diff --git a/.gitignore b/.gitignore
index 38965d1..afdd12e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,5 @@
 02-EnergyModel/*.tar.gz
 02-EnergyModel/*.tar
 02-EnergyModel/*.Rhistory
+*.egg-info
+*__pycache__
\ No newline at end of file
diff --git a/01-ActivityModel/activity-model/README.md b/01-ActivityModel/activity-model/README.md
index f6cea5b..d49084e 100644
--- a/01-ActivityModel/activity-model/README.md
+++ b/01-ActivityModel/activity-model/README.md
@@ -29,7 +29,7 @@ machine:
 
 ```bash
 $ git clone https://github.com/anetobradley/energy_flex.git
-$ cd energy_flex/01-ActivityModel/activity-model/
+$ cd 01-ActivityModel/activity-model/
 ```
 
 This package requires a specific
@@ -59,6 +59,7 @@ $ nano config/user.yaml
 #  EPC credentials
 epc_user: "user@email"
 epc_key: "user_key"
+# the epc key can be found at the bottom of the https://epc.opendatacommunities.org/ website next to the email you have used to log in.
 ```
 
 #### Local Authority codes
diff --git a/01-ActivityModel/activity-model/activity_model/__main__.py b/01-ActivityModel/activity-model/activity_model/__main__.py
index 83d09f3..b82bde0 100644
--- a/01-ActivityModel/activity-model/activity_model/__main__.py
+++ b/01-ActivityModel/activity-model/activity_model/__main__.py
@@ -4,7 +4,7 @@
 from enriching_population import EnrichingPopulation
 
 if __name__ == "__main__":
-    print("hi")
+    print("Running the Activity model process, this can take a while, depending on how many areas you have added.")
     spenser = Spenser()
     epc = Epc()
     psm = EnrichingPopulation()
diff --git a/01-ActivityModel/activity-model/build/lib/activity_model/__init__.py b/01-ActivityModel/activity-model/build/lib/activity_model/__init__.py
new file mode 100644
index 0000000..b794fd4
--- /dev/null
+++ b/01-ActivityModel/activity-model/build/lib/activity_model/__init__.py
@@ -0,0 +1 @@
+__version__ = '0.1.0'
diff --git a/01-ActivityModel/activity-model/build/lib/activity_model/__main__.py b/01-ActivityModel/activity-model/build/lib/activity_model/__main__.py
new file mode 100644
index 0000000..83d09f3
--- /dev/null
+++ b/01-ActivityModel/activity-model/build/lib/activity_model/__main__.py
@@ -0,0 +1,28 @@
+import yaml
+
+from data_preparation import Epc, Spenser
+from enriching_population import EnrichingPopulation
+
+if __name__ == "__main__":
+    print("hi")
+    spenser = Spenser()
+    epc = Epc()
+    psm = EnrichingPopulation()
+
+    list_df = []
+    list_df_names = []
+    lad_codes_yaml = open("config/lad_codes.yaml")
+    parsed_lad_codes = yaml.load(lad_codes_yaml, Loader=yaml.FullLoader)
+    lad_codes = parsed_lad_codes.get("lad_codes")
+
+    for lad_code in lad_codes:
+        spenser_df = spenser.step(lad_code)
+        epc_df = epc.step(lad_code)
+        rich_df = psm.step(
+            spenser_df, epc_df, lad_code, psm_fig=True, validation_fig=True
+        )
+        list_df_names.append("_".join([lad_code, "hh_msm_epc.csv"]))
+        list_df.append(rich_df)
+
+    psm.save_enriched_pop(list_df_names, list_df)
+
diff --git a/01-ActivityModel/activity-model/build/lib/activity_model/data_preparation.py b/01-ActivityModel/activity-model/build/lib/activity_model/data_preparation.py
new file mode 100644
index 0000000..7e96b17
--- /dev/null
+++ b/01-ActivityModel/activity-model/build/lib/activity_model/data_preparation.py
@@ -0,0 +1,350 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import yaml
+import pandas as pd
+import requests
+import io
+import zipfile
+
+
+class Epc:
+    """Class to represent the SPENSER data and related parameters/methods."""
+
+    def __init__(self) -> None:
+        """Initialise an EPC class."""
+        # Configure epc api related parameters from "config/epc_api.yaml"
+        epc_api_yaml = open("config/epc_api.yaml")
+        parsed_epc_api = yaml.load(epc_api_yaml, Loader=yaml.FullLoader)
+        self.epc_user = parsed_epc_api.get("epc_user")
+        self.epc_key = parsed_epc_api.get("epc_key")
+        self.epc_url = parsed_epc_api.get("epc_url")
+        self.epc_years = parsed_epc_api.get("epc_years")
+        self.desired_headers = parsed_epc_api.get("epc_headers")
+
+        # Using epc api info to build all base url-filter
+        self.epc_filter = self.get_epc_url_filter()
+
+        # Configure lookups
+        ## Lookups from "config/lookups.yaml" file
+        lookup_yaml = open("config/lookups.yaml")
+        parsed_lookup = yaml.load(lookup_yaml, Loader=yaml.FullLoader)
+        self.accommodation_lookup = parsed_lookup.get("accommodation")
+        self.age_categorical_lookup = parsed_lookup.get("age_categorical")
+        self.age_numerical_lookup = parsed_lookup.get("age_numerical")
+        self.floor_area_lookup = parsed_lookup.get("floor_area")
+        self.gas_lookup = parsed_lookup.get("gas")
+        self.tenure_lookup = parsed_lookup.get("tenure")
+        url = parsed_lookup.get("area_url")
+        area_in_out = parsed_lookup.get("area_in_out")
+        area_lookup = pd.read_csv(
+            url,
+            compression="zip",
+            # usecols=[area_in, area_out],
+            usecols=[area_in_out[0], area_in_out[1]],
+            encoding="unicode_escape",
+            engine="python",
+        )
+        self.area_lookup = (
+            area_lookup.set_index(area_in_out[0], drop=True)
+            .loc[:, area_in_out[1]]
+            .to_dict()
+        )
+
+    def get_epc_url_filter(self):
+        """Build a list of EPC search filters urls.
+
+        According to EPC-API
+        [documentation](https://epc.opendatacommunities.org/docs/api/domestic)
+        the API is designed to return up to 10,000 records at a time, with a
+        maximum page size of 5,000. If more than 10,000 records are required,
+        is necessary to vary the search filters and make multiple requests.
+
+        This method returns a list of filter urls to get the maximum possible
+        volume of data. Each filter url covers 4 months.
+
+        :return: EPC-API urls with filters.
+        :rtype: list
+        """
+
+        url_filter = []
+        for i in range(self.epc_years[0], self.epc_years[1], 1):
+            for j in range(3):
+                for k in range(2):
+                    search = f"size=5000&from-year={i}&from-month={(j*4)+1}&to-year={i}&to-month={(j+1)*4}&from={k*5000}&local-authority="
+                    url_filter.append(self.epc_url + search)
+        return url_filter
+
+    def get_epc_dataframe(self, lad_code) -> pd.DataFrame:
+        """Get EPC data for a given local authority.
+
+        This function uses the EPC-API to get a large amount of data.
+        Due to data limitation per request, several filters are considered.
+
+        Note 1: You need insert a valid EPC user/key (config/epc_api.yaml)
+
+        Note 2: Some data interval return Null value (usually in early 2008) and
+        an exception is used to avoid errors in this case.
+
+        :param lad_code: Local authority code.
+        :type lad_code: string
+        :return: A data frame with all EPC collected data.
+        :rtype: pandas.DataFrame
+        """
+        url_filter = [s + lad_code for s in self.epc_filter]
+        headers = {"Accept": "text/csv"}
+        list_df = []
+        for url in url_filter:
+            try:
+                res = requests.get(
+                    url, headers=headers, auth=(self.epc_user, self.epc_key)
+                ).content
+                df = pd.read_csv(
+                    io.StringIO(res.decode("utf-8")), usecols=self.desired_headers
+                )
+                list_df.append(df)
+            except pd.errors.EmptyDataError:
+                """
+                Some data interval return Null value (usually in early 2008).
+                This Exception is raised to avoid errors in this situation.
+                Warning: Problems in EPC-API may be difficult to follow.
+                """
+                pass
+        return pd.concat(list_df)
+
+    @staticmethod
+    def remove_duplicates(df):
+        """Remove EPC Duplicate Certificates
+
+        When using the EPC datasets we need to be careful with duplicate EPCs
+        for the same property. While not an enormous issue as an EPC is valid
+        for up to 10 years unless the property is renovated or retrofitted,
+        there may be multiple records especially for rental properties which are
+        improved to meet recent regulations.
+
+        This function removing duplicates with the same BUILDING REFERENCE 
+        NUMBER by selecting the most recent record and discarding others.
+        
+        :param df: Raw EPC dataset.
+        :type df: pandas.DataFrame
+        :return: EPC dataset without duplicate Certificates.
+        :rtype: pandas.DataFrame
+        """
+        df["lodgement-datetime"] = pd.to_datetime(df["lodgement-datetime"])
+        df = df.sort_values(by=["building-reference-number", "lodgement-datetime"])
+        df.drop_duplicates(
+            subset=["building-reference-number"], keep="last", inplace=True
+        )
+        df.sort_index(inplace=True)
+        df.reset_index(drop=True, inplace=True)
+        drop_list = ["building-reference-number", "lodgement-datetime"]
+        df.drop(drop_list, axis=1, inplace=True)
+        return df
+
+    @staticmethod
+    def set_categorical_code(df, df_col, lookup, rename=False):
+        """ Apply the lookup to a categorical column.
+        
+        Transform the values in a dataframe column using a lookup dictionary.
+        This method is valid when the column values are categorical.
+
+        :param df:  The input dataframe.
+        :type df: pandas.dataframe
+        :param df_col: The column in df that represents the categorical values.
+        :type df_col: string
+        :param lookup: A dictionary from categorical values to categorical codes.
+        :type lookup: dict
+        :param rename: The new column name after transformation (if false, keep 
+            the current name), defaults to False.
+        :type rename: bool, optional
+        :return: Returns the data with the updated column.
+        :rtype: pandas.DataFrame
+        """
+
+        # This looks redundant, but ensures that the function works even for
+        # missing values (returning empty code).
+        def augment(x, lookup):
+            try:
+                return lookup[x]
+            except:
+                return
+
+        # setting new values according the rename_dict
+        df[df_col] = df[df_col].apply(func=lambda x: augment(x, lookup))
+
+        # remove empty rows
+        df.dropna(subset=[df_col], inplace=True)
+
+        # rename column
+        if rename:
+            df.rename({df_col: rename}, axis=1, inplace=True)
+
+    @staticmethod
+    def set_numerical_code(df, df_col, lookup, rename=False):
+        """Apply the lookup to a numerical column
+
+        Transform the values in a dataframe column using a lookup dictionary.
+        This method is valid when the column values are numerical, following 
+        the rule:
+        
+        if (j < value <= k), then, (value = i).
+
+        :param df: The input dataframe.
+        :type df: pandas.dataframe
+        :param df_col: The column in df that represents the numerical values.
+        :type df_col: string
+        :param lookup: A dictionary from numerical values to numerical codes;
+            The dictionary structure is [[i1, j1, k1], [i2, j2, k2], ..., 
+            [iN, jN, kN]], where: iN is the desired code for band N, jN is the
+            minimum value of the band N (not included), kN is the maximum value
+            of the band N (included), and N is the number of bands.
+        :type lookup: dict
+        :param rename: The new column name after transformation (if false, keep
+            the current name), defaults to False.
+        :type rename: bool, optional
+        """
+        for band in lookup:
+            df.loc[(df[df_col] > band[1]) & (df[df_col] <= band[2]), df_col] = band[0]
+
+        # remove out bound and empty rows
+        df.dropna(subset=[df_col], inplace=True)
+
+        if rename:
+            df.rename({df_col: rename}, axis=1, inplace=True)
+
+    def set_lookups(self, df):
+        """Update all columns using the lookups dictionaries.
+
+        Update the information related with area, tenure, accommodation type,
+        construction age band, main gas flag, and floor area, by using the self
+        lookup variables (accommodation_lookup, age_categorical_lookup,
+        age_numerical_lookup, floor_area_lookup, gas_lookup, tenure_lookup,
+        area_lookup) and the set_categorical_code and set_numerical_code
+        functions.
+
+        :param df: Dataframe with EPC information.
+        :type df: pandas.Dataframe
+        """
+        # Area: change area from postcode to output area
+        self.set_categorical_code(df, "postcode", self.area_lookup, rename="Area")
+
+        # Tenure: change the tenure from EPC to SPENSER classification
+        self.set_categorical_code(df, "tenure", self.tenure_lookup)
+
+        # Accommodation type:
+        # - create an EPC accommodation type by combining "property-type" and "built-form"
+        # - change the accommodation type from EPC to SPENSER classification
+        # - discard "property-type" and "built-form" columns
+        df["LC4402_C_TYPACCOM"] = df["property-type"] + ": " + df["built-form"]
+        self.set_categorical_code(df, "LC4402_C_TYPACCOM", self.accommodation_lookup)
+        df.pop("property-type")
+        df.pop("built-form")
+
+        # Construction age band:
+        # - initially is a combination of categorical and numeric values
+        # - convert all categorical values into absolute ages
+        # - groups the absolute build age into bands
+        self.set_categorical_code(
+            df,
+            "construction-age-band",
+            self.age_categorical_lookup,
+            rename="ACCOM_AGE",
+        )
+        df["ACCOM_AGE"] = df["ACCOM_AGE"].apply(pd.to_numeric)
+        self.set_numerical_code(df, "ACCOM_AGE", self.age_numerical_lookup)
+
+        # Main gas flag: change the values (N, Y) to (0, 1)
+        self.set_categorical_code(df, "mains-gas-flag", self.gas_lookup, rename="GAS")
+
+        # Floor Area: groups the absolute area into bands
+        area_max_lim = self.floor_area_lookup[-1][2]
+        df.rename({"total-floor-area": "FLOOR_AREA"}, axis=1, inplace=True)
+        df.drop(df[df.FLOOR_AREA > area_max_lim].index, inplace=True)
+        self.set_numerical_code(df, "FLOOR_AREA", self.floor_area_lookup)
+
+    def step(self, lad_code):
+        """EPC data preparation main step.
+
+        For each given local authority, this functions get the raw EPC data
+        using an API approach and then return a processed EPC dataset.
+
+        :param lad_code: Local authority code.
+        :type lad_code: string
+        :return: processed EPC data
+        :rtype: pandas.DataFrame
+        """
+        # Create EPC dataframe for local authority lad_code
+        df = self.get_epc_dataframe(lad_code)
+
+        df = self.remove_duplicates(df)
+
+        # Apply all lookups
+        self.set_lookups(df)
+
+        # Change selected columns to integer values
+        cols = ["FLOOR_AREA", "ACCOM_AGE", "GAS", "tenure", "LC4402_C_TYPACCOM"]
+        df[cols] = df[cols].applymap(np.int64)
+        return df
+
+
+class Spenser:
+    """Class to represent the SPENSER data and related parameters/methods."""
+
+    def __init__(self) -> None:
+        """Initialise a Spenser class."""
+        # Configure SPENSER related parameters from "config/spenser.yaml"
+        spenser_yaml = open("config/spenser.yaml")
+        parsed_spenser = yaml.load(spenser_yaml, Loader=yaml.FullLoader)
+        spenser_url = parsed_spenser.get("spenser_url")
+        r = requests.get(spenser_url)
+        self.spenser_zip_file = zipfile.ZipFile(io.BytesIO(r.content))
+
+    def set_new_tenure(self, df) -> pd.DataFrame:
+        """Create new temporary tenure column
+
+        This method creates a new tenure column (following EPC values) where
+        the sub-categories 
+        - "Owned outright"(=2)
+        - shared ownership" (=3)
+        are merged into a general "Owner-occupied" (=1) category.
+
+        :param df: original SPENSER data frame
+        :type df: pandas.Dataframe
+        :return: SPENSER data frame with a new column
+        :rtype: pandas.DataFrame
+        """
+        df["tenure"] = df["LC4402_C_TENHUK11"].copy()
+        df.loc[(df["tenure"] == 2), "tenure"] = 1
+        df.loc[(df["tenure"] == 3), "tenure"] = 1
+        df["tenure"] = df["tenure"].map(np.int64)
+
+        return df
+
+    def step(self, lad_code):
+        """SPENSER data preparation main step.
+
+        For each given local authority, this functions get the raw EPC data
+        from a zip file and then return a processed SPENSER dataset.
+
+        :param lad_code: Local authority code.
+        :type lad_code: string
+        :return: processed SPENSER data
+        :rtype: pandas.DataFrame
+        """
+
+        # From the zipfile - open the local authority file
+        lad_file = "_".join(["msm_england/ass_hh", lad_code, "OA11_2020.csv"])
+        df = pd.read_csv(self.spenser_zip_file.open(lad_file))
+
+        # Remove "empty" rows: empty codes (here, negative values) are a problem
+        # for PSM method.
+        # TODO: store the "empty" rows in other variable to be possible append
+        # then at the end.
+        df.drop(df[df.LC4402_C_TENHUK11 < 0].index, inplace=True)
+        df.drop(df[df.LC4402_C_TYPACCOM < 0].index, inplace=True)
+
+        # create new tenure
+        df = self.set_new_tenure(df)
+
+        return df
diff --git a/01-ActivityModel/activity-model/build/lib/activity_model/enriching_population.py b/01-ActivityModel/activity-model/build/lib/activity_model/enriching_population.py
new file mode 100644
index 0000000..13e89a5
--- /dev/null
+++ b/01-ActivityModel/activity-model/build/lib/activity_model/enriching_population.py
@@ -0,0 +1,324 @@
+from random import choices
+import zipfile
+from causalinference import CausalModel
+import numpy as np
+import pandas as pd
+from sklearn.neighbors import NearestNeighbors
+import yaml
+import seaborn as sns
+import matplotlib.pyplot as plt
+import os
+from matplotlib.ticker import MaxNLocator
+
+
+class EnrichingPopulation:
+    """Class to enrich a synthetic population.
+
+    To create a enriched synthetic population, this class combines two
+    pandas.DataFrames using the Propensity Score Machting approach.
+    """
+
+    def __init__(self) -> None:
+        """Initialise an EnrichingPopulation class."""
+        # Configure PSM related parameters from "config/psm.yaml"
+        psm_yaml = open("config/psm.yaml")
+        parsed_psm = yaml.load(psm_yaml, Loader=yaml.FullLoader)
+        self.n_neighbors = parsed_psm.get("n_neighbors")
+        self.overlap_columns = parsed_psm.get("overlap_columns")
+        self.matches_columns = parsed_psm.get("matches_columns")
+
+    @staticmethod
+    def set_treatment(df0, df1):
+        """Create a "Treatment" column in each dataframe.
+
+        :param df0: SPENSER data
+        :type df0: pandas.DataFrame
+        :param df1: EPC data
+        :type df1: pandas.DataFrame
+        :return: Two dataframes, first the SPENSER data + new column 
+            ("Treatment" = 0), second the EPC data + new column ("Treatment" = 1)
+        :rtype: pandas.DataFrame, pandas.DataFrame
+        """
+
+        df0["Treatment"] = 0
+        df1["Treatment"] = 1
+
+        return df0, df1
+
+    @staticmethod
+    def set_area_factor(df):
+        """Add a new Area column by factorizing the Area codes.
+
+        :param df: Dataset with a Area column.
+        :type df: pandas.DataFrame
+        :return: Input dataset + new factorized Area column
+        :rtype: pandas.DataFrame
+        """
+        Area_factor = df.Area.factorize()
+        df["Area_factor"] = Area_factor[0]
+
+        return df
+
+    @staticmethod
+    def get_propensity_score(df, overlap_columns):
+        """Return the propensity score values.
+
+        :param df: complete dataframe
+        :type df: pandas.DataFrame
+        :param overlap_columns: list of columns names that are present in both
+            datasets (EPC and SPENSER).
+        :type overlap_columns: list
+        :return: list of propensity score for all rows.
+        :rtype: numpy.ndarray
+        """
+
+        ## Isolate the Y, X and the covariates
+        Y = df["Treatment"].copy()  # 1-Dimension outcome - arbitrary values
+        X = df["Treatment"].copy()  # 1-Dimension treatment
+        C = df[overlap_columns].copy()  # n-Dimension covariates
+
+        # Transform pandas dataframe into numpy.ndarray (CausalModel requisite)
+        Y = Y.values
+        X = X.values
+        C = C.values
+
+        # Create the Causal Model
+        model = CausalModel(Y, X, C)
+
+        # Propensity score calculation
+        model.est_propensity_s()
+        return model.propensity["fitted"]
+
+    @staticmethod
+    def get_neighbors(df1, df2, n_neighbors):
+        """For each SPENSER row get a list of EPC rows with the closest propensity score values.
+
+        :param df1: SPENSER dataset
+        :type df1: pandas.DataFrame
+        :param df2: EPC dataset
+        :type df2: pandas.DataFrame
+        :param n_neighbors: Number of neighbors.
+        :type n_neighbors: integer
+        :return: The propensity score difference and the indices of the closest neighbors.
+        :rtype: list, list
+        """
+        # create the neighbors object (p=2 means Euclidean distance)
+        knn = NearestNeighbors(n_neighbors=n_neighbors, p=2).fit(df2[["ps"]])
+
+        # for each household in df1 dataframe, find the nearest df2 neighbors
+        distances, indices = knn.kneighbors(df1[["ps"]])
+        return distances, indices
+
+    @staticmethod
+    def get_matches(distances, indices, n_neighbors):
+        """From the neighbors list get one match for each SPENSER row.
+
+        EPC rows with the same propensity score value have the same probability
+        of being matched with a SPENSER row. The greater the difference between
+        the propensity score values, the lower the probability of being drawn.
+        The weight function used, is a step function.
+
+        :param distances: List of propensity score difference between the closest neighbors.
+        :type distances: list
+        :param indices: List of the closest neighbors indices.
+        :type indices: list
+        :param n_neighbors: Number of neighbors.
+        :type n_neighbors: integer
+        :return: List of assigned pairs.
+        :rtype: list
+        """
+        pairs = []
+        for index1, candidates2 in enumerate(indices):
+            is_zero = np.flatnonzero(distances[index1] == 0)
+            if is_zero.size < n_neighbors:
+                weight = 100 - (distances[index1] / distances[index1][-1] * 95)
+                index2 = choices(candidates2, weights=weight)[0]
+            else:
+                index2 = choices(candidates2)[0]
+            pairs.append([index1, index2])
+
+        return pairs
+
+    @staticmethod
+    def get_enriched_pop(pairs, df1, df2, matches_columns):
+        """Returns the SPENSER enriched population.
+
+        Combine the EPC data with the SPENSER data to generated a enriched
+        synthetic population. To combine the datasets, the propensity score
+        matching method is used.
+
+        :param pairs: List of assigned pairs.
+        :type pairs: list
+        :param df1: SPENSER dataset.
+        :type df1: pandas.DataFrame
+        :param df2: EPC dataset.
+        :type df2: pandas.DataFrame
+        :param matches_columns: List of columns name from EPC to be incorporated
+            into SPENSER dataset.
+        :type matches_columns: list
+        :return: The enriched synthetic population
+        :rtype: pandas.DataFrame
+        """
+        # Add matched df2 index id in df1 dataframe
+        matches = pd.DataFrame(pairs)
+        df1["EPCid"] = matches[1]
+
+        drop_list = [
+            "tenure",
+            "ps",
+            "Treatment",
+            "Area_factor",
+            *matches_columns,
+        ]
+        df1.drop(drop_list, axis=1, inplace=True)
+
+        df2 = df2[matches_columns].copy()
+        df2["EPCid"] = df2.index
+
+        df1 = pd.merge(df1, df2, on="EPCid", how="left")
+        df1.drop(["EPCid"], axis=1, inplace=True)
+
+        return df1
+
+    @staticmethod
+    def save_enriched_pop(list_df_names, list_df):
+        """Save the synthetic population.
+
+        Save the synthetic population into a zip file. Each local authority is
+        stored in a different csv file.
+
+        :param list_df_names: Names of each csv file.
+        :type list_df_names: list
+        :param list_df: List of dataframes.
+        :type list_df: list
+        """
+        if not (os.path.exists("data/output/")):
+            os.makedirs("data/output/")
+
+        # save final population
+        csv_name = os.path.join("data/output/", "msm_epc_england.zip")
+        with zipfile.ZipFile(csv_name, "w") as csv_zip:
+            for i in range(len(list_df_names)):
+                csv_zip.writestr(
+                    list_df_names[i], list_df[i].to_csv(index=False, header=True)
+                )
+
+    @staticmethod
+    def save_psm_fig(df, lad_code):
+        """Save the propensity score distribution image.
+
+        This image is a way to visualize the compatibility between the two
+        datasets.
+
+        :param df: SPENSER + EPC merged dataset.
+        :type df: pandas.DataFrame
+        :param lad_code: Local authority district code.
+        :type lad_code: string
+        """
+        if not (os.path.exists("data/output/")):
+            os.makedirs("data/output/")
+
+        sns.set(color_codes=True)
+        # Propensity score comparison plot
+        plt.figure(figsize=(10, 7), dpi=80)
+        sns.kdeplot(df["ps"], hue=df["Treatment"], shade=True)
+
+        # * MSM: `Treatment` = 0
+        # * EPC: `Treatment` = 1
+        plt.xlabel("Propensity Score")
+        fig_name = "_".join([lad_code, "propensity_score.png"])
+        fig_name = os.path.join("data/output/", fig_name)
+        plt.savefig(fig_name)
+        plt.close()
+
+    @staticmethod
+    def save_validation_fig(df1, df2, lad_code):
+        """Save the internal validation image.
+
+        Floor Area distribution and Accommodation age codes distribution
+        comparison between original EPC data and Enriched Synthetic population.
+
+        :param df1: SPENSER dataset.
+        :type df1: pandas.DataFrame
+        :param df2: EPC dataset.
+        :type df2: pandas.DataFrame
+        :param lad_code: Local authority district code.
+        :type lad_code: string
+        """
+        if not (os.path.exists("data/output/")):
+            os.makedirs("data/output/")
+
+        fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(16, 10))
+
+        bins = list(range(1, 20, 1))
+        df2.FLOOR_AREA.plot(kind="hist", ax=ax[0][0], title="EPC", bins=bins)
+        df2.ACCOM_AGE.plot(kind="hist", ax=ax[1][0], title="EPC", bins=10)
+
+        df1.FLOOR_AREA.plot(
+            kind="hist", ax=ax[0][1], title="Enriched SPENSER", bins=bins
+        )
+        df1.ACCOM_AGE.plot(kind="hist", ax=ax[1][1], title="Enriched SPENSER", bins=10)
+
+        ax[0][0].xaxis.set_major_locator(MaxNLocator(integer=True))
+        ax[0][1].xaxis.set_major_locator(MaxNLocator(integer=True))
+
+        ax[0][0].set_xlabel("Floor area code")
+        ax[0][1].set_xlabel("Floor area code")
+
+        ax[1][0].set_xlabel("Accommodation age code")
+        ax[1][1].set_xlabel("Accommodation age code")
+
+        fig.tight_layout(pad=3.0)
+        fig_name = "_".join([lad_code, "validation.png"])
+        fig_name = os.path.join("data/output/", fig_name)
+        plt.savefig(fig_name)
+        plt.close()
+
+    def step(self, df0, df1, lad_code, psm_fig=True, validation_fig=True):
+        """Enriching population main step.
+
+        In this step the EPC data and the SPENSER data are combined to generate
+        an enriched synthetic population for a given local authority.
+
+        :param df0: SPENSER dataset.
+        :type df0: pandas.DataFrame
+        :param df1: EPC dataset.
+        :type df1: pandas.DataFrame
+        :param lad_code: Local authority district code.
+        :type lad_code: string
+        :param psm_fig: Boolean to save the propensity score distribution image, defaults to True.
+        :type psm_fig: bool, optional
+        :param validation_fig: Boolean to save the internal validation image, defaults to True.
+        :type validation_fig: bool, optional
+        :return: Enriched synthetic population
+        :rtype: pandas.DataFrame
+        """
+        df0, df1 = self.set_treatment(df0, df1)
+        dataset = pd.concat([df0, df1], ignore_index=True, sort=False)
+        dataset = self.set_area_factor(dataset)
+        dataset["ps"] = self.get_propensity_score(dataset, self.overlap_columns)
+
+        # TODO instead save the image every step, the image should be stored in
+        # a list. The list should be saved as zip file at the end.
+        if psm_fig:
+            self.save_psm_fig(dataset, lad_code)
+
+        # Separating EPC data from MSM data
+        df0 = dataset.loc[dataset.Treatment == 0].reset_index(drop=True)
+        df1 = dataset.loc[dataset.Treatment == 1].reset_index(drop=True)
+        del dataset
+
+        # Get neighbors and matched pairs
+        distances, indices = self.get_neighbors(df0, df1, self.n_neighbors)
+        pairs = self.get_matches(distances, indices, self.n_neighbors)
+        del distances, indices
+
+        # Get enriched population
+        rich_df = self.get_enriched_pop(pairs, df0, df1, self.matches_columns)
+
+        # TODO instead save the image every step, the image should be stored in
+        # a list. The list should be saved as zip file at the end.
+        if validation_fig:
+            self.save_validation_fig(rich_df, df1, lad_code)
+
+        return rich_df
diff --git a/01-ActivityModel/activity-model/build/lib/tests/__init__.py b/01-ActivityModel/activity-model/build/lib/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/01-ActivityModel/activity-model/build/lib/tests/test_activity_model.py b/01-ActivityModel/activity-model/build/lib/tests/test_activity_model.py
new file mode 100644
index 0000000..6d0a755
--- /dev/null
+++ b/01-ActivityModel/activity-model/build/lib/tests/test_activity_model.py
@@ -0,0 +1,48 @@
+from activity_model import __version__
+from activity_model.data_preparation import Epc
+
+import requests
+import pytest
+
+
+def test_version():
+    assert __version__ == "0.1.0"
+
+
+@pytest.fixture
+def epc():
+    epc = Epc()
+    return epc
+
+
+def test_lookup_type(epc):
+    assert type(epc.accommodation_lookup) is dict
+    assert type(epc.age_categorical_lookup) is dict
+    assert type(epc.gas_lookup) is dict
+    assert type(epc.tenure_lookup) is dict
+    assert type(epc.age_numerical_lookup) is list
+    assert type(epc.floor_area_lookup) is list
+    assert type(epc.area_lookup) is dict
+
+
+def test_epc_connection(epc):
+    url = epc.epc_url
+    user = epc.epc_user
+    key = epc.epc_key
+    headers = {"Accept": "text/csv"}
+
+    r = requests.head(url, headers=headers, auth=(user, key))
+    assert (
+        r.status_code == 200
+    ), "Please check your EPC credentials here: config/epc_api.yaml"
+
+
+# test area lookup connection?
+# test spenser connection?
+
+# test if area column has the right values
+# test if floor area has the right values
+# test if age has the right values
+# test if gas has the right values
+# test if tenure has the right values
+# test if accommodation type has the right values
diff --git a/01-ActivityModel/activity-model/config/epc_api.yaml b/01-ActivityModel/activity-model/config/epc_api.yaml
index d3e572b..c9f84bb 100644
--- a/01-ActivityModel/activity-model/config/epc_api.yaml
+++ b/01-ActivityModel/activity-model/config/epc_api.yaml
@@ -4,8 +4,8 @@
 ################################################################################
 
 #  EPC credentials
-epc_user: "user@email"
-epc_key: "user_key"
+epc_user: "fbenitez@turing.ac.uk"
+epc_key: "835bf8345666a63362b6f327dc138b8c78a2d80d"
 
 epc_url: "https://epc.opendatacommunities.org/api/v1/domestic/search?"
 
diff --git a/01-ActivityModel/activity-model/config/lad_codes.yaml b/01-ActivityModel/activity-model/config/lad_codes.yaml
index 6f7054a..5be518d 100644
--- a/01-ActivityModel/activity-model/config/lad_codes.yaml
+++ b/01-ActivityModel/activity-model/config/lad_codes.yaml
@@ -5,4 +5,5 @@
 ################################################################################
 
 lad_codes:
-  - E09000014
\ No newline at end of file
+  - E09000014
+  - E08000035
\ No newline at end of file
diff --git a/01-ActivityModel/activity-model/data/output/E08000035_propensity_score.png b/01-ActivityModel/activity-model/data/output/E08000035_propensity_score.png
new file mode 100644
index 0000000..9e68190
Binary files /dev/null and b/01-ActivityModel/activity-model/data/output/E08000035_propensity_score.png differ
diff --git a/01-ActivityModel/activity-model/data/output/E08000035_validation.png b/01-ActivityModel/activity-model/data/output/E08000035_validation.png
new file mode 100644
index 0000000..70c2224
Binary files /dev/null and b/01-ActivityModel/activity-model/data/output/E08000035_validation.png differ
diff --git a/01-ActivityModel/activity-model/data/output/E09000014_propensity_score.png b/01-ActivityModel/activity-model/data/output/E09000014_propensity_score.png
new file mode 100644
index 0000000..e530594
Binary files /dev/null and b/01-ActivityModel/activity-model/data/output/E09000014_propensity_score.png differ
diff --git a/01-ActivityModel/activity-model/data/output/E09000014_validation.png b/01-ActivityModel/activity-model/data/output/E09000014_validation.png
new file mode 100644
index 0000000..f635fbf
Binary files /dev/null and b/01-ActivityModel/activity-model/data/output/E09000014_validation.png differ
diff --git a/01-ActivityModel/activity-model/dist/activity_model-0.1.0-py3.9.egg b/01-ActivityModel/activity-model/dist/activity_model-0.1.0-py3.9.egg
new file mode 100644
index 0000000..d96cf4e
Binary files /dev/null and b/01-ActivityModel/activity-model/dist/activity_model-0.1.0-py3.9.egg differ
diff --git a/01-ActivityModel/activity_model.ipynb b/01-ActivityModel/activity_model.ipynb
index 7ff67f6..353e1a8 100644
--- a/01-ActivityModel/activity_model.ipynb
+++ b/01-ActivityModel/activity_model.ipynb
@@ -315,7 +315,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]