We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
AttributeError for LocalConfig during replication
### Expected behaviour
SSHTunnel for replication doesn't open due to AttributeError. I have tried to understand the replication process and ran also a separate script that failed with same error. 

### Actual behaviour
```
AttributeError: 'LocalConfig' object has no attribute 'db_hostname'
```

### Steps to reproduce the behaviour

```python
from paramiko import SSHClient, WarningPolicy
from sshtunnel import SSHTunnelForwarder
from datacube.config import LocalConfig, _DEFAULT_CONF
from configparser import ConfigParser

client = SSHClient()
client.load_system_host_keys()
client.set_missing_host_key_policy(WarningPolicy())
client.connect(hostname="host", username="user")
sftp = client.open_sftp()


remote_config = ConfigParser()
remote_config.read_string(_DEFAULT_CONF)
with sftp.open('.datacube.conf') as fin:
    remote_config.read_file(fin)

config = LocalConfig(remote_config)
print(config.db_hostname)

client.close()
```
Same with
```
datacube-simple-replica
```

### Environment information

* Which ``datacube --version`` are you using? 1.7
* What datacube deployment/enviornment are you running against? Conda environment + postgres docker db


--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `datacube_apps/simple_replica.py`
Content:
```
1 #!/usr/bin/env python
2 """
3 A Simple Data Cube Replication Tool
4 
5 Connects to a remote Data Cube via SSH, and downloads database records and files to a local file system and database.
6 
7 Provide a configuration file in ~/.datacube.replication.conf in YAML format, or specify an alternate location
8 on the command line.
9 
10 For example, the following config will download 3 PQ products for the specified time and space range. Queries
11 are specified the same as when using the API to search for datasets.
12 
13 .. code-block:: yaml
14 
15     remote_host: raijin.nci.org.auo
16     remote_user: dra547
17     db_password: xxxxxxxxxxxx
18     remote_dir: /g/data/
19     local_dir: C:/datacube/
20 
21     replicated_data:
22     - product: ls5_pq_albers
23       crs: EPSG:3577
24       x: [1200000, 1300000]
25       y: [-4200000, -4300000]
26       time: [2008-01-01, 2010-01-01]
27 
28     - product: ls7_pq_albers
29       crs: EPSG:3577
30       x: [1200000, 1300000]
31       y: [-4200000, -4300000]
32       time: [2008-01-01, 2010-01-01]
33 
34     - product: ls8_pq_albers
35       crs: EPSG:3577
36       x: [1200000, 1300000]
37       y: [-4200000, -4300000]
38       time: [2008-01-01, 2010-01-01]
39 
40 """
41 
42 import logging
43 import os.path
44 from configparser import ConfigParser
45 from pathlib import Path
46 
47 import click
48 import yaml
49 from paramiko import SSHClient, WarningPolicy
50 from sshtunnel import SSHTunnelForwarder
51 from tqdm import tqdm
52 
53 from datacube import Datacube
54 from datacube.config import LocalConfig, _DEFAULT_CONF
55 from datacube.index import index_connect
56 from datacube.ui.click import global_cli_options
57 
58 LOG = logging.getLogger('simple_replicator')
59 
60 DEFAULT_REPLICATION_CONFIG = os.path.expanduser('~/.datacube.replication.conf')
61 
62 
63 def uri_to_path(uri):
64     return uri.replace('file://', '')
65 
66 
67 class DatacubeReplicator(object):
68     def __init__(self, config):
69         self.remote_host = config['remote_host']
70         self.remote_user = config['remote_user']
71         self.db_password = config['db_password']
72         self.remote_dir = config['remote_dir']
73         self.local_dir = config['local_dir']
74         self.replication_defns = config['replicated_data']
75 
76         self.client = None
77         self.sftp = None
78         self.tunnel = None
79         self.remote_dc_config = None
80         self.remote_dc = None
81         self.local_index = index_connect()
82 
83     def run(self):
84         self.connect()
85         self.read_remote_config()
86         self.connect_to_db()
87         self.replicate_all()
88         self.disconnect()
89 
90     def connect(self):
91         client = SSHClient()
92         client.load_system_host_keys()
93         client.set_missing_host_key_policy(WarningPolicy())
94         client.connect(hostname=self.remote_host, username=self.remote_user)
95 
96         LOG.debug(client)
97         self.client = client
98         self.sftp = client.open_sftp()
99 
100     def disconnect(self):
101         self.client.close()
102         self.tunnel.stop()
103 
104     def read_remote_config(self):
105         remote_config = ConfigParser()
106         remote_config.read_string(_DEFAULT_CONF)
107         with self.sftp.open('.datacube.conf') as fin:
108             remote_config.read_file(fin)
109         self.remote_dc_config = LocalConfig(remote_config)
110 
111     def connect_to_db(self):
112         self.tunnel = SSHTunnelForwarder(
113             self.remote_host,
114             ssh_username=self.remote_user,
115             remote_bind_address=(self.remote_dc_config.db_hostname, int(self.remote_dc_config.db_port)))
116         self.tunnel.start()
117 
118         # pylint: disable=protected-access
119         self.remote_dc_config._config['datacube']['db_hostname'] = '127.0.0.1'
120         self.remote_dc_config._config['datacube']['db_port'] = str(self.tunnel.local_bind_port)
121         self.remote_dc_config._config['datacube']['db_username'] = self.remote_user
122         self.remote_dc_config._config['datacube']['db_password'] = self.db_password
123 
124         # This requires the password from somewhere
125         # Parsing it out of .pgpass sounds error prone and fragile
126         # Lets put it in the configuration for now
127         LOG.debug('Remote configuration loaded %s', self.remote_dc_config)
128 
129         self.remote_dc = Datacube(config=self.remote_dc_config)
130 
131     def replicate_all(self):
132 
133         for defn in tqdm(self.replication_defns, 'Replicating products'):
134             self.replicate(defn)
135 
136     def replicate_all_products(self):
137         products = self.remote_dc.index.products.get_all()
138         for product in products:
139             self.local_index.products.add(product)
140 
141     def replicate(self, defn):
142         datasets = list(self.remote_dc.find_datasets(**defn))
143 
144         if not datasets:
145             LOG.info('No remote datasets found matching %s', defn)
146             return
147 
148         # TODO: use generator not list
149         product = datasets[0].type
150         LOG.info('Ensuring remote product is in local index. %s', product)
151 
152         self.local_index.products.add(product)
153 
154         for dataset in tqdm(datasets, 'Datasets'):
155             # dataset = remote_dc.index.datasets.get(dataset.id, include_sources=True)
156             # We would need to pull the parent products down too
157             # TODO: Include parent source datasets + product definitions
158             dataset.sources = {}
159 
160             LOG.debug('Replicating dataset %s', dataset)
161             remote_path = uri_to_path(dataset.local_uri)
162             local_path = self.remote_to_local(uri_to_path(dataset.local_uri))
163 
164             # Ensure local path exists
165             Path(local_path).parent.mkdir(parents=True, exist_ok=True)
166 
167             # Download file
168             self.sftp.get(remote_path, local_path)
169 
170             # Add to local index
171             dataset.local_uri = 'file://' + local_path
172             self.local_index.datasets.add(dataset)
173             LOG.debug('Downloaded to %s', local_path)
174 
175     def remote_to_local(self, remote):
176         return remote.replace(self.remote_dir, self.local_dir)
177 
178 
179 def replicate_data(config):
180     replicator = DatacubeReplicator(config)
181     replicator.run()
182 
183 
184 @click.command(help=__doc__)
185 @click.argument('config_path', required=False)
186 @global_cli_options
187 def replicate(config_path):
188     """
189     Connect to a remote Datacube, and replicate data locally.
190     """
191     if config_path is None:
192         config_path = DEFAULT_REPLICATION_CONFIG
193     LOG.debug('Config path: %s', config_path)
194     with open(config_path) as fin:
195         config = yaml.load(fin)
196 
197     replicate_data(config)
198 
199 
200 if __name__ == '__main__':
201     replicate()
202
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/datacube_apps/simple_replica.py b/datacube_apps/simple_replica.py
--- a/datacube_apps/simple_replica.py
+++ b/datacube_apps/simple_replica.py
@@ -112,7 +112,8 @@
         self.tunnel = SSHTunnelForwarder(
             self.remote_host,
             ssh_username=self.remote_user,
-            remote_bind_address=(self.remote_dc_config.db_hostname, int(self.remote_dc_config.db_port)))
+            remote_bind_address=(self.remote_dc_config.get('db_hostname', '127.0.0.1'),
+                                 int(self.remote_dc_config.get('db_port', 5432))))
         self.tunnel.start()
 
         # pylint: disable=protected-access

{"golden_diff": "diff --git a/datacube_apps/simple_replica.py b/datacube_apps/simple_replica.py\n--- a/datacube_apps/simple_replica.py\n+++ b/datacube_apps/simple_replica.py\n@@ -112,7 +112,8 @@\n         self.tunnel = SSHTunnelForwarder(\n             self.remote_host,\n             ssh_username=self.remote_user,\n-            remote_bind_address=(self.remote_dc_config.db_hostname, int(self.remote_dc_config.db_port)))\n+            remote_bind_address=(self.remote_dc_config.get('db_hostname', '127.0.0.1'),\n+                                 int(self.remote_dc_config.get('db_port', 5432))))\n         self.tunnel.start()\n \n         # pylint: disable=protected-access\n", "issue": "AttributeError for LocalConfig during replication\n### Expected behaviour\r\nSSHTunnel for replication doesn't open due to AttributeError. I have tried to understand the replication process and ran also a separate script that failed with same error. \r\n\r\n### Actual behaviour\r\n```\r\nAttributeError: 'LocalConfig' object has no attribute 'db_hostname'\r\n```\r\n\r\n### Steps to reproduce the behaviour\r\n\r\n```python\r\nfrom paramiko import SSHClient, WarningPolicy\r\nfrom sshtunnel import SSHTunnelForwarder\r\nfrom datacube.config import LocalConfig, _DEFAULT_CONF\r\nfrom configparser import ConfigParser\r\n\r\nclient = SSHClient()\r\nclient.load_system_host_keys()\r\nclient.set_missing_host_key_policy(WarningPolicy())\r\nclient.connect(hostname=\"host\", username=\"user\")\r\nsftp = client.open_sftp()\r\n\r\n\r\nremote_config = ConfigParser()\r\nremote_config.read_string(_DEFAULT_CONF)\r\nwith sftp.open('.datacube.conf') as fin:\r\n    remote_config.read_file(fin)\r\n\r\nconfig = LocalConfig(remote_config)\r\nprint(config.db_hostname)\r\n\r\nclient.close()\r\n```\r\nSame with\r\n```\r\ndatacube-simple-replica\r\n```\r\n\r\n### Environment information\r\n\r\n* Which ``datacube --version`` are you using? 1.7\r\n* What datacube deployment/enviornment are you running against? Conda environment + postgres docker db\r\n\n", "before_files": [{"content": "#!/usr/bin/env python\n\"\"\"\nA Simple Data Cube Replication Tool\n\nConnects to a remote Data Cube via SSH, and downloads database records and files to a local file system and database.\n\nProvide a configuration file in ~/.datacube.replication.conf in YAML format, or specify an alternate location\non the command line.\n\nFor example, the following config will download 3 PQ products for the specified time and space range. Queries\nare specified the same as when using the API to search for datasets.\n\n.. code-block:: yaml\n\n    remote_host: raijin.nci.org.auo\n    remote_user: dra547\n    db_password: xxxxxxxxxxxx\n    remote_dir: /g/data/\n    local_dir: C:/datacube/\n\n    replicated_data:\n    - product: ls5_pq_albers\n      crs: EPSG:3577\n      x: [1200000, 1300000]\n      y: [-4200000, -4300000]\n      time: [2008-01-01, 2010-01-01]\n\n    - product: ls7_pq_albers\n      crs: EPSG:3577\n      x: [1200000, 1300000]\n      y: [-4200000, -4300000]\n      time: [2008-01-01, 2010-01-01]\n\n    - product: ls8_pq_albers\n      crs: EPSG:3577\n      x: [1200000, 1300000]\n      y: [-4200000, -4300000]\n      time: [2008-01-01, 2010-01-01]\n\n\"\"\"\n\nimport logging\nimport os.path\nfrom configparser import ConfigParser\nfrom pathlib import Path\n\nimport click\nimport yaml\nfrom paramiko import SSHClient, WarningPolicy\nfrom sshtunnel import SSHTunnelForwarder\nfrom tqdm import tqdm\n\nfrom datacube import Datacube\nfrom datacube.config import LocalConfig, _DEFAULT_CONF\nfrom datacube.index import index_connect\nfrom datacube.ui.click import global_cli_options\n\nLOG = logging.getLogger('simple_replicator')\n\nDEFAULT_REPLICATION_CONFIG = os.path.expanduser('~/.datacube.replication.conf')\n\n\ndef uri_to_path(uri):\n    return uri.replace('file://', '')\n\n\nclass DatacubeReplicator(object):\n    def __init__(self, config):\n        self.remote_host = config['remote_host']\n        self.remote_user = config['remote_user']\n        self.db_password = config['db_password']\n        self.remote_dir = config['remote_dir']\n        self.local_dir = config['local_dir']\n        self.replication_defns = config['replicated_data']\n\n        self.client = None\n        self.sftp = None\n        self.tunnel = None\n        self.remote_dc_config = None\n        self.remote_dc = None\n        self.local_index = index_connect()\n\n    def run(self):\n        self.connect()\n        self.read_remote_config()\n        self.connect_to_db()\n        self.replicate_all()\n        self.disconnect()\n\n    def connect(self):\n        client = SSHClient()\n        client.load_system_host_keys()\n        client.set_missing_host_key_policy(WarningPolicy())\n        client.connect(hostname=self.remote_host, username=self.remote_user)\n\n        LOG.debug(client)\n        self.client = client\n        self.sftp = client.open_sftp()\n\n    def disconnect(self):\n        self.client.close()\n        self.tunnel.stop()\n\n    def read_remote_config(self):\n        remote_config = ConfigParser()\n        remote_config.read_string(_DEFAULT_CONF)\n        with self.sftp.open('.datacube.conf') as fin:\n            remote_config.read_file(fin)\n        self.remote_dc_config = LocalConfig(remote_config)\n\n    def connect_to_db(self):\n        self.tunnel = SSHTunnelForwarder(\n            self.remote_host,\n            ssh_username=self.remote_user,\n            remote_bind_address=(self.remote_dc_config.db_hostname, int(self.remote_dc_config.db_port)))\n        self.tunnel.start()\n\n        # pylint: disable=protected-access\n        self.remote_dc_config._config['datacube']['db_hostname'] = '127.0.0.1'\n        self.remote_dc_config._config['datacube']['db_port'] = str(self.tunnel.local_bind_port)\n        self.remote_dc_config._config['datacube']['db_username'] = self.remote_user\n        self.remote_dc_config._config['datacube']['db_password'] = self.db_password\n\n        # This requires the password from somewhere\n        # Parsing it out of .pgpass sounds error prone and fragile\n        # Lets put it in the configuration for now\n        LOG.debug('Remote configuration loaded %s', self.remote_dc_config)\n\n        self.remote_dc = Datacube(config=self.remote_dc_config)\n\n    def replicate_all(self):\n\n        for defn in tqdm(self.replication_defns, 'Replicating products'):\n            self.replicate(defn)\n\n    def replicate_all_products(self):\n        products = self.remote_dc.index.products.get_all()\n        for product in products:\n            self.local_index.products.add(product)\n\n    def replicate(self, defn):\n        datasets = list(self.remote_dc.find_datasets(**defn))\n\n        if not datasets:\n            LOG.info('No remote datasets found matching %s', defn)\n            return\n\n        # TODO: use generator not list\n        product = datasets[0].type\n        LOG.info('Ensuring remote product is in local index. %s', product)\n\n        self.local_index.products.add(product)\n\n        for dataset in tqdm(datasets, 'Datasets'):\n            # dataset = remote_dc.index.datasets.get(dataset.id, include_sources=True)\n            # We would need to pull the parent products down too\n            # TODO: Include parent source datasets + product definitions\n            dataset.sources = {}\n\n            LOG.debug('Replicating dataset %s', dataset)\n            remote_path = uri_to_path(dataset.local_uri)\n            local_path = self.remote_to_local(uri_to_path(dataset.local_uri))\n\n            # Ensure local path exists\n            Path(local_path).parent.mkdir(parents=True, exist_ok=True)\n\n            # Download file\n            self.sftp.get(remote_path, local_path)\n\n            # Add to local index\n            dataset.local_uri = 'file://' + local_path\n            self.local_index.datasets.add(dataset)\n            LOG.debug('Downloaded to %s', local_path)\n\n    def remote_to_local(self, remote):\n        return remote.replace(self.remote_dir, self.local_dir)\n\n\ndef replicate_data(config):\n    replicator = DatacubeReplicator(config)\n    replicator.run()\n\n\n@click.command(help=__doc__)\n@click.argument('config_path', required=False)\n@global_cli_options\ndef replicate(config_path):\n    \"\"\"\n    Connect to a remote Datacube, and replicate data locally.\n    \"\"\"\n    if config_path is None:\n        config_path = DEFAULT_REPLICATION_CONFIG\n    LOG.debug('Config path: %s', config_path)\n    with open(config_path) as fin:\n        config = yaml.load(fin)\n\n    replicate_data(config)\n\n\nif __name__ == '__main__':\n    replicate()\n", "path": "datacube_apps/simple_replica.py"}], "after_files": [{"content": "#!/usr/bin/env python\n\"\"\"\nA Simple Data Cube Replication Tool\n\nConnects to a remote Data Cube via SSH, and downloads database records and files to a local file system and database.\n\nProvide a configuration file in ~/.datacube.replication.conf in YAML format, or specify an alternate location\non the command line.\n\nFor example, the following config will download 3 PQ products for the specified time and space range. Queries\nare specified the same as when using the API to search for datasets.\n\n.. code-block:: yaml\n\n    remote_host: raijin.nci.org.auo\n    remote_user: dra547\n    db_password: xxxxxxxxxxxx\n    remote_dir: /g/data/\n    local_dir: C:/datacube/\n\n    replicated_data:\n    - product: ls5_pq_albers\n      crs: EPSG:3577\n      x: [1200000, 1300000]\n      y: [-4200000, -4300000]\n      time: [2008-01-01, 2010-01-01]\n\n    - product: ls7_pq_albers\n      crs: EPSG:3577\n      x: [1200000, 1300000]\n      y: [-4200000, -4300000]\n      time: [2008-01-01, 2010-01-01]\n\n    - product: ls8_pq_albers\n      crs: EPSG:3577\n      x: [1200000, 1300000]\n      y: [-4200000, -4300000]\n      time: [2008-01-01, 2010-01-01]\n\n\"\"\"\n\nimport logging\nimport os.path\nfrom configparser import ConfigParser\nfrom pathlib import Path\n\nimport click\nimport yaml\nfrom paramiko import SSHClient, WarningPolicy\nfrom sshtunnel import SSHTunnelForwarder\nfrom tqdm import tqdm\n\nfrom datacube import Datacube\nfrom datacube.config import LocalConfig, _DEFAULT_CONF\nfrom datacube.index import index_connect\nfrom datacube.ui.click import global_cli_options\n\nLOG = logging.getLogger('simple_replicator')\n\nDEFAULT_REPLICATION_CONFIG = os.path.expanduser('~/.datacube.replication.conf')\n\n\ndef uri_to_path(uri):\n    return uri.replace('file://', '')\n\n\nclass DatacubeReplicator(object):\n    def __init__(self, config):\n        self.remote_host = config['remote_host']\n        self.remote_user = config['remote_user']\n        self.db_password = config['db_password']\n        self.remote_dir = config['remote_dir']\n        self.local_dir = config['local_dir']\n        self.replication_defns = config['replicated_data']\n\n        self.client = None\n        self.sftp = None\n        self.tunnel = None\n        self.remote_dc_config = None\n        self.remote_dc = None\n        self.local_index = index_connect()\n\n    def run(self):\n        self.connect()\n        self.read_remote_config()\n        self.connect_to_db()\n        self.replicate_all()\n        self.disconnect()\n\n    def connect(self):\n        client = SSHClient()\n        client.load_system_host_keys()\n        client.set_missing_host_key_policy(WarningPolicy())\n        client.connect(hostname=self.remote_host, username=self.remote_user)\n\n        LOG.debug(client)\n        self.client = client\n        self.sftp = client.open_sftp()\n\n    def disconnect(self):\n        self.client.close()\n        self.tunnel.stop()\n\n    def read_remote_config(self):\n        remote_config = ConfigParser()\n        remote_config.read_string(_DEFAULT_CONF)\n        with self.sftp.open('.datacube.conf') as fin:\n            remote_config.read_file(fin)\n        self.remote_dc_config = LocalConfig(remote_config)\n\n    def connect_to_db(self):\n        self.tunnel = SSHTunnelForwarder(\n            self.remote_host,\n            ssh_username=self.remote_user,\n            remote_bind_address=(self.remote_dc_config.get('db_hostname', '127.0.0.1'),\n                                 int(self.remote_dc_config.get('db_port', 5432))))\n        self.tunnel.start()\n\n        # pylint: disable=protected-access\n        self.remote_dc_config._config['datacube']['db_hostname'] = '127.0.0.1'\n        self.remote_dc_config._config['datacube']['db_port'] = str(self.tunnel.local_bind_port)\n        self.remote_dc_config._config['datacube']['db_username'] = self.remote_user\n        self.remote_dc_config._config['datacube']['db_password'] = self.db_password\n\n        # This requires the password from somewhere\n        # Parsing it out of .pgpass sounds error prone and fragile\n        # Lets put it in the configuration for now\n        LOG.debug('Remote configuration loaded %s', self.remote_dc_config)\n\n        self.remote_dc = Datacube(config=self.remote_dc_config)\n\n    def replicate_all(self):\n\n        for defn in tqdm(self.replication_defns, 'Replicating products'):\n            self.replicate(defn)\n\n    def replicate_all_products(self):\n        products = self.remote_dc.index.products.get_all()\n        for product in products:\n            self.local_index.products.add(product)\n\n    def replicate(self, defn):\n        datasets = list(self.remote_dc.find_datasets(**defn))\n\n        if not datasets:\n            LOG.info('No remote datasets found matching %s', defn)\n            return\n\n        # TODO: use generator not list\n        product = datasets[0].type\n        LOG.info('Ensuring remote product is in local index. %s', product)\n\n        self.local_index.products.add(product)\n\n        for dataset in tqdm(datasets, 'Datasets'):\n            # dataset = remote_dc.index.datasets.get(dataset.id, include_sources=True)\n            # We would need to pull the parent products down too\n            # TODO: Include parent source datasets + product definitions\n            dataset.sources = {}\n\n            LOG.debug('Replicating dataset %s', dataset)\n            remote_path = uri_to_path(dataset.local_uri)\n            local_path = self.remote_to_local(uri_to_path(dataset.local_uri))\n\n            # Ensure local path exists\n            Path(local_path).parent.mkdir(parents=True, exist_ok=True)\n\n            # Download file\n            self.sftp.get(remote_path, local_path)\n\n            # Add to local index\n            dataset.local_uri = 'file://' + local_path\n            self.local_index.datasets.add(dataset)\n            LOG.debug('Downloaded to %s', local_path)\n\n    def remote_to_local(self, remote):\n        return remote.replace(self.remote_dir, self.local_dir)\n\n\ndef replicate_data(config):\n    replicator = DatacubeReplicator(config)\n    replicator.run()\n\n\n@click.command(help=__doc__)\n@click.argument('config_path', required=False)\n@global_cli_options\ndef replicate(config_path):\n    \"\"\"\n    Connect to a remote Datacube, and replicate data locally.\n    \"\"\"\n    if config_path is None:\n        config_path = DEFAULT_REPLICATION_CONFIG\n    LOG.debug('Config path: %s', config_path)\n    with open(config_path) as fin:\n        config = yaml.load(fin)\n\n    replicate_data(config)\n\n\nif __name__ == '__main__':\n    replicate()\n", "path": "datacube_apps/simple_replica.py"}]}