From 751c84cd098a3b78ef8e3edb2f27629d9edfc412 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Thu, 16 Mar 2023 22:02:10 -0300
Subject: [PATCH 01/75] Submitted python model successfully

---
 dbt/adapters/athena/connections.py            |  11 ++
 dbt/adapters/athena/impl.py                   |  19 ++-
 dbt/adapters/athena/python_submissions.py     |  74 +++++++++
 .../models/incremental/incremental.sql        |  15 +-
 .../models/table/create_table_as.sql          | 140 +++++++++++++-----
 .../materializations/models/table/table.sql   |   7 +-
 6 files changed, 217 insertions(+), 49 deletions(-)
 create mode 100644 dbt/adapters/athena/python_submissions.py

diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index fb7d5f1b..3b6c3fc1 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -47,6 +47,7 @@ class AthenaCredentials(Credentials):
     num_retries: Optional[int] = 5
     s3_data_dir: Optional[str] = None
     s3_data_naming: Optional[str] = "schema_table_unique"
+    spark_work_group: Optional[str] = None
     lf_tags: Optional[Dict[str, str]] = None
 
     @property
@@ -70,8 +71,18 @@ def _connection_keys(self) -> Tuple[str, ...]:
             "s3_data_dir",
             "s3_data_naming",
             "lf_tags",
+            "spark_work_group",
         )
 
+    def get_region_name(self) -> str:
+        return self.region_name
+
+    def get_profile_name(self) -> str:
+        return self.aws_profile_name
+
+    def get_spark_work_group(self) -> str:
+        return self.spark_work_group
+
 
 class AthenaCursor(Cursor):
     def __init__(self, **kwargs):
diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index f13d38de..467a621e 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -1,7 +1,7 @@
 import posixpath as path
 from itertools import chain
 from threading import Lock
-from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union, Type
 from urllib.parse import urlparse
 from uuid import uuid4
 
@@ -10,11 +10,13 @@
 
 from dbt.adapters.athena import AthenaConnectionManager
 from dbt.adapters.athena.config import get_boto3_config
+from dbt.adapters.athena.python_submissions import AthenaPythonJobHelper
 from dbt.adapters.athena.relation import AthenaRelation, AthenaSchemaSearchMap
 from dbt.adapters.athena.utils import clean_sql_comment
-from dbt.adapters.base import Column, available
+from dbt.adapters.base import PythonJobHelper, Column, available
 from dbt.adapters.base.relation import BaseRelation, InformationSchema
 from dbt.adapters.sql import SQLAdapter
+from dbt.contracts.connection import AdapterResponse
 from dbt.contracts.graph.manifest import Manifest
 from dbt.contracts.graph.nodes import CompiledNode
 from dbt.events import AdapterLogger
@@ -617,6 +619,19 @@ def persist_docs_to_glue(
 
         glue_client.update_table(DatabaseName=relation.schema, TableInput=updated_table)
 
+    def generate_python_submission_response(self, submission_result: Any) -> AdapterResponse:
+        if submission_result is not None:
+            return AdapterResponse(_message="OK")
+        return AdapterResponse(_message="ERROR")
+
+    @property
+    def default_python_submission_method(self) -> str:
+        return "athena_helper"
+
+    @property
+    def python_submission_helpers(self) -> Dict[str, Type[PythonJobHelper]]:
+        return {"athena_helper": AthenaPythonJobHelper}
+
     @available
     def list_schemas(self, database: str) -> List[str]:
         conn = self.connections.get_thread_connection()
diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
new file mode 100644
index 00000000..b1e7b4ee
--- /dev/null
+++ b/dbt/adapters/athena/python_submissions.py
@@ -0,0 +1,74 @@
+from functools import cached_property
+from typing import Any, Dict
+
+import boto3
+
+from dbt.adapters.athena.connections import AthenaCredentials
+from dbt.adapters.base import PythonJobHelper
+
+DEFAULT_POLLING_INTERVAL = 10
+SUBMISSION_LANGUAGE = "python"
+DEFAULT_TIMEOUT = 60 * 60 * 24
+
+
+class AthenaPythonJobHelper(PythonJobHelper):
+    def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
+        self.identifier = parsed_model["alias"]
+        self.schema = parsed_model["schema"]
+        self.parsed_model = parsed_model
+        self.timeout = self.get_timeout()
+        self.polling_interval = DEFAULT_POLLING_INTERVAL
+        self.region_name = credentials.get_region_name()
+        self.profile_name = credentials.get_profile_name()
+        self.spark_work_group = credentials.get_spark_work_group()
+
+    @cached_property
+    def session_id(self) -> str:
+        if self._list_sessions() is None:
+            return self._start_session().get("SessionId")
+        return self._list_sessions().get("SessionId")
+
+    @cached_property
+    def athena_client(self) -> Any:
+        return boto3.client("athena")
+
+    def get_timeout(self) -> int:
+        timeout = self.parsed_model["config"].get("timeout", DEFAULT_TIMEOUT)
+        if timeout <= 0:
+            raise ValueError("Timeout must be a positive integer")
+        return timeout
+
+    def _list_sessions(self) -> dict:
+        try:
+            response = self.athena_client.list_sessions(
+                WorkGroup=self.spark_work_group, MaxResults=1, StateFilter="IDLE"
+            )
+            return response.get("Sessions")[0]
+        except Exception:
+            return None
+
+    def _start_session(self) -> dict:
+        try:
+            response = self.athena_client.start_session(
+                WorkGroup=self.spark_work_group,
+                EngineConfiguration={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 1, "DefaultExecutorDpuSize": 18},
+            )
+            return response
+        except Exception:
+            return None
+
+    def submit(self, compiled_code: str) -> dict:
+        try:
+            response = self.athena_client.start_calculation_execution(
+                SessionId=self.session_id, CodeBlock=compiled_code.strip()
+            )
+            return response
+        except Exception:
+            return None
+
+    def _terminate_session(self) -> dict:
+        try:
+            response = self.athena_client.terminate_session(SessionId=self.session_id)
+            return response
+        except Exception:
+            return None
diff --git a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
index 865af83d..c2400c15 100644
--- a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
+++ b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
@@ -1,4 +1,5 @@
-{% materialization incremental, adapter='athena' -%}
+{% materialization incremental, adapter='athena', supported_languages=['sql', 'python'] -%}
+  {%- set language = model['language'] -%}
 
   {% set raw_strategy = config.get('incremental_strategy') or 'insert_overwrite' %}
   {% set table_type = config.get('table_type', default='hive') | lower %}
@@ -24,16 +25,16 @@
 
   {% set to_drop = [] %}
   {% if existing_relation is none %}
-    {% set build_sql = create_table_as(False, target_relation, sql) -%}
+    {% set build_sql = create_table_as(False, target_relation, sql, language) -%}
   {% elif existing_relation.is_view or should_full_refresh() %}
     {% do drop_relation(existing_relation) %}
-    {% set build_sql = create_table_as(False, target_relation, sql) -%}
+    {% set build_sql = create_table_as(False, target_relation, sql, language) -%}
   {% elif partitioned_by is not none and strategy == 'insert_overwrite' %}
     {% set tmp_relation = make_temp_relation(target_relation) %}
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, sql)) %}
+    {% do run_query(create_table_as(True, tmp_relation, sql, language)) %}
     {% do delete_overlapping_partitions(target_relation, tmp_relation, partitioned_by) %}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
@@ -42,7 +43,7 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, sql)) %}
+    {% do run_query(create_table_as(True, tmp_relation, sql, language)) %}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
   {% elif strategy == 'merge' and table_type == 'iceberg' %}
@@ -58,12 +59,12 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, sql)) %}
+    {% do run_query(create_table_as(True, tmp_relation, sql, language)) %}
     {% set build_sql = iceberg_merge(on_schema_change, tmp_relation, target_relation, unique_key, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
   {% endif %}
 
-  {% call statement("main") %}
+  {% call statement("main", language=language) %}
     {{ build_sql }}
   {% endcall %}
 
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index 49b3ce4e..4f42cb51 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -1,49 +1,57 @@
-{% macro athena__create_table_as(temporary, relation, sql) -%}
-  {%- set materialized = config.get('materialized', default='table') -%}
-  {%- set external_location = config.get('external_location', default=none) -%}
-  {%- set partitioned_by = config.get('partitioned_by', default=none) -%}
-  {%- set bucketed_by = config.get('bucketed_by', default=none) -%}
-  {%- set bucket_count = config.get('bucket_count', default=none) -%}
-  {%- set field_delimiter = config.get('field_delimiter', default=none) -%}
-  {%- set table_type = config.get('table_type', default='hive') | lower -%}
-  {%- set format = config.get('format', default='parquet') -%}
-  {%- set write_compression = config.get('write_compression', default=none) -%}
-  {%- set s3_data_dir = config.get('s3_data_dir', default=target.s3_data_dir) -%}
-  {%- set s3_data_naming = config.get('s3_data_naming', default=target.s3_data_naming) -%}
-  {%- set extra_table_properties = config.get('table_properties', default=none) -%}
+{% macro athena__create_table_as(temporary, relation, compiled_code, language='sql') -%}
+  {%- if language == 'sql' -%}
+    {%- set materialized = config.get('materialized', default='table') -%}
+    {%- set external_location = config.get('external_location', default=none) -%}
+    {%- set partitioned_by = config.get('partitioned_by', default=none) -%}
+    {%- set bucketed_by = config.get('bucketed_by', default=none) -%}
+    {%- set bucket_count = config.get('bucket_count', default=none) -%}
+    {%- set field_delimiter = config.get('field_delimiter', default=none) -%}
+    {%- set table_type = config.get('table_type', default='hive') | lower -%}
+    {%- set format = config.get('format', default='parquet') -%}
+    {%- set write_compression = config.get('write_compression', default=none) -%}
+    {%- set s3_data_dir = config.get('s3_data_dir', default=target.s3_data_dir) -%}
+    {%- set s3_data_naming = config.get('s3_data_naming', default=target.s3_data_naming) -%}
+    {%- set extra_table_properties = config.get('table_properties', default=none) -%}
 
+<<<<<<< HEAD
   {%- set location_property = 'external_location' -%}
   {%- set partition_property = 'partitioned_by' -%}
   {%- set work_group_output_location = adapter.get_work_group_output_location() -%}
   {%- set location = adapter.s3_table_location(s3_data_dir, s3_data_naming, relation.schema, relation.identifier, external_location, temporary) -%}
+=======
+    {%- set location_property = 'external_location' -%}
+    {%- set partition_property = 'partitioned_by' -%}
+    {%- set location = adapter.s3_table_location(s3_data_dir, s3_data_naming, relation.schema, relation.identifier, external_location, temporary) -%}
+>>>>>>> 10dd892 (Submitted python model successfully)
 
-  {%- if materialized == 'table_hive_ha' -%}
-    {%- set location = location.replace('__ha', '') -%}
-  {%- endif %}
+    {%- if materialized == 'table_hive_ha' -%}
+      {%- set location = location.replace('__ha', '') -%}
+    {%- endif %}
 
-  {%- if table_type == 'iceberg' -%}
-    {%- set location_property = 'location' -%}
-    {%- set partition_property = 'partitioning' -%}
-    {%- if bucketed_by is not none or bucket_count is not none -%}
-      {%- set ignored_bucket_iceberg -%}
-      bucketed_by or bucket_count cannot be used with Iceberg tables. You have to use the bucket function
-      when partitioning. Will be ignored
-      {%- endset -%}
-      {%- set bucketed_by = none -%}
-      {%- set bucket_count = none -%}
-      {% do log(ignored_bucket_iceberg) %}
-    {%- endif -%}
-    {%- if s3_data_naming in ['table', 'table_schema'] or external_location is not none -%}
-      {%- set error_unique_location_iceberg -%}
-        You need to have an unique table location when creating Iceberg table. Right now we are building tables in
-        a destructive way but in the near future we will be using the RENAME feature to provide near-zero downtime.
-      {%- endset -%}
-      {% do exceptions.raise_compiler_error(error_unique_location_iceberg) %}
-    {%- endif -%}
-  {%- endif %}
+    {%- if table_type == 'iceberg' -%}
+      {%- set location_property = 'location' -%}
+      {%- set partition_property = 'partitioning' -%}
+      {%- if bucketed_by is not none or bucket_count is not none -%}
+        {%- set ignored_bucket_iceberg -%}
+        bucketed_by or bucket_count cannot be used with Iceberg tables. You have to use the bucket function
+        when partitioning. Will be ignored
+        {%- endset -%}
+        {%- set bucketed_by = none -%}
+        {%- set bucket_count = none -%}
+        {% do log(ignored_bucket_iceberg) %}
+      {%- endif -%}
+      {%- if s3_data_naming in ['table', 'table_schema'] or external_location is not none -%}
+        {%- set error_unique_location_iceberg -%}
+          You need to have an unique table location when creating Iceberg table. Right now we are building tables in
+          a destructive way but in the near future we will be using the RENAME feature to provide near-zero downtime.
+        {%- endset -%}
+        {% do exceptions.raise_compiler_error(error_unique_location_iceberg) %}
+      {%- endif -%}
+    {%- endif %}
 
-  {% do adapter.delete_from_s3(location) %}
+    {% do adapter.delete_from_s3(location) %}
 
+<<<<<<< HEAD
   create table {{ relation }}
   with (
     table_type='{{ table_type }}',
@@ -77,3 +85,61 @@
   as
     {{ sql }}
 {% endmacro %}
+=======
+    create table {{ relation }}
+    with (
+      table_type='{{ table_type }}',
+      is_external={%- if table_type == 'iceberg' -%}false{%- else -%}true{%- endif %},
+      {{ location_property }}='{{ location }}',
+    {%- if partitioned_by is not none %}
+      {{ partition_property }}=ARRAY{{ partitioned_by | tojson | replace('\"', '\'') }},
+    {%- endif %}
+    {%- if bucketed_by is not none %}
+      bucketed_by=ARRAY{{ bucketed_by | tojson | replace('\"', '\'') }},
+    {%- endif %}
+    {%- if bucket_count is not none %}
+      bucket_count={{ bucket_count }},
+    {%- endif %}
+    {%- if field_delimiter is not none %}
+      field_delimiter='{{ field_delimiter }}',
+    {%- endif %}
+    {%- if write_compression is not none %}
+      write_compression='{{ write_compression }}',
+    {%- endif %}
+      format='{{ format }}'
+    {%- if extra_table_properties is not none -%}
+      {%- for prop_name, prop_value in extra_table_properties.items() -%}
+      ,
+      {{ prop_name }}={{ prop_value }}
+      {%- endfor -%}
+    {% endif %}
+    )
+    as
+      {{ compiled_code }}
+  {%- elif language == 'python' -%}
+    {{ athena__py_create_table_as(compiled_code=compiled_code, target_relation=relation, temporary=temporary) }}
+  {%- else -%}
+    {% do exceptions.raise_compiler_error("athena__create_table_as macro doesn't support the provided language, it got %s" % language) %}
+  {%- endif -%}
+{%- endmacro -%}
+
+{%- macro athena__py_create_table_as(compiled_code, target_relation, temporary) -%}
+{{ compiled_code }}
+def materialize(session, df, target_relation):
+    # make sure pandas exists
+    import importlib.util
+    package_name = 'pandas'
+    if importlib.util.find_spec(package_name):
+        import pandas
+        if isinstance(df, pandas.core.frame.DataFrame):
+          # session.write_pandas does not have overwrite function
+          df = session.createDataFrame(df)
+    df.write.mode("overwrite").save_as_table('{{ target_relation.identifier }}', create_temp_table={{temporary}})
+
+def main(session):
+    dbt = dbtObj(session.table)
+    df = model(dbt, session)
+    materialize(session, df, dbt.this)
+    return "OK"
+{%- endmacro -%}
+>>>>>>> 10dd892 (Submitted python model successfully)
diff --git a/dbt/include/athena/macros/materializations/models/table/table.sql b/dbt/include/athena/macros/materializations/models/table/table.sql
index ce995e99..34646220 100644
--- a/dbt/include/athena/macros/materializations/models/table/table.sql
+++ b/dbt/include/athena/macros/materializations/models/table/table.sql
@@ -1,5 +1,6 @@
-{% materialization table, adapter='athena' -%}
+{% materialization table, adapter='athena', supported_languages=['sql', 'python'] -%}
   {%- set identifier = model['alias'] -%}
+  {%- set language = model['language'] -%}
 
   {%- set lf_tags = config.get('lf_tags', default=none) -%}
   {%- set lf_tags_columns = config.get('lf_tags_columns', default=none) -%}
@@ -18,8 +19,8 @@
   {%- endif -%}
 
   -- build model
-  {% call statement('main') -%}
-    {{ create_table_as(False, target_relation, sql) }}
+  {% call statement('main', language=language) -%}
+    {{ create_table_as(False, target_relation, compiled_code, language) }}
   {%- endcall %}
 
   {% if table_type != 'iceberg' %}

From 773700077854a3c4631afb262d4c81f4e1d62648 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Sat, 25 Mar 2023 15:47:01 -0300
Subject: [PATCH 02/75] Rebase and resolved conflicts

---
 .../models/table/create_table_as.sql          | 44 +------------------
 1 file changed, 1 insertion(+), 43 deletions(-)

diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index 4f42cb51..f7a96997 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -13,16 +13,10 @@
     {%- set s3_data_naming = config.get('s3_data_naming', default=target.s3_data_naming) -%}
     {%- set extra_table_properties = config.get('table_properties', default=none) -%}
 
-<<<<<<< HEAD
-  {%- set location_property = 'external_location' -%}
-  {%- set partition_property = 'partitioned_by' -%}
-  {%- set work_group_output_location = adapter.get_work_group_output_location() -%}
-  {%- set location = adapter.s3_table_location(s3_data_dir, s3_data_naming, relation.schema, relation.identifier, external_location, temporary) -%}
-=======
     {%- set location_property = 'external_location' -%}
     {%- set partition_property = 'partitioned_by' -%}
+    {%- set work_group_output_location = adapter.get_work_group_output_location() -%}
     {%- set location = adapter.s3_table_location(s3_data_dir, s3_data_naming, relation.schema, relation.identifier, external_location, temporary) -%}
->>>>>>> 10dd892 (Submitted python model successfully)
 
     {%- if materialized == 'table_hive_ha' -%}
       {%- set location = location.replace('__ha', '') -%}
@@ -51,41 +45,6 @@
 
     {% do adapter.delete_from_s3(location) %}
 
-<<<<<<< HEAD
-  create table {{ relation }}
-  with (
-    table_type='{{ table_type }}',
-    is_external={%- if table_type == 'iceberg' -%}false{%- else -%}true{%- endif %},
-  {%- if work_group_output_location is none -%}
-    {{ location_property }}='{{ location }}',
-  {%- endif %}
-  {%- if partitioned_by is not none %}
-    {{ partition_property }}=ARRAY{{ partitioned_by | tojson | replace('\"', '\'') }},
-  {%- endif %}
-  {%- if bucketed_by is not none %}
-    bucketed_by=ARRAY{{ bucketed_by | tojson | replace('\"', '\'') }},
-  {%- endif %}
-  {%- if bucket_count is not none %}
-    bucket_count={{ bucket_count }},
-  {%- endif %}
-  {%- if field_delimiter is not none %}
-    field_delimiter='{{ field_delimiter }}',
-  {%- endif %}
-  {%- if write_compression is not none %}
-    write_compression='{{ write_compression }}',
-  {%- endif %}
-    format='{{ format }}'
-  {%- if extra_table_properties is not none -%}
-    {%- for prop_name, prop_value in extra_table_properties.items() -%}
-    ,
-    {{ prop_name }}={{ prop_value }}
-    {%- endfor -%}
-  {% endif %}
-  )
-  as
-    {{ sql }}
-{% endmacro %}
-=======
     create table {{ relation }}
     with (
       table_type='{{ table_type }}',
@@ -142,4 +101,3 @@ def main(session):
     materialize(session, df, dbt.this)
     return "OK"
 {%- endmacro -%}
->>>>>>> 10dd892 (Submitted python model successfully)

From c1d1ab24e93f7a029b03bc9bf04ad13387df6d95 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Sun, 26 Mar 2023 01:17:03 -0300
Subject: [PATCH 03/75] Execution successful but table not saved

---
 dbt/adapters/athena/impl.py                   | 10 +--
 dbt/adapters/athena/python_submissions.py     | 73 ++++++++++++++++---
 .../models/table/create_table_as.sql          | 26 ++++---
 .../materializations/models/table/table.sql   |  2 +-
 4 files changed, 81 insertions(+), 30 deletions(-)

diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index 467a621e..330077f6 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -1,7 +1,7 @@
 import posixpath as path
 from itertools import chain
 from threading import Lock
-from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union, Type
+from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Type, Union
 from urllib.parse import urlparse
 from uuid import uuid4
 
@@ -13,7 +13,7 @@
 from dbt.adapters.athena.python_submissions import AthenaPythonJobHelper
 from dbt.adapters.athena.relation import AthenaRelation, AthenaSchemaSearchMap
 from dbt.adapters.athena.utils import clean_sql_comment
-from dbt.adapters.base import PythonJobHelper, Column, available
+from dbt.adapters.base import Column, PythonJobHelper, available
 from dbt.adapters.base.relation import BaseRelation, InformationSchema
 from dbt.adapters.sql import SQLAdapter
 from dbt.contracts.connection import AdapterResponse
@@ -620,9 +620,9 @@ def persist_docs_to_glue(
         glue_client.update_table(DatabaseName=relation.schema, TableInput=updated_table)
 
     def generate_python_submission_response(self, submission_result: Any) -> AdapterResponse:
-        if submission_result is not None:
-            return AdapterResponse(_message="OK")
-        return AdapterResponse(_message="ERROR")
+        if submission_result is None:
+            return AdapterResponse(_message="ERROR")
+        return AdapterResponse(_message="OK")
 
     @property
     def default_python_submission_method(self) -> str:
diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index b1e7b4ee..8afc8f0f 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -1,3 +1,4 @@
+import time
 from functools import cached_property
 from typing import Any, Dict
 
@@ -5,11 +6,15 @@
 
 from dbt.adapters.athena.connections import AthenaCredentials
 from dbt.adapters.base import PythonJobHelper
+from dbt.events import AdapterLogger
+from dbt.exceptions import DbtRuntimeError
 
-DEFAULT_POLLING_INTERVAL = 10
+DEFAULT_POLLING_INTERVAL = 2
 SUBMISSION_LANGUAGE = "python"
 DEFAULT_TIMEOUT = 60 * 60 * 24
 
+logger = AdapterLogger("Athena")
+
 
 class AthenaPythonJobHelper(PythonJobHelper):
     def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
@@ -43,32 +48,76 @@ def _list_sessions(self) -> dict:
             response = self.athena_client.list_sessions(
                 WorkGroup=self.spark_work_group, MaxResults=1, StateFilter="IDLE"
             )
+            if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
+                return None
             return response.get("Sessions")[0]
         except Exception:
-            return None
+            raise
 
     def _start_session(self) -> dict:
         try:
             response = self.athena_client.start_session(
                 WorkGroup=self.spark_work_group,
-                EngineConfiguration={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 1, "DefaultExecutorDpuSize": 18},
+                EngineConfiguration={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
             )
+            if response["State"] != "IDLE":
+                self._poll_until_session_creation(response["SessionId"])
             return response
         except Exception:
-            return None
+            raise
 
     def submit(self, compiled_code: str) -> dict:
         try:
-            response = self.athena_client.start_calculation_execution(
-                SessionId=self.session_id, CodeBlock=compiled_code.strip()
-            )
-            return response
+            calculation_execution_id = self.athena_client.start_calculation_execution(
+                SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
+            )["CalculationExecutionId"]
+            logger.debug(f"Submitted calculation execution id {calculation_execution_id}")
+            execution_status = self._poll_until_execution_completion(calculation_execution_id)
+            logger.debug(f"Received execution status {execution_status}")
+            if execution_status == "COMPLETED":
+                result_s3_uri = self.athena_client.get_calculation_execution(
+                    CalculationExecutionId=calculation_execution_id
+                )["Result"]["ResultS3Uri"]
+                return result_s3_uri
+            else:
+                raise DbtRuntimeError(f"python model run ended in state {execution_status}")
         except Exception:
-            return None
+            raise
 
     def _terminate_session(self) -> dict:
         try:
-            response = self.athena_client.terminate_session(SessionId=self.session_id)
-            return response
+            self.athena_client.terminate_session(SessionId=self.session_id)
         except Exception:
-            return None
+            raise
+
+    def _poll_until_execution_completion(self, calculation_execution_id):
+        polling_interval = self.polling_interval
+        while True:
+            execution_status = self.athena_client.get_calculation_execution_status(
+                CalculationExecutionId=calculation_execution_id
+            )["Status"]["State"]
+            if execution_status in ["COMPLETED", "FAILED", "CANCELLED"]:
+                return execution_status
+            time.sleep(polling_interval)
+            polling_interval *= 2
+            if polling_interval > self.timeout:
+                raise DbtRuntimeError(
+                    f"Execution {calculation_execution_id} did not complete within {self.timeout} seconds."
+                )
+
+    def _poll_until_session_creation(self, session_id):
+        polling_interval = self.polling_interval
+        while True:
+            creation_status = self.athena_client.get_session_status(SessionId=session_id)["Status"]["State"]
+            if creation_status in ["FAILED", "TERMINATED", "DEGRADED"]:
+                raise DbtRuntimeError(f"Unable to create session: {session_id}. Got status: {creation_status}.")
+            elif creation_status == "IDLE":
+                return creation_status
+            time.sleep(polling_interval)
+            polling_interval *= 2
+            if polling_interval > self.timeout:
+                raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
+
+    def __del__(self) -> None:
+        logger.debug(f"Terminating session: {self.session_id}")
+        self._terminate_session()
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index f7a96997..978b4c92 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -51,10 +51,10 @@
       is_external={%- if table_type == 'iceberg' -%}false{%- else -%}true{%- endif %},
       {{ location_property }}='{{ location }}',
     {%- if partitioned_by is not none %}
-      {{ partition_property }}=ARRAY{{ partitioned_by | tojson | replace('\"', '\'') }},
+      {{ partition_property }}=ARRAY{{ partitioned_by | join("', '") | replace('"', "'") | prepend("'") | append("'") }},
     {%- endif %}
     {%- if bucketed_by is not none %}
-      bucketed_by=ARRAY{{ bucketed_by | tojson | replace('\"', '\'') }},
+      bucketed_by=ARRAY{{ bucketed_by | join("', '") | replace('"', "'") | prepend("'") | append("'") }},
     {%- endif %}
     {%- if bucket_count is not none %}
       bucket_count={{ bucket_count }},
@@ -76,24 +76,26 @@
     as
       {{ compiled_code }}
   {%- elif language == 'python' -%}
-    {{ athena__py_create_table_as(compiled_code=compiled_code, target_relation=relation, temporary=temporary) }}
+    {{ athena__py_create_table_as(compiled_code=compiled_code, target_relation=relation, temporary=temporary) | trim }}
   {%- else -%}
     {% do exceptions.raise_compiler_error("athena__create_table_as macro doesn't support the provided language, it got %s" % language) %}
   {%- endif -%}
 {%- endmacro -%}
 
 {%- macro athena__py_create_table_as(compiled_code, target_relation, temporary) -%}
-{{ compiled_code }}
+{{ compiled_code | trim }}
 def materialize(session, df, target_relation):
-    # make sure pandas exists
-    import importlib.util
-    package_name = 'pandas'
-    if importlib.util.find_spec(package_name):
-        import pandas
+    import pandas
+    try:
         if isinstance(df, pandas.core.frame.DataFrame):
-          # session.write_pandas does not have overwrite function
-          df = session.createDataFrame(df)
-    df.write.mode("overwrite").save_as_table('{{ target_relation.identifier }}', create_temp_table={{temporary}})
+            df = spark.createDataFrame(df)
+        df.write.saveAsTable(
+            name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
+            format="parquet",
+            mode="overwrite"
+        )
+    except Exception:
+        raise
 
 def main(session):
     dbt = dbtObj(session.table)
diff --git a/dbt/include/athena/macros/materializations/models/table/table.sql b/dbt/include/athena/macros/materializations/models/table/table.sql
index 34646220..79c7ba9c 100644
--- a/dbt/include/athena/macros/materializations/models/table/table.sql
+++ b/dbt/include/athena/macros/materializations/models/table/table.sql
@@ -23,7 +23,7 @@
     {{ create_table_as(False, target_relation, compiled_code, language) }}
   {%- endcall %}
 
-  {% if table_type != 'iceberg' %}
+  {% if table_type != 'iceberg' and language != 'python' %}
     {{ set_table_classification(target_relation) }}
   {% endif %}
 

From fd6a135e7be4a3edf49000c7b3a38ebe9a3f392c Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Mon, 27 Mar 2023 10:02:12 -0300
Subject: [PATCH 04/75] Add incremental model support

---
 .../models/incremental/incremental.sql        | 10 +++++-----
 .../models/table/create_table_as.sql          | 19 +++++++++----------
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
index c2400c15..6a6acb45 100644
--- a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
+++ b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
@@ -25,16 +25,16 @@
 
   {% set to_drop = [] %}
   {% if existing_relation is none %}
-    {% set build_sql = create_table_as(False, target_relation, sql, language) -%}
+    {% set build_sql = create_table_as(False, target_relation, compiled_code, language) -%}
   {% elif existing_relation.is_view or should_full_refresh() %}
     {% do drop_relation(existing_relation) %}
-    {% set build_sql = create_table_as(False, target_relation, sql, language) -%}
+    {% set build_sql = create_table_as(False, target_relation, compiled_code, language) -%}
   {% elif partitioned_by is not none and strategy == 'insert_overwrite' %}
     {% set tmp_relation = make_temp_relation(target_relation) %}
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, sql, language)) %}
+    {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
     {% do delete_overlapping_partitions(target_relation, tmp_relation, partitioned_by) %}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
@@ -43,7 +43,7 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, sql, language)) %}
+    {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
   {% elif strategy == 'merge' and table_type == 'iceberg' %}
@@ -59,7 +59,7 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, sql, language)) %}
+    {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
     {% set build_sql = iceberg_merge(on_schema_change, tmp_relation, target_relation, unique_key, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
   {% endif %}
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index 978b4c92..cf58d47c 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -76,30 +76,29 @@
     as
       {{ compiled_code }}
   {%- elif language == 'python' -%}
-    {{ athena__py_create_table_as(compiled_code=compiled_code, target_relation=relation, temporary=temporary) | trim }}
+    {{ athena__py_create_table_as(compiled_code=compiled_code, target_relation=relation, temporary=temporary) }}
   {%- else -%}
     {% do exceptions.raise_compiler_error("athena__create_table_as macro doesn't support the provided language, it got %s" % language) %}
   {%- endif -%}
 {%- endmacro -%}
 
 {%- macro athena__py_create_table_as(compiled_code, target_relation, temporary) -%}
-{{ compiled_code | trim }}
-def materialize(session, df, target_relation):
+{{ compiled_code }}
+def materialize(spark_session, df, target_relation):
     import pandas
     try:
         if isinstance(df, pandas.core.frame.DataFrame):
-            df = spark.createDataFrame(df)
+            df = spark_session.createDataFrame(df)
         df.write.saveAsTable(
             name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
             format="parquet",
-            mode="overwrite"
+            mode="overwrite",
         )
+        return "OK"
     except Exception:
         raise
 
-def main(session):
-    dbt = dbtObj(session.table)
-    df = model(dbt, session)
-    materialize(session, df, dbt.this)
-    return "OK"
+dbt = dbtObj(spark.table)
+df = model(dbt, spark)
+materialize(spark, df, dbt.this)
 {%- endmacro -%}

From 7913646da68b3ed5c6efffc68edf161021187962 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Mon, 3 Apr 2023 20:47:24 -0300
Subject: [PATCH 05/75] Fixed location and incremental model rerun

---
 .env.example                                  |   1 +
 dbt/adapters/athena/connections.py            |   9 --
 dbt/adapters/athena/python_submissions.py     |  30 +++--
 .../macros/adapters/python_submissions.sql    |  35 ++++++
 .../models/incremental/incremental.sql        |  45 +++++++-
 .../models/table/create_table_as.sql          | 106 +++++++-----------
 tests/conftest.py                             |   1 +
 tests/unit/constants.py                       |   1 +
 tests/unit/test_python_submissions.py         |  56 +++++++++
 9 files changed, 194 insertions(+), 90 deletions(-)
 create mode 100644 dbt/include/athena/macros/adapters/python_submissions.sql
 create mode 100644 tests/unit/test_python_submissions.py

diff --git a/.env.example b/.env.example
index cfda7881..520991b3 100644
--- a/.env.example
+++ b/.env.example
@@ -4,3 +4,4 @@ DBT_TEST_ATHENA_DATABASE=
 DBT_TEST_ATHENA_SCHEMA=
 DBT_TEST_ATHENA_WORK_GROUND=
 DBT_TEST_ATHENA_AWS_PROFILE_NAME=
+DBT_TEST_ATHENA_SPARK_WORK_GROUP=
diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index 421b00a9..a4ed8911 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -74,15 +74,6 @@ def _connection_keys(self) -> Tuple[str, ...]:
             "spark_work_group",
         )
 
-    def get_region_name(self) -> str:
-        return self.region_name
-
-    def get_profile_name(self) -> str:
-        return self.aws_profile_name
-
-    def get_spark_work_group(self) -> str:
-        return self.spark_work_group
-
 
 class AthenaCursor(Cursor):
     def __init__(self, **kwargs):
diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 8afc8f0f..8ef7b066 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -1,5 +1,6 @@
 import time
-from functools import cached_property
+from datetime import datetime, timedelta, timezone
+from functools import lru_cache
 from typing import Any, Dict
 
 import boto3
@@ -11,7 +12,7 @@
 
 DEFAULT_POLLING_INTERVAL = 2
 SUBMISSION_LANGUAGE = "python"
-DEFAULT_TIMEOUT = 60 * 60 * 24
+DEFAULT_TIMEOUT = 60 * 60 * 2
 
 logger = AdapterLogger("Athena")
 
@@ -23,17 +24,20 @@ def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
         self.parsed_model = parsed_model
         self.timeout = self.get_timeout()
         self.polling_interval = DEFAULT_POLLING_INTERVAL
-        self.region_name = credentials.get_region_name()
-        self.profile_name = credentials.get_profile_name()
-        self.spark_work_group = credentials.get_spark_work_group()
+        self.region_name = credentials.region_name
+        self.profile_name = credentials.aws_profile_name
+        self.spark_work_group = credentials.spark_work_group
 
-    @cached_property
+    @property
+    @lru_cache()
     def session_id(self) -> str:
-        if self._list_sessions() is None:
+        session_info = self._list_sessions()
+        if session_info is None:
             return self._start_session().get("SessionId")
-        return self._list_sessions().get("SessionId")
+        return session_info.get("SessionId")
 
-    @cached_property
+    @property
+    @lru_cache()
     def athena_client(self) -> Any:
         return boto3.client("athena")
 
@@ -86,7 +90,12 @@ def submit(self, compiled_code: str) -> dict:
 
     def _terminate_session(self) -> dict:
         try:
-            self.athena_client.terminate_session(SessionId=self.session_id)
+            session_status = self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
+            if session_status["State"] in ["IDLE", "BUSY"] and (
+                session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
+            ):
+                logger.debug(f"Terminating session: {self.session_id}")
+                self.athena_client.terminate_session(SessionId=self.session_id)
         except Exception:
             raise
 
@@ -119,5 +128,4 @@ def _poll_until_session_creation(self, session_id):
                 raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
 
     def __del__(self) -> None:
-        logger.debug(f"Terminating session: {self.session_id}")
         self._terminate_session()
diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
new file mode 100644
index 00000000..c9c02d24
--- /dev/null
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -0,0 +1,35 @@
+{%- macro athena__py_save_table_as(compiled_code, target_relation, format, location, mode="overwrite") -%}
+{{ compiled_code }}
+def materialize(spark_session, df, target_relation):
+    import pandas
+    try:
+        if isinstance(df, pandas.core.frame.DataFrame):
+            df = spark_session.createDataFrame(df)
+        df.write \
+        .format("{{ format }}") \
+        .option("path", "{{ location }}") \
+        .mode("{{ mode }}") \
+        .saveAsTable(
+            name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
+        )
+        return "OK"
+    except Exception:
+        raise
+
+dbt = dbtObj(spark.table)
+df = model(dbt, spark)
+materialize(spark, df, dbt.this)
+{%- endmacro -%}
+
+{%- macro athena__py_execute_query(query) -%}
+def execute_query(spark_session):
+    import pandas
+    try:
+        spark_session.sql("""{{ query }}""")
+        return "OK"
+    except Exception:
+        raise
+
+dbt = dbtObj(spark.table)
+execute_query(spark)
+{%- endmacro -%}
diff --git a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
index b6724cc2..309bf87e 100644
--- a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
+++ b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
@@ -13,6 +13,8 @@
   {% set existing_relation = load_relation(this) %}
   {% set tmp_relation = make_temp_relation(this) %}
 
+  {{ log("temporary relation is" ~ tmp_relation.schema ~ tmp_relation.identifier)}}
+
   -- If no partitions are used with insert_overwrite, we fall back to append mode.
   {% if partitioned_by is none and strategy == 'insert_overwrite' %}
     {% set strategy = 'append' %}
@@ -25,16 +27,28 @@
 
   {% set to_drop = [] %}
   {% if existing_relation is none %}
-    {% set build_sql = create_table_as(False, target_relation, compiled_code, language) -%}
+    {% call statement('save_table', language=language) -%}
+        {{ create_table_as(False, target_relation, compiled_code, language) }}
+    {%- endcall %}
+    {% set build_sql = None %}
   {% elif existing_relation.is_view or should_full_refresh() %}
     {% do drop_relation(existing_relation) %}
-    {% set build_sql = create_table_as(False, target_relation, compiled_code, language) -%}
+    {% call statement('save_table', language=language) -%}
+        {{ create_table_as(False, target_relation, compiled_code, language) }}
+    {%- endcall %}
+    {% set build_sql = None %}
   {% elif partitioned_by is not none and strategy == 'insert_overwrite' %}
     {% set tmp_relation = make_temp_relation(target_relation) %}
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% if language == 'sql' %}
+      {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% else %}
+      {% call statement('save_table', language=language) -%}
+          {{ create_table_as(True, tmp_relation, compiled_code, language) }}
+      {%- endcall %}
+    {% endif %}
     {% do delete_overlapping_partitions(target_relation, tmp_relation, partitioned_by) %}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
@@ -43,7 +57,13 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% if language == 'sql' %}
+      {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% else %}
+      {% call statement('save_table', language=language) -%}
+          {{ create_table_as(True, tmp_relation, compiled_code, language) }}
+      {%- endcall %}
+    {% endif %}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
   {% elif strategy == 'merge' and table_type == 'iceberg' %}
@@ -59,13 +79,26 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% if language == 'sql' %}
+      {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% else %}
+      {% call statement('save_table', language=language) -%}
+          {{ create_table_as(True, tmp_relation, compiled_code, language) }}
+      {%- endcall %}
+    {% endif %}
     {% set build_sql = iceberg_merge(on_schema_change, tmp_relation, target_relation, unique_key, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
   {% endif %}
 
   {% call statement("main", language=language) %}
-    {{ build_sql }}
+    {% if language == 'sql' %}
+      {{ build_sql }}
+    {% else %}
+      {% if build_sql %}
+          {{ log(build_sql) }}
+          {% do athena__py_execute_query(query=build_sql) %}
+      {% endif %}
+    {% endif %}
   {% endcall %}
 
   -- set table properties
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index cf58d47c..5205a14b 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -1,50 +1,49 @@
 {% macro athena__create_table_as(temporary, relation, compiled_code, language='sql') -%}
-  {%- if language == 'sql' -%}
-    {%- set materialized = config.get('materialized', default='table') -%}
-    {%- set external_location = config.get('external_location', default=none) -%}
-    {%- set partitioned_by = config.get('partitioned_by', default=none) -%}
-    {%- set bucketed_by = config.get('bucketed_by', default=none) -%}
-    {%- set bucket_count = config.get('bucket_count', default=none) -%}
-    {%- set field_delimiter = config.get('field_delimiter', default=none) -%}
-    {%- set table_type = config.get('table_type', default='hive') | lower -%}
-    {%- set format = config.get('format', default='parquet') -%}
-    {%- set write_compression = config.get('write_compression', default=none) -%}
-    {%- set s3_data_dir = config.get('s3_data_dir', default=target.s3_data_dir) -%}
-    {%- set s3_data_naming = config.get('s3_data_naming', default=target.s3_data_naming) -%}
-    {%- set extra_table_properties = config.get('table_properties', default=none) -%}
-
-    {%- set location_property = 'external_location' -%}
-    {%- set partition_property = 'partitioned_by' -%}
-    {%- set work_group_output_location = adapter.get_work_group_output_location() -%}
-    {%- set location = adapter.s3_table_location(s3_data_dir, s3_data_naming, relation.schema, relation.identifier, external_location, temporary) -%}
+  {%- set materialized = config.get('materialized', default='table') -%}
+  {%- set external_location = config.get('external_location', default=none) -%}
+  {%- set partitioned_by = config.get('partitioned_by', default=none) -%}
+  {%- set bucketed_by = config.get('bucketed_by', default=none) -%}
+  {%- set bucket_count = config.get('bucket_count', default=none) -%}
+  {%- set field_delimiter = config.get('field_delimiter', default=none) -%}
+  {%- set table_type = config.get('table_type', default='hive') | lower -%}
+  {%- set format = config.get('format', default='parquet') -%}
+  {%- set write_compression = config.get('write_compression', default=none) -%}
+  {%- set s3_data_dir = config.get('s3_data_dir', default=target.s3_data_dir) -%}
+  {%- set s3_data_naming = config.get('s3_data_naming', default=target.s3_data_naming) -%}
+  {%- set extra_table_properties = config.get('table_properties', default=none) -%}
 
-    {%- if materialized == 'table_hive_ha' -%}
-      {%- set location = location.replace('__ha', '') -%}
-    {%- endif %}
+  {%- set location_property = 'external_location' -%}
+  {%- set partition_property = 'partitioned_by' -%}
+  {%- set work_group_output_location = adapter.get_work_group_output_location() -%}
+  {%- set location = adapter.s3_table_location(s3_data_dir, s3_data_naming, relation.schema, relation.identifier, external_location, temporary) -%}
 
-    {%- if table_type == 'iceberg' -%}
-      {%- set location_property = 'location' -%}
-      {%- set partition_property = 'partitioning' -%}
-      {%- if bucketed_by is not none or bucket_count is not none -%}
-        {%- set ignored_bucket_iceberg -%}
-        bucketed_by or bucket_count cannot be used with Iceberg tables. You have to use the bucket function
-        when partitioning. Will be ignored
-        {%- endset -%}
-        {%- set bucketed_by = none -%}
-        {%- set bucket_count = none -%}
-        {% do log(ignored_bucket_iceberg) %}
-      {%- endif -%}
-      {%- if s3_data_naming in ['table', 'table_schema'] or external_location is not none -%}
-        {%- set error_unique_location_iceberg -%}
-          You need to have an unique table location when creating Iceberg table. Right now we are building tables in
-          a destructive way but in the near future we will be using the RENAME feature to provide near-zero downtime.
-        {%- endset -%}
-        {% do exceptions.raise_compiler_error(error_unique_location_iceberg) %}
-      {%- endif -%}
-    {%- endif %}
+  {%- if materialized == 'table_hive_ha' -%}
+    {%- set location = location.replace('__ha', '') -%}
+  {%- endif %}
 
-    {% do adapter.delete_from_s3(location) %}
+  {%- if table_type == 'iceberg' -%}
+    {%- set location_property = 'location' -%}
+    {%- set partition_property = 'partitioning' -%}
+    {%- if bucketed_by is not none or bucket_count is not none -%}
+      {%- set ignored_bucket_iceberg -%}
+      bucketed_by or bucket_count cannot be used with Iceberg tables. You have to use the bucket function
+      when partitioning. Will be ignored
+      {%- endset -%}
+      {%- set bucketed_by = none -%}
+      {%- set bucket_count = none -%}
+      {% do log(ignored_bucket_iceberg) %}
+    {%- endif -%}
+    {%- if s3_data_naming in ['table', 'table_schema'] or external_location is not none -%}
+      {%- set error_unique_location_iceberg -%}
+        You need to have an unique table location when creating Iceberg table. Right now we are building tables in
+        a destructive way but in the near future we will be using the RENAME feature to provide near-zero downtime.
+      {%- endset -%}
+      {% do exceptions.raise_compiler_error(error_unique_location_iceberg) %}
+    {%- endif -%}
+  {%- endif %}
 
+  {% do adapter.delete_from_s3(location) %}
+  {%- if language == 'sql' -%}
     create table {{ relation }}
     with (
       table_type='{{ table_type }}',
@@ -76,29 +75,8 @@
     as
       {{ compiled_code }}
   {%- elif language == 'python' -%}
-    {{ athena__py_create_table_as(compiled_code=compiled_code, target_relation=relation, temporary=temporary) }}
+    {{ athena__py_save_table_as(compiled_code=compiled_code, target_relation=relation, format=format, location=location, mode="overwrite") }}
   {%- else -%}
     {% do exceptions.raise_compiler_error("athena__create_table_as macro doesn't support the provided language, it got %s" % language) %}
   {%- endif -%}
 {%- endmacro -%}
-
-{%- macro athena__py_create_table_as(compiled_code, target_relation, temporary) -%}
-{{ compiled_code }}
-def materialize(spark_session, df, target_relation):
-    import pandas
-    try:
-        if isinstance(df, pandas.core.frame.DataFrame):
-            df = spark_session.createDataFrame(df)
-        df.write.saveAsTable(
-            name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
-            format="parquet",
-            mode="overwrite",
-        )
-        return "OK"
-    except Exception:
-        raise
-
-dbt = dbtObj(spark.table)
-df = model(dbt, spark)
-materialize(spark, df, dbt.this)
-{%- endmacro -%}
diff --git a/tests/conftest.py b/tests/conftest.py
index 2233c410..fba8b34a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -26,6 +26,7 @@ def dbt_profile_target():
         "num_retries": 0,
         "work_group": os.getenv("DBT_TEST_ATHENA_WORK_GROUND"),
         "aws_profile_name": os.getenv("DBT_TEST_ATHENA_AWS_PROFILE_NAME") or None,
+        "spark_work_group": os.getenv("DBT_TEST_ATHENA_SPARK_WORK_GROUP"),
     }
 
 
diff --git a/tests/unit/constants.py b/tests/unit/constants.py
index 4178f9be..7a7d01ac 100644
--- a/tests/unit/constants.py
+++ b/tests/unit/constants.py
@@ -5,3 +5,4 @@
 AWS_REGION = "eu-west-1"
 S3_STAGING_DIR = "s3://my-bucket/test-dbt/"
 ATHENA_WORKGROUP = "dbt-athena-adapter"
+SPARK_WORKGROUP = "spark"
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
new file mode 100644
index 00000000..56069711
--- /dev/null
+++ b/tests/unit/test_python_submissions.py
@@ -0,0 +1,56 @@
+from unittest.mock import patch
+
+from dbt.adapters.athena.connections import AthenaCredentials
+from dbt.adapters.athena.python_submissions import AthenaPythonJobHelper
+
+from .constants import (
+    ATHENA_WORKGROUP,
+    AWS_REGION,
+    DATA_CATALOG_NAME,
+    DATABASE_NAME,
+    S3_STAGING_DIR,
+    SPARK_WORKGROUP,
+)
+from .utils import MockAWSService
+
+
+class TestPythonSubmission:
+    mock_aws_service = MockAWSService()
+    parsed_model = {"alias": "test_model", "schema": DATABASE_NAME, "config": {"timeout": 10}}
+    _athena_job_helper = None
+    credentials = AthenaCredentials(
+        database=DATA_CATALOG_NAME,
+        schema=DATABASE_NAME,
+        s3_staging_dir=S3_STAGING_DIR,
+        region_name=AWS_REGION,
+        work_group=ATHENA_WORKGROUP,
+        spark_work_group=SPARK_WORKGROUP,
+    )
+
+    @property
+    def athena_job_helper(self):
+        if self._athena_job_helper is None:
+            self._athena_job_helper = AthenaPythonJobHelper(self.parsed_model, self.credentials)
+        return self._athena_job_helper
+
+    def test_create_session(self):
+        obj = self.athena_job_helper
+
+        # Define the mock return values for the _list_sessions and _start_session methods
+        mock_list_sessions = {"SessionId": "session123"}
+        mock_start_session = {"SessionId": "session456"}
+
+        # Mock the _list_sessions and _start_session methods using the patch decorator
+        with patch.object(obj, "_list_sessions", return_value=mock_list_sessions), patch.object(
+            obj, "_start_session", return_value=mock_start_session
+        ):
+            # Call the session_id property and assert that it returns the expected value
+            assert obj.session_id == "session123"
+
+            # Call the _list_sessions and _start_session methods to ensure they were called
+            obj._list_sessions.assert_called_once()
+            obj._start_session.assert_not_called()  # since _list_sessions return value is not None
+
+        # Call the session_id property again to ensure it still returns the expected value after
+        # the mock context is complete
+        assert obj.session_id == "session123"

From 233ab98bd3543aacc01d1289fa7d6912653ec86a Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Tue, 4 Apr 2023 23:02:34 -0300
Subject: [PATCH 06/75] Added docs

---
 dbt/adapters/athena/python_submissions.py | 226 +++++++++++++++++-----
 1 file changed, 181 insertions(+), 45 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 8ef7b066..d1ba83dc 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -18,6 +18,34 @@
 
 
 class AthenaPythonJobHelper(PythonJobHelper):
+    """
+     A helper class for executing Python jobs on AWS Athena.
+
+    This class extends the base `PythonJobHelper` class and provides additional functionality
+    specific to executing jobs on Athena. It takes a parsed model and credentials as inputs
+    during initialization, and provides methods for executing Athena jobs, setting timeout,
+    polling interval, region name, AWS profile name, and Spark work group.
+
+    Args:
+        parsed_model (Dict): A dictionary representing the parsed model of the Athena job.
+            It should contain keys such as 'alias' for job identifier and 'schema' for
+            job schema.
+        credentials (AthenaCredentials): An instance of the `AthenaCredentials` class
+            containing AWS credentials for accessing Athena.
+
+    Attributes:
+        identifier (str): A string representing the alias or identifier of the Athena job.
+        schema (str): A string representing the schema of the Athena job.
+        parsed_model (Dict): A dictionary representing the parsed model of the Athena job.
+        timeout (int): An integer representing the timeout value in seconds for the Athena job.
+        polling_interval (int): An integer representing the polling interval in seconds for
+            checking the status of the Athena job.
+        region_name (str): A string representing the AWS region name for executing the Athena job.
+        profile_name (str): A string representing the AWS profile name for accessing Athena.
+        spark_work_group (str): A string representing the Spark work group for executing the Athena job.
+
+    """
+
     def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
         self.identifier = parsed_model["alias"]
         self.schema = parsed_model["schema"]
@@ -31,6 +59,16 @@ def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
     @property
     @lru_cache()
     def session_id(self) -> str:
+        """
+        Get the session ID.
+
+        This function retrieves the session ID from the stored session information. If session information
+        is not available, a new session is started and its session ID is returned.
+
+        Returns:
+            str: The session ID.
+
+        """
         session_info = self._list_sessions()
         if session_info is None:
             return self._start_session().get("SessionId")
@@ -39,67 +77,150 @@ def session_id(self) -> str:
     @property
     @lru_cache()
     def athena_client(self) -> Any:
-        return boto3.client("athena")
+        """
+        Get the AWS Athena client.
+
+        This function returns an AWS Athena client object that can be used to interact with the Athena service.
+        The client is created using the region name and profile name provided during object instantiation.
+
+        Returns:
+            Any: The Athena client object.
+
+        """
+        return boto3.session.Session(region_name=self.region_name, profile_name=self.profile_name).client("athena")
 
     def get_timeout(self) -> int:
+        """
+        Get the timeout value.
+
+        This function retrieves the timeout value from the parsed model's configuration. If the timeout value
+        is not defined, it falls back to the default timeout value. If the retrieved timeout value is less than or
+        equal to 0, a ValueError is raised as timeout must be a positive integer.
+
+        Returns:
+            int: The timeout value in seconds.
+
+        Raises:
+            ValueError: If the timeout value is not a positive integer.
+
+        """
         timeout = self.parsed_model["config"].get("timeout", DEFAULT_TIMEOUT)
         if timeout <= 0:
             raise ValueError("Timeout must be a positive integer")
         return timeout
 
     def _list_sessions(self) -> dict:
-        try:
-            response = self.athena_client.list_sessions(
-                WorkGroup=self.spark_work_group, MaxResults=1, StateFilter="IDLE"
-            )
-            if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
-                return None
-            return response.get("Sessions")[0]
-        except Exception:
-            raise
+        """
+        List Athena sessions.
+
+        This function sends a request to the Athena service to list the sessions in the specified Spark workgroup.
+        It filters the sessions by state, only returning the first session that is in IDLE state. If no idle sessions
+        are found or if an error occurs, None is returned.
+
+        Returns:
+            dict: The session information dictionary if an idle session is found, None otherwise.
+
+        """
+        response = self.athena_client.list_sessions(WorkGroup=self.spark_work_group, MaxResults=1, StateFilter="IDLE")
+        if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
+            return None
+        return response.get("Sessions")[0]
 
     def _start_session(self) -> dict:
-        try:
-            response = self.athena_client.start_session(
-                WorkGroup=self.spark_work_group,
-                EngineConfiguration={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
-            )
-            if response["State"] != "IDLE":
-                self._poll_until_session_creation(response["SessionId"])
-            return response
-        except Exception:
-            raise
+        """
+        Start an Athena session.
+
+        This function sends a request to the Athena service to start a session in the specified Spark workgroup.
+        It configures the session with specific engine configurations. If the session state is not IDLE, the function
+        polls until the session creation is complete. The response containing session information is returned.
+
+        Returns:
+            dict: The session information dictionary.
+
+        """
+        response = self.athena_client.start_session(
+            WorkGroup=self.spark_work_group,
+            EngineConfiguration={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
+        )
+        if response["State"] != "IDLE":
+            self._poll_until_session_creation(response["SessionId"])
+        return response
 
     def submit(self, compiled_code: str) -> dict:
-        try:
-            calculation_execution_id = self.athena_client.start_calculation_execution(
-                SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
-            )["CalculationExecutionId"]
-            logger.debug(f"Submitted calculation execution id {calculation_execution_id}")
-            execution_status = self._poll_until_execution_completion(calculation_execution_id)
-            logger.debug(f"Received execution status {execution_status}")
-            if execution_status == "COMPLETED":
-                result_s3_uri = self.athena_client.get_calculation_execution(
-                    CalculationExecutionId=calculation_execution_id
-                )["Result"]["ResultS3Uri"]
-                return result_s3_uri
-            else:
-                raise DbtRuntimeError(f"python model run ended in state {execution_status}")
-        except Exception:
-            raise
+        """
+        Submit a calculation to Athena.
+
+        This function submits a calculation to Athena for execution using the provided compiled code.
+        It starts a calculation execution with the current session ID and the compiled code as the code block.
+        The function then polls until the calculation execution is completed, and retrieves the result S3 URI.
+        If the execution is successful and completed, the result S3 URI is returned. Otherwise, a DbtRuntimeError
+        is raised with the execution status.
+
+        Args:
+            compiled_code (str): The compiled code to submit for execution.
+
+        Returns:
+            dict: The result S3 URI if the execution is successful and completed.
+
+        Raises:
+            DbtRuntimeError: If the execution ends in a state other than "COMPLETED".
+
+        """
+        calculation_execution_id = self.athena_client.start_calculation_execution(
+            SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
+        )["CalculationExecutionId"]
+        logger.debug(f"Submitted calculation execution id {calculation_execution_id}")
+        execution_status = self._poll_until_execution_completion(calculation_execution_id)
+        logger.debug(f"Received execution status {execution_status}")
+        if execution_status == "COMPLETED":
+            result_s3_uri = self.athena_client.get_calculation_execution(
+                CalculationExecutionId=calculation_execution_id
+            )["Result"]["ResultS3Uri"]
+            return result_s3_uri
+        else:
+            raise DbtRuntimeError(f"python model run ended in state {execution_status}")
 
     def _terminate_session(self) -> dict:
-        try:
-            session_status = self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
-            if session_status["State"] in ["IDLE", "BUSY"] and (
-                session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
-            ):
-                logger.debug(f"Terminating session: {self.session_id}")
-                self.athena_client.terminate_session(SessionId=self.session_id)
-        except Exception:
-            raise
+        """
+        Terminate the current Athena session.
+
+        This function terminates the current Athena session if it is in IDLE or BUSY state and has exceeded the
+        configured timeout period. It retrieves the session status, and if the session state is IDLE or BUSY and the
+        duration since the session start time exceeds the timeout period, the session is terminated. The session ID is
+        used to terminate the session via the Athena client.
+
+        Returns:
+            dict: The response from the Athena client after terminating the session.
+
+        """
+        session_status = self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
+        if session_status["State"] in ["IDLE", "BUSY"] and (
+            session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
+        ):
+            logger.debug(f"Terminating session: {self.session_id}")
+            self.athena_client.terminate_session(SessionId=self.session_id)
 
     def _poll_until_execution_completion(self, calculation_execution_id):
+        """
+        Poll the status of a calculation execution until it is completed, failed, or cancelled.
+
+        This function polls the status of a calculation execution identified by the given `calculation_execution_id`
+        until it is completed, failed, or cancelled. It uses the Athena client to retrieve the status of the execution
+        and checks if the state is one of "COMPLETED", "FAILED", or "CANCELLED". If the execution is not yet completed,
+        the function sleeps for a certain polling interval, which starts with the value of `self.polling_interval` and
+        doubles after each iteration until it reaches the `self.timeout` period. If the execution does not complete
+        within the timeout period, a `DbtRuntimeError` is raised.
+
+        Args:
+            calculation_execution_id (str): The ID of the calculation execution to poll.
+
+        Returns:
+            str: The final state of the calculation execution, which can be one of "COMPLETED", "FAILED" or "CANCELLED".
+
+        Raises:
+            DbtRuntimeError: If the calculation execution does not complete within the timeout period.
+
+        """
         polling_interval = self.polling_interval
         while True:
             execution_status = self.athena_client.get_calculation_execution_status(
@@ -115,6 +236,20 @@ def _poll_until_execution_completion(self, calculation_execution_id):
                 )
 
     def _poll_until_session_creation(self, session_id):
+        """
+        Polls the status of an Athena session creation until it is completed or reaches the timeout.
+
+        Args:
+            session_id (str): The ID of the session being created.
+
+        Returns:
+            str: The final status of the session, which will be "IDLE" if the session creation is successful.
+
+        Raises:
+            DbtRuntimeError: If the session creation fails, is terminated, or degrades during polling.
+            DbtRuntimeError: If the session does not become IDLE within the specified timeout.
+
+        """
         polling_interval = self.polling_interval
         while True:
             creation_status = self.athena_client.get_session_status(SessionId=session_id)["Status"]["State"]
@@ -128,4 +263,5 @@ def _poll_until_session_creation(self, session_id):
                 raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
 
     def __del__(self) -> None:
+        """Teardown for the class."""
         self._terminate_session()

From d2ad09e5ba35739a1076bfd659d1028590c855b3 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Tue, 4 Apr 2023 23:14:12 -0300
Subject: [PATCH 07/75] Updated README

---
 README.md | 33 ++++++++++++++++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 280ead04..c143fed0 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@
     * Support two incremental update strategies: `insert_overwrite` and `append`
     * Does **not** support the use of `unique_key`
 * Supports [snapshots][snapshots]
-* Does not support [Python models][python-models]
+* Supports [Python models][python-models]
 * Does not support [persist docs][persist-docs] for views
 
 [seeds]: https://docs.getdbt.com/docs/building-a-dbt-project/seeds
@@ -73,6 +73,7 @@ A dbt profile can be configured to run against AWS Athena using the following co
 | work_group       | Identifier of Athena workgroup                                                 | Optional  | `my-custom-workgroup`                    |
 | num_retries      | Number of times to retry a failing query                                       | Optional  | `3`                                      |
 | lf_tags          | Default lf tags to apply to any database created by dbt                        | Optional  | `{"origin": "dbt", "team": "analytics"}` |
+| spark_work_group | Identifier of athena spark workgroup                                           | Optional  | `my-spark-workgroup`                     |
 
 **Example profiles.yml entry:**
 ```yaml
@@ -89,6 +90,7 @@ athena:
       database: awsdatacatalog
       aws_profile_name: my-profile
       work_group: my-workgroup
+      spark_work_group: my-spark-workgroup
       lf_tags:
         origin: dbt
         team: analytics
@@ -373,6 +375,35 @@ The only way, from a dbt perspective, is to do a full-refresh of the incremental
 
 * Snapshot does not support dropping columns from the source table. If you drop a column make sure to drop the column from the snapshot as well. Another workaround is to NULL the column in the snapshot definition to preserve history
 
+### Python Models
+
+The adapter supports python models using [`spark`](https://docs.aws.amazon.com/athena/latest/ug/notebooks-spark.html).
+
+#### Prerequisites
+
+* A spark enabled work group created in athena
+* Spark execution role granted access to Athena, Glue and S3
+* The spark work group is added to the ~/.dbt/profiles.yml file and the profile is referenced in dbt_project.yml
+
+#### Example model
+
+```python
+import pandas as pd
+
+
+def model(dbt, session):
+    dbt.config(materialized="table")
+
+    model_df = pd.DataFrame({"A": [1, 2, 3, 4]})
+
+    return model_df
+```
+
+#### Known issues in python models
+
+* Incremental models do not fully utilize spark capabilities. They depend on existing sql based logic.
+* Snapshots materializations are not supported.
+
 ### Contributing
 
 This connector works with Python from 3.7 to 3.11.

From fed0dfacce8e816be7adfd0b4b03b66b33bfd8b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9my=20Guiselin?=
 <9251353+Jrmyy@users.noreply.github.com>
Date: Wed, 5 Apr 2023 17:51:58 +0200
Subject: [PATCH 08/75] fix: return empty if table does not exist in
 get_columns (#199)

---
 dbt/adapters/athena/impl.py | 10 +++++++++-
 tests/unit/test_adapter.py  | 15 +++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index 53b69cdd..e34ebb32 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -696,7 +696,15 @@ def get_columns_in_relation(self, relation: AthenaRelation) -> List[Column]:
         with boto3_client_lock:
             glue_client = client.session.client("glue", region_name=client.region_name, config=get_boto3_config())
 
-        table = glue_client.get_table(DatabaseName=relation.schema, Name=relation.identifier)["Table"]
+        try:
+            table = glue_client.get_table(DatabaseName=relation.schema, Name=relation.identifier)["Table"]
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "EntityNotFoundException":
+                logger.debug("table not exist, catching the error")
+                return []
+            else:
+                logger.error(e)
+                raise e
 
         columns = [c for c in table["StorageDescriptor"]["Columns"] if self._is_current_column(c)]
         partition_keys = table.get("PartitionKeys", [])
diff --git a/tests/unit/test_adapter.py b/tests/unit/test_adapter.py
index 01685291..4a7d10d9 100644
--- a/tests/unit/test_adapter.py
+++ b/tests/unit/test_adapter.py
@@ -848,6 +848,21 @@ def test_get_columns_in_relation(self):
             Column("dt", "date"),
         ]
 
+    @mock_athena
+    @mock_glue
+    def test_get_columns_in_relation_not_found_table(self):
+        self.mock_aws_service.create_data_catalog()
+        self.mock_aws_service.create_database()
+        self.adapter.acquire_connection("dummy")
+        columns = self.adapter.get_columns_in_relation(
+            self.adapter.Relation.create(
+                database=DATA_CATALOG_NAME,
+                schema=DATABASE_NAME,
+                identifier="tbl_name",
+            )
+        )
+        assert columns == []
+
     @pytest.mark.parametrize(
         "response,database,table,columns,lf_tags,expected",
         [

From f5c816774e0588004bddcd82da604d9830e243ad Mon Sep 17 00:00:00 2001
From: nicor88 <6278547+nicor88@users.noreply.github.com>
Date: Thu, 6 Apr 2023 11:40:16 +0200
Subject: [PATCH 09/75] fix: check for empty workgroup in profiles (#194)

---
 dbt/adapters/athena/impl.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index e34ebb32..535378f3 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -149,13 +149,14 @@ def get_work_group_output_location(self) -> Optional[str]:
         with boto3_client_lock:
             athena_client = client.session.client("athena", region_name=client.region_name, config=get_boto3_config())
 
-        work_group = athena_client.get_work_group(WorkGroup=creds.work_group)
-        return (
-            work_group.get("WorkGroup", {})
-            .get("Configuration", {})
-            .get("ResultConfiguration", {})
-            .get("OutputLocation")
-        )
+        if creds.work_group:
+            work_group = athena_client.get_work_group(WorkGroup=creds.work_group)
+            return (
+                work_group.get("WorkGroup", {})
+                .get("Configuration", {})
+                .get("ResultConfiguration", {})
+                .get("OutputLocation")
+            )
 
     @available
     def s3_table_prefix(self, s3_data_dir: Optional[str]) -> str:

From 785ba5fd9eb880e695360efd3ff1a9b1a8f05bf1 Mon Sep 17 00:00:00 2001
From: Mattia <5013654+mattiamatrix@users.noreply.github.com>
Date: Thu, 6 Apr 2023 12:03:23 +0100
Subject: [PATCH 10/75] chore: add credits section (#201)

---
 README.md | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c143fed0..b2424498 100644
--- a/README.md
+++ b/README.md
@@ -446,8 +446,25 @@ make test
   [conventionalcommits](https://www.conventionalcommits.org).
 * Pull request body should describe _motivation_.
 
-### Helpful Resources
+## Credits
+The following acknowledges the Maintainers for this repository, those who have Contributed to this repository (via bug reports, code, design, ideas, project management, translation, testing, etc.), and any other References utilized.
 
+### Maintainers
+The following individuals are responsible for curating the list of issues, responding to pull requests, and ensuring regular releases happen.
+
+* [nicor88](https://github.com/nicor88)
+* [Jrmyy](https://github.com/Jrmyy)
+* [jessedobbelaere](https://github.com/jessedobbelaere)
+* [mattiamatrix](https://github.com/mattiamatrix)
+* [thenaturalist](https://github.com/thenaturalist)
+
+### Contributors
+Thank you to all the people who have already contributed to this repository via bug reports, code, design, ideas, project management, translation, testing, etc.
+
+* [Tomme](https://github.com/Tomme) - Wrote the initial version.
+* [Lemiffe](https://github.com/lemiffe) - Logo design.
+
+## Resources
 * [Athena CREATE TABLE AS](https://docs.aws.amazon.com/athena/latest/ug/create-table-as.html)
 * [dbt-labs/dbt-core](https://github.com/dbt-labs/dbt-core)
 * [laughingman7743/PyAthena](https://github.com/laughingman7743/PyAthena)

From ee8bf9581d76858ae2508fd545017808a18bf70a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9my=20Guiselin?=
 <9251353+Jrmyy@users.noreply.github.com>
Date: Thu, 6 Apr 2023 15:25:49 +0200
Subject: [PATCH 11/75] fix: enable database in policy to support cross-account
 queries (#200)

Co-authored-by: nicor88 <6278547+nicor88@users.noreply.github.com>
---
 dbt/adapters/athena/relation.py | 2 +-
 tests/unit/test_relation.py     | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbt/adapters/athena/relation.py b/dbt/adapters/athena/relation.py
index 887158c7..414d2dc9 100644
--- a/dbt/adapters/athena/relation.py
+++ b/dbt/adapters/athena/relation.py
@@ -6,7 +6,7 @@
 
 @dataclass
 class AthenaIncludePolicy(Policy):
-    database: bool = False
+    database: bool = True
     schema: bool = True
     identifier: bool = True
 
diff --git a/tests/unit/test_relation.py b/tests/unit/test_relation.py
index 21f64973..81872224 100644
--- a/tests/unit/test_relation.py
+++ b/tests/unit/test_relation.py
@@ -12,7 +12,7 @@ def test_render_hive_uses_hive_style_quotation(self):
             database=DATA_CATALOG_NAME,
             schema=DATABASE_NAME,
         )
-        assert relation.render_hive() == f"`{DATABASE_NAME}`.`{TABLE_NAME}`"
+        assert relation.render_hive() == f"`{DATA_CATALOG_NAME}`.`{DATABASE_NAME}`.`{TABLE_NAME}`"
 
     def test_render_hive_resets_quote_character_after_call(self):
         relation = AthenaRelation.create(
@@ -21,7 +21,7 @@ def test_render_hive_resets_quote_character_after_call(self):
             schema=DATABASE_NAME,
         )
         relation.render_hive()
-        assert relation.render() == f'"{DATABASE_NAME}"."{TABLE_NAME}"'
+        assert relation.render() == f'"{DATA_CATALOG_NAME}"."{DATABASE_NAME}"."{TABLE_NAME}"'
 
     def test_render_pure_resets_quote_character_after_call(self):
         relation = AthenaRelation.create(
@@ -29,4 +29,4 @@ def test_render_pure_resets_quote_character_after_call(self):
             database=DATA_CATALOG_NAME,
             schema=DATABASE_NAME,
         )
-        assert relation.render_pure() == f"{DATABASE_NAME}.{TABLE_NAME}"
+        assert relation.render_pure() == f"{DATA_CATALOG_NAME}.{DATABASE_NAME}.{TABLE_NAME}"

From 414c739336db45b481881d6f8e885971c8071b49 Mon Sep 17 00:00:00 2001
From: Serhii Dimchenko <39801237+svdimchenko@users.noreply.github.com>
Date: Fri, 7 Apr 2023 09:43:23 +0200
Subject: [PATCH 12/75] fix: glue column types (#196)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: nicor88 <6278547+nicor88@users.noreply.github.com>
Co-authored-by: Jérémy Guiselin <9251353+Jrmyy@users.noreply.github.com>
---
 dbt/adapters/athena/column.py   | 55 +++++++++++++++++++++++++++++++++
 dbt/adapters/athena/impl.py     | 44 +++++++++++++++++---------
 dbt/adapters/athena/relation.py |  9 ++++++
 tests/unit/test_adapter.py      | 16 +++++-----
 4 files changed, 101 insertions(+), 23 deletions(-)
 create mode 100644 dbt/adapters/athena/column.py

diff --git a/dbt/adapters/athena/column.py b/dbt/adapters/athena/column.py
new file mode 100644
index 00000000..e5dfdadd
--- /dev/null
+++ b/dbt/adapters/athena/column.py
@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+
+from dbt.adapters.athena.relation import TableType
+from dbt.adapters.base.column import Column
+from dbt.exceptions import DbtRuntimeError
+
+
+@dataclass
+class AthenaColumn(Column):
+    table_type: TableType = TableType.TABLE
+
+    def is_iceberg(self) -> bool:
+        return self.table_type == TableType.ICEBERG
+
+    def is_string(self) -> bool:
+        return self.dtype.lower() in {"varchar", "string"}
+
+    def is_binary(self) -> bool:
+        return self.dtype.lower() in {"binary", "varbinary"}
+
+    def is_timestamp(self) -> bool:
+        return self.dtype.lower() in {"timestamp"}
+
+    @classmethod
+    def string_type(cls, size: int) -> str:
+        return f"varchar({size})" if size > 0 else "varchar"
+
+    @classmethod
+    def binary_type(cls) -> str:
+        return "varbinary"
+
+    def timestamp_type(self) -> str:
+        if self.is_iceberg():
+            return "timestamp(6)"
+        return "timestamp"
+
+    def string_size(self) -> int:
+        if not self.is_string():
+            raise DbtRuntimeError("Called string_size() on non-string field!")
+        if not self.char_size:
+            # Handle error: '>' not supported between instances of 'NoneType' and 'NoneType' for union relations macro
+            return 0
+        return self.char_size
+
+    @property
+    def data_type(self) -> str:
+        if self.is_string():
+            return self.string_type(self.string_size())
+        elif self.is_numeric():
+            return self.numeric_type(self.dtype, self.numeric_precision, self.numeric_scale)
+        elif self.is_binary():
+            return self.binary_type()
+        elif self.is_timestamp():
+            return self.timestamp_type()
+        return self.dtype
diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index 535378f3..e42b6f16 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -12,11 +12,22 @@
 from botocore.exceptions import ClientError
 
 from dbt.adapters.athena import AthenaConnectionManager
+from dbt.adapters.athena.column import AthenaColumn
 from dbt.adapters.athena.config import get_boto3_config
+<<<<<<< HEAD
 from dbt.adapters.athena.python_submissions import AthenaPythonJobHelper
 from dbt.adapters.athena.relation import AthenaRelation, AthenaSchemaSearchMap
 from dbt.adapters.athena.utils import clean_sql_comment
 from dbt.adapters.base import Column, PythonJobHelper, available
+=======
+from dbt.adapters.athena.relation import (
+    AthenaRelation,
+    AthenaSchemaSearchMap,
+    TableType,
+)
+from dbt.adapters.athena.utils import clean_sql_comment
+from dbt.adapters.base import available
+>>>>>>> 6f41803 (fix: glue column types (#196))
 from dbt.adapters.base.relation import BaseRelation, InformationSchema
 from dbt.adapters.sql import SQLAdapter
 from dbt.contracts.connection import AdapterResponse
@@ -35,13 +46,13 @@ class AthenaAdapter(SQLAdapter):
     Relation = AthenaRelation
 
     relation_type_map = {
-        "EXTERNAL_TABLE": "table",
-        "MANAGED_TABLE": "table",
-        "VIRTUAL_VIEW": "view",
-        "table": "table",
-        "view": "view",
-        "cte": "cte",
-        "materializedview": "materializedview",
+        "EXTERNAL_TABLE": TableType.TABLE,
+        "MANAGED_TABLE": TableType.TABLE,
+        "VIRTUAL_VIEW": TableType.VIEW,
+        "table": TableType.TABLE,
+        "view": TableType.VIEW,
+        "cte": TableType.CTE,
+        "materializedview": TableType.MATERIALIZED_VIEW,
     }
 
     @classmethod
@@ -366,7 +377,7 @@ def _get_one_table_for_catalog(self, table: dict, database: str) -> list:
             "table_database": database,
             "table_schema": table["DatabaseName"],
             "table_name": table["Name"],
-            "table_type": self.relation_type_map[table["TableType"]],
+            "table_type": self.relation_type_map[table["TableType"]].value,
             "table_comment": table.get("Parameters", {}).get("comment", table.get("Description", "")),
         }
         return [
@@ -486,7 +497,7 @@ def list_relations_without_caching(
         return relations
 
     @available
-    def get_table_type(self, db_name, table_name):
+    def get_table_type(self, db_name, table_name) -> TableType:
         conn = self.connections.get_thread_connection()
         client = conn.handle
 
@@ -495,17 +506,17 @@ def get_table_type(self, db_name, table_name):
 
         try:
             response = glue_client.get_table(DatabaseName=db_name, Name=table_name)
-            _type = self.relation_type_map.get(response.get("Table", {}).get("TableType", "Table"))
+            _type = self.relation_type_map.get(response.get("Table", {}).get("TableType"))
             _specific_type = response.get("Table", {}).get("Parameters", {}).get("table_type", "")
 
             if _specific_type.lower() == "iceberg":
-                _type = "iceberg_table"
+                _type = TableType.ICEBERG
 
             if _type is None:
                 raise ValueError("Table type cannot be None")
 
-            logger.debug("table_name : " + table_name)
-            logger.debug("table type : " + _type)
+            logger.debug(f"table_name : {table_name}")
+            logger.debug(f"table type : {_type}")
 
             return _type
 
@@ -690,7 +701,7 @@ def _is_current_column(col: dict) -> bool:
         return True
 
     @available
-    def get_columns_in_relation(self, relation: AthenaRelation) -> List[Column]:
+    def get_columns_in_relation(self, relation: AthenaRelation) -> List[AthenaColumn]:
         conn = self.connections.get_thread_connection()
         client = conn.handle
 
@@ -706,10 +717,13 @@ def get_columns_in_relation(self, relation: AthenaRelation) -> List[Column]:
             else:
                 logger.error(e)
                 raise e
+        table_type = self.get_table_type(relation.schema, relation.identifier)
 
         columns = [c for c in table["StorageDescriptor"]["Columns"] if self._is_current_column(c)]
         partition_keys = table.get("PartitionKeys", [])
 
         logger.debug(f"Columns in relation {relation.identifier}: {columns + partition_keys}")
 
-        return [Column(c["Name"], c["Type"]) for c in columns + partition_keys]
+        return [
+            AthenaColumn(column=c["Name"], dtype=c["Type"], table_type=table_type) for c in columns + partition_keys
+        ]
diff --git a/dbt/adapters/athena/relation.py b/dbt/adapters/athena/relation.py
index 414d2dc9..0cf51947 100644
--- a/dbt/adapters/athena/relation.py
+++ b/dbt/adapters/athena/relation.py
@@ -1,9 +1,18 @@
 from dataclasses import dataclass, field
+from enum import Enum
 from typing import Dict, Optional, Set
 
 from dbt.adapters.base.relation import BaseRelation, InformationSchema, Policy
 
 
+class TableType(Enum):
+    TABLE = "table"
+    VIEW = "view"
+    CTE = "cte"
+    MATERIALIZED_VIEW = "materializedview"
+    ICEBERG = "iceberg_table"
+
+
 @dataclass
 class AthenaIncludePolicy(Policy):
     database: bool = True
diff --git a/tests/unit/test_adapter.py b/tests/unit/test_adapter.py
index 4a7d10d9..d69bdc69 100644
--- a/tests/unit/test_adapter.py
+++ b/tests/unit/test_adapter.py
@@ -10,9 +10,9 @@
 
 from dbt.adapters.athena import AthenaAdapter
 from dbt.adapters.athena import Plugin as AthenaPlugin
+from dbt.adapters.athena.column import AthenaColumn
 from dbt.adapters.athena.connections import AthenaCursor, AthenaParameterFormatter
-from dbt.adapters.athena.relation import AthenaRelation
-from dbt.adapters.base import Column
+from dbt.adapters.athena.relation import AthenaRelation, TableType
 from dbt.clients import agate_helper
 from dbt.contracts.connection import ConnectionState
 from dbt.contracts.files import FileHash
@@ -436,7 +436,7 @@ def test__get_relation_type_table(self, aws_credentials):
         self.mock_aws_service.create_table("test_table")
         self.adapter.acquire_connection("dummy")
         table_type = self.adapter.get_table_type(DATABASE_NAME, "test_table")
-        assert table_type == "table"
+        assert table_type == TableType.TABLE
 
     @mock_glue
     @mock_s3
@@ -459,7 +459,7 @@ def test__get_relation_type_view(self, aws_credentials):
         self.mock_aws_service.create_view("test_view")
         self.adapter.acquire_connection("dummy")
         table_type = self.adapter.get_table_type(DATABASE_NAME, "test_view")
-        assert table_type == "view"
+        assert table_type == TableType.VIEW
 
     @mock_glue
     @mock_s3
@@ -470,7 +470,7 @@ def test__get_relation_type_iceberg(self, aws_credentials):
         self.mock_aws_service.create_iceberg_table("test_iceberg")
         self.adapter.acquire_connection("dummy")
         table_type = self.adapter.get_table_type(DATABASE_NAME, "test_iceberg")
-        assert table_type == "iceberg_table"
+        assert table_type == TableType.ICEBERG
 
     def _test_list_relations_without_caching(self, schema_relation):
         self.adapter.acquire_connection("dummy")
@@ -843,9 +843,9 @@ def test_get_columns_in_relation(self):
             )
         )
         assert columns == [
-            Column("id", "string"),
-            Column("country", "string"),
-            Column("dt", "date"),
+            AthenaColumn(column="id", dtype="string", table_type=TableType.TABLE),
+            AthenaColumn(column="country", dtype="string", table_type=TableType.TABLE),
+            AthenaColumn(column="dt", dtype="date", table_type=TableType.TABLE),
         ]
 
     @mock_athena

From 6ad67e7cbc23bf5cee76193a7db3cd2592b52b86 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
 <46447321+allcontributors[bot]@users.noreply.github.com>
Date: Fri, 7 Apr 2023 18:01:13 +0100
Subject: [PATCH 13/75] docs: add nicor88 as a contributor for code (#205)

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>
---
 .all-contributorsrc | 26 ++++++++++++++++++++++++++
 README.md           | 25 +++++++++++++++++++++++++
 2 files changed, 51 insertions(+)
 create mode 100644 .all-contributorsrc

diff --git a/.all-contributorsrc b/.all-contributorsrc
new file mode 100644
index 00000000..b499a8b1
--- /dev/null
+++ b/.all-contributorsrc
@@ -0,0 +1,26 @@
+{
+  "files": [
+    "README.md"
+  ],
+  "imageSize": 100,
+  "commit": false,
+  "commitConvention": "angular",
+  "contributors": [
+    {
+      "login": "nicor88",
+      "name": "nicor88",
+      "avatar_url": "https://avatars.githubusercontent.com/u/6278547?v=4",
+      "profile": "https://github.com/nicor88",
+      "contributions": [
+        "code",
+        "maintenance"
+      ]
+    }
+  ],
+  "contributorsPerLine": 7,
+  "skipCi": true,
+  "repoType": "github",
+  "repoHost": "https://github.com",
+  "projectName": "dbt-athena",
+  "projectOwner": "dbt-athena"
+}
diff --git a/README.md b/README.md
index b2424498..185db8f4 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,7 @@
 [![pypi](https://badge.fury.io/py/dbt-athena-community.svg)](https://pypi.org/project/dbt-athena-community/)
+<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+[![All Contributors](https://img.shields.io/badge/all_contributors-1-orange.svg?style=flat-square)](#contributors-)
+<!-- ALL-CONTRIBUTORS-BADGE:END -->
 [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![Stats: pepy](https://pepy.tech/badge/dbt-athena-community/month)](https://pepy.tech/project/dbt-athena-community)
@@ -468,3 +471,25 @@ Thank you to all the people who have already contributed to this repository via
 * [Athena CREATE TABLE AS](https://docs.aws.amazon.com/athena/latest/ug/create-table-as.html)
 * [dbt-labs/dbt-core](https://github.com/dbt-labs/dbt-core)
 * [laughingman7743/PyAthena](https://github.com/laughingman7743/PyAthena)
+
+## Contributors ✨
+
+Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable -->
+<table>
+  <tbody>
+    <tr>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/nicor88"><img src="https://avatars.githubusercontent.com/u/6278547?v=4?s=100" width="100px;" alt="nicor88"/><br /><sub><b>nicor88</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/commits?author=nicor88" title="Code">💻</a> <a href="#maintenance-nicor88" title="Maintenance">🚧</a></td>
+    </tr>
+  </tbody>
+</table>
+
+<!-- markdownlint-restore -->
+<!-- prettier-ignore-end -->
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
\ No newline at end of file

From 1c35b6e2fe578a636a51dcd5b237ca010c4e8f93 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
 <46447321+allcontributors[bot]@users.noreply.github.com>
Date: Fri, 7 Apr 2023 18:07:28 +0100
Subject: [PATCH 14/75] docs: add jessedobbelaere as a contributor for bug
 (#210)

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>
---
 .all-contributorsrc | 9 +++++++++
 README.md           | 3 ++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/.all-contributorsrc b/.all-contributorsrc
index b499a8b1..0f6b58f8 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -15,6 +15,15 @@
         "code",
         "maintenance"
       ]
+    },
+    {
+      "login": "jessedobbelaere",
+      "name": "Jesse Dobbelaere",
+      "avatar_url": "https://avatars.githubusercontent.com/u/1352979?v=4",
+      "profile": "https://jessedobbelae.re",
+      "contributions": [
+        "bug"
+      ]
     }
   ],
   "contributorsPerLine": 7,
diff --git a/README.md b/README.md
index 185db8f4..8c6ea621 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 [![pypi](https://badge.fury.io/py/dbt-athena-community.svg)](https://pypi.org/project/dbt-athena-community/)
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-1-orange.svg?style=flat-square)](#contributors-)
+[![All Contributors](https://img.shields.io/badge/all_contributors-2-orange.svg?style=flat-square)](#contributors-)
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
@@ -483,6 +483,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
   <tbody>
     <tr>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/nicor88"><img src="https://avatars.githubusercontent.com/u/6278547?v=4?s=100" width="100px;" alt="nicor88"/><br /><sub><b>nicor88</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/commits?author=nicor88" title="Code">💻</a> <a href="#maintenance-nicor88" title="Maintenance">🚧</a></td>
+      <td align="center" valign="top" width="14.28%"><a href="https://jessedobbelae.re"><img src="https://avatars.githubusercontent.com/u/1352979?v=4?s=100" width="100px;" alt="Jesse Dobbelaere"/><br /><sub><b>Jesse Dobbelaere</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/issues?q=author%3Ajessedobbelaere" title="Bug reports">🐛</a></td>
     </tr>
   </tbody>
 </table>

From 3150170b59114d4057b54449deeedce2a72cba0f Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
 <46447321+allcontributors[bot]@users.noreply.github.com>
Date: Fri, 7 Apr 2023 19:15:19 +0100
Subject: [PATCH 15/75] docs: add lemiffe as a contributor for design (#209)

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>
Co-authored-by: Mattia <5013654+mattiamatrix@users.noreply.github.com>
---
 .all-contributorsrc | 9 +++++++++
 README.md           | 5 +++--
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/.all-contributorsrc b/.all-contributorsrc
index 0f6b58f8..ae15c652 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -24,6 +24,15 @@
       "contributions": [
         "bug"
       ]
+    },
+    {
+      "login": "lemiffe",
+      "name": "Lemiffe",
+      "avatar_url": "https://avatars.githubusercontent.com/u/7487772?v=4",
+      "profile": "https://github.com/lemiffe",
+      "contributions": [
+        "design"
+      ]
     }
   ],
   "contributorsPerLine": 7,
diff --git a/README.md b/README.md
index 8c6ea621..1821e61f 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 [![pypi](https://badge.fury.io/py/dbt-athena-community.svg)](https://pypi.org/project/dbt-athena-community/)
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-2-orange.svg?style=flat-square)](#contributors-)
+[![All Contributors](https://img.shields.io/badge/all_contributors-3-orange.svg?style=flat-square)](#contributors-)
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
@@ -484,6 +484,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
     <tr>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/nicor88"><img src="https://avatars.githubusercontent.com/u/6278547?v=4?s=100" width="100px;" alt="nicor88"/><br /><sub><b>nicor88</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/commits?author=nicor88" title="Code">💻</a> <a href="#maintenance-nicor88" title="Maintenance">🚧</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://jessedobbelae.re"><img src="https://avatars.githubusercontent.com/u/1352979?v=4?s=100" width="100px;" alt="Jesse Dobbelaere"/><br /><sub><b>Jesse Dobbelaere</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/issues?q=author%3Ajessedobbelaere" title="Bug reports">🐛</a></td>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/lemiffe"><img src="https://avatars.githubusercontent.com/u/7487772?v=4?s=100" width="100px;" alt="Lemiffe"/><br /><sub><b>Lemiffe</b></sub></a><br /><a href="#design-lemiffe" title="Design">🎨</a></td>
     </tr>
   </tbody>
 </table>
@@ -493,4 +494,4 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
 
 <!-- ALL-CONTRIBUTORS-LIST:END -->
 
-This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
\ No newline at end of file
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

From 4074bc7ff075a88fdc1b6624d21b4e73881e1e98 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
 <46447321+allcontributors[bot]@users.noreply.github.com>
Date: Fri, 7 Apr 2023 19:22:32 +0100
Subject: [PATCH 16/75] docs: add jessedobbelaere as a contributor for
 maintenance (#212)

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>
---
 .all-contributorsrc | 3 ++-
 README.md           | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/.all-contributorsrc b/.all-contributorsrc
index ae15c652..c3a4f99b 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -22,7 +22,8 @@
       "avatar_url": "https://avatars.githubusercontent.com/u/1352979?v=4",
       "profile": "https://jessedobbelae.re",
       "contributions": [
-        "bug"
+        "bug",
+        "maintenance"
       ]
     },
     {
diff --git a/README.md b/README.md
index 1821e61f..1cbb8e52 100644
--- a/README.md
+++ b/README.md
@@ -483,7 +483,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
   <tbody>
     <tr>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/nicor88"><img src="https://avatars.githubusercontent.com/u/6278547?v=4?s=100" width="100px;" alt="nicor88"/><br /><sub><b>nicor88</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/commits?author=nicor88" title="Code">💻</a> <a href="#maintenance-nicor88" title="Maintenance">🚧</a></td>
-      <td align="center" valign="top" width="14.28%"><a href="https://jessedobbelae.re"><img src="https://avatars.githubusercontent.com/u/1352979?v=4?s=100" width="100px;" alt="Jesse Dobbelaere"/><br /><sub><b>Jesse Dobbelaere</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/issues?q=author%3Ajessedobbelaere" title="Bug reports">🐛</a></td>
+      <td align="center" valign="top" width="14.28%"><a href="https://jessedobbelae.re"><img src="https://avatars.githubusercontent.com/u/1352979?v=4?s=100" width="100px;" alt="Jesse Dobbelaere"/><br /><sub><b>Jesse Dobbelaere</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/issues?q=author%3Ajessedobbelaere" title="Bug reports">🐛</a> <a href="#maintenance-jessedobbelaere" title="Maintenance">🚧</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/lemiffe"><img src="https://avatars.githubusercontent.com/u/7487772?v=4?s=100" width="100px;" alt="Lemiffe"/><br /><sub><b>Lemiffe</b></sub></a><br /><a href="#design-lemiffe" title="Design">🎨</a></td>
     </tr>
   </tbody>

From 439bc7570182adaeff27c15baae888664fca1926 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
 <46447321+allcontributors[bot]@users.noreply.github.com>
Date: Fri, 7 Apr 2023 19:23:16 +0100
Subject: [PATCH 17/75] docs: add Jrmyy as a contributor for maintenance (#207)

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>
Co-authored-by: Mattia <5013654+mattiamatrix@users.noreply.github.com>
---
 .all-contributorsrc | 9 +++++++++
 README.md           | 3 ++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/.all-contributorsrc b/.all-contributorsrc
index c3a4f99b..1423ee17 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -34,6 +34,15 @@
       "contributions": [
         "design"
       ]
+    },
+    {
+      "login": "Jrmyy",
+      "name": "Jérémy Guiselin",
+      "avatar_url": "https://avatars.githubusercontent.com/u/9251353?v=4",
+      "profile": "https://github.com/Jrmyy",
+      "contributions": [
+        "maintenance"
+      ]
     }
   ],
   "contributorsPerLine": 7,
diff --git a/README.md b/README.md
index 1cbb8e52..6a314221 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 [![pypi](https://badge.fury.io/py/dbt-athena-community.svg)](https://pypi.org/project/dbt-athena-community/)
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-3-orange.svg?style=flat-square)](#contributors-)
+[![All Contributors](https://img.shields.io/badge/all_contributors-4-orange.svg?style=flat-square)](#contributors-)
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
@@ -485,6 +485,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/nicor88"><img src="https://avatars.githubusercontent.com/u/6278547?v=4?s=100" width="100px;" alt="nicor88"/><br /><sub><b>nicor88</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/commits?author=nicor88" title="Code">💻</a> <a href="#maintenance-nicor88" title="Maintenance">🚧</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://jessedobbelae.re"><img src="https://avatars.githubusercontent.com/u/1352979?v=4?s=100" width="100px;" alt="Jesse Dobbelaere"/><br /><sub><b>Jesse Dobbelaere</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/issues?q=author%3Ajessedobbelaere" title="Bug reports">🐛</a> <a href="#maintenance-jessedobbelaere" title="Maintenance">🚧</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/lemiffe"><img src="https://avatars.githubusercontent.com/u/7487772?v=4?s=100" width="100px;" alt="Lemiffe"/><br /><sub><b>Lemiffe</b></sub></a><br /><a href="#design-lemiffe" title="Design">🎨</a></td>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/Jrmyy"><img src="https://avatars.githubusercontent.com/u/9251353?v=4?s=100" width="100px;" alt="Jérémy Guiselin"/><br /><sub><b>Jérémy Guiselin</b></sub></a><br /><a href="#maintenance-Jrmyy" title="Maintenance">🚧</a></td>
     </tr>
   </tbody>
 </table>

From 3d31ab9ad0808cf52a89f61c944ceb4ee3b7d313 Mon Sep 17 00:00:00 2001
From: Mattia <5013654+mattiamatrix@users.noreply.github.com>
Date: Sat, 8 Apr 2023 14:46:47 +0100
Subject: [PATCH 18/75] docs: add dbt-athena-logo (#211)

---
 static/images/dbt-athena-black.png | Bin 0 -> 25422 bytes
 static/images/dbt-athena-color.png | Bin 0 -> 112239 bytes
 static/images/dbt-athena-long.png  | Bin 0 -> 152087 bytes
 3 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 static/images/dbt-athena-black.png
 create mode 100644 static/images/dbt-athena-color.png
 create mode 100644 static/images/dbt-athena-long.png

diff --git a/static/images/dbt-athena-black.png b/static/images/dbt-athena-black.png
new file mode 100644
index 0000000000000000000000000000000000000000..b7ba90b7c00c373e1fc69c536c4d140bb251c408
GIT binary patch
literal 25422
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

literal 0
HcmV?d00001

diff --git a/static/images/dbt-athena-color.png b/static/images/dbt-athena-color.png
new file mode 100644
index 0000000000000000000000000000000000000000..aca1b51b5471ef9b4d056243a4837f51121609e3
GIT binary patch
literal 112239
zcmeEt^<R@=-?oU9q#`XKpro|KNGWNMlJ0J4Mk*=Y-AGDzGYLm`caN@(j_sY^&;7i=
zzJI{`10M$4uJhVAj^leA=ee-YO47K`$)7)Y@&s2_MpE_3lcyVhe=yOJ|2hBY75@aK
zkylnyOx+XZr~~6So3sWWJY$=_<(=@`0`ZqGKYKl4@|!F)CAmn5p=b1&|D%jHWLU`b
z<J+4zQcU>-0+^U`BxnV}O5fgoB)8@(SoT)iMGT*e4g)MlhfiRQ_adj>egob)D+_5Z
zqnS**M+*zuyO!U&j5tVf&;z@Sw78E@k-z@)S9K8w!}9+=W133n@ISBODCZo;;``4#
zI7nwnAwd-X-i>_P7RRL<_wSXEk3)Du02}}F7`=zQC-dunFKrxUtknF!%Ygs?GXFnl
z|8JG1Tb;7*|5e1{;biw~&-GXk=;7(I=R{gvZ>%3mD{Aw}9HsO7E5L<Ta|K2>rJMYb
zH%xHMPdO`#`q}@M-iwU~94*uvVa?4DN55Bm*|3F$(>{w`&0LTAh|C{&{GidX>z0MA
z>Ye0ku*ilZq~L#RJ0d{Cqg$f>{*GHTfTHszd-O$d?g?*h+bX$Pwy%S`rCrNokA**e
z=>Hb>YK@K34KDZYeQONpC7;i3T^d<!kG{NhVC%j)z@wjY9+3?)8U1e~80(w<$vPvr
z?YuG#gt7XXlfXUB24b=)`K4=d(`LBdI(<PGd3^KYwUztmO~)|VfBUaoxjdDSDmh*6
z`jq|mrJ>i@ItPBG8#GZY)4AnDmr#sNj?Bs}R01B|s5y9Hy-_&&czP-60{(B49zJK;
z3^MeGNIM<3<*1b3LNYmwcVu0cliDkwboFihH!FTG?lZ{^Higjtx0P3WYctQ*T@CNg
zH8)z7L7ef}*wWqL0Et)~hT{;-Mryeyop<r{tb}`)AQ{ap=U&gaX<v)cn`A+u*SZeZ
z9RGK5Z(Moz?w-}vwl(N|^ZEUnq_1FCx_s7(8&Fta>C*mr1T*8DPOYTngE6<|!v-Ys
zzp0pgE$`gzm<d?-hVL^q*W6c+I&*e1(fB*L*rE0?`9PiK7r!FBMJ6(x{wM7{>BbHW
zLXw>xAUM<6-1y}h%z>vFZuEa+U%`<=NJYEeW_X#}h2q#DTzaIar7t(RNFxP7xlq0@
zU&j3g*!nN7&4A4q+FgDl_UBsHs0QU@+1QEBJ8M1(I-W%peLXT)XtBtg%!Wkvr3g%o
zhLp>=U-VqAlKBVx=K@+D&2Yh-z#QSU&W-McHL104Z4jH~YM4)QpS>{V$@tF=Jbujk
z<qP#A@4cF@8y;6Am1H;}9TBohp7Urs2b#i--ed_x$xE*Cn{;z!r|QfiJS((%4kVr1
z$Jh*dOQ(4M36t^Z&wHxAV&%Su9KWrjn_upbxaR3jKG4)KrzqO}%E9VN4HE9X6`Z?0
zK)3i#k9;Bm;#fW3a!i3T-l#-z9y%93<aO4!-j-_~qn-b`^LYwP<=m>rn=+>rveOCf
z5=cd-nR@z^(Odvs=h`u~4PHxEbqJ|jch&8D+1KMfILcJ_fb(@6){x}%*OszzQe9n<
z<jUYx9zVC%EN;I!=}}tDrl5b#QWj<_`dE~P>&NrJqq!fGY#WnlD$phZ_nQ?7rHVp5
zxs*I|shfJgXU0*^m9FI3eBXKZPBfI$6WWq_<LGYvcqW#eNwGq;ac<a3P9b4aup3_X
z&?Ca;MB%NU;QvYny9;)xaI(=Ok+_tsU2lZ&7S6lp`Ac8M?_SLM7{X53k7j*fXJ1%T
zd(~Q!wi@f39M5TSBU~a{LBc4!q+f^>86FNaMH-jlt0^f)_g@fhuC;Omgt+_GzL)!I
zWOEA~7u*8b{im3cqpDBt(-)?82~dh-QBIkzY+HEQA!`Ucd>+eXBP}%btTS8CjlmIc
zj$1606)|WYY!pdL(w18OIvKJaGb9o$7v=J``#M8W-B>Z}UvOZwlA!DMd+oa7aT4*x
z^dwAjS%rBuoN0LIH??Y~zu9I9{6*+DBkvb&C#}V*MC_C}ccU6#!(**;3mjrix@tE+
zyzSn0{oRrMKLt-O7UO3-M8D<49A<6Rp*hp~rQ0sEtJ?W<)|tq2`1^wIX;)~kYim8;
zZCy$__Y)4i$w5t1de0(e_|_>XJGt0R0r>Rc9nk<t@aj2xddvZ>;fYcvBWgy;-ywh_
zn(gkf((+P_T{=?UIKH4x$O4t9FMYwzm<8K=sS(lDh(=+l;uL7Sk6ew#@Bzm3+~8<H
zpYEA+&WRj?Puw?5m#OSgm0T)QZ&<nE1{kHOD8l2gesC8%cgHu9GhR{3{Wo(oZ;oKT
zBhrRZwj#c*cXrA7=Ai{cQQ;%WjhTzTX3<&5D}JnhbL_Zg*R38f(xQFN@NjqPL)B)0
zIQ&IOX_z~U{+@dLVPfHCj*a5!bLoY?nH7<#uRSO48fu}<!<h6TSB0apXcY4vyxPH+
zuKzl!2Lis_^}%afdpyFD7jcvEK4e*Xh+eSCrnX6Ax<Y(w6RySPZ9(#m5r=~GM$l=x
zFmc;S<aK^0RTL2hb<#t2``2h}E;?6+ncq>N`(>`WKD~4xTJK|UzG9PM(SK;bj@NbK
zH0BYt@^(4{!uT#F??a_WC>K=H-l+$oaZQ+Gfe5r;I^RoiRrbe4@A>db=_ZNY?^%l=
z11jnJQW32w>&UkxXehU56{HU@yUCPLbH+ap$)&5kcF;~)?A=*}S}O@H@PPlJ;=EA*
z#3^>@s}YAMt;eykycTjCLt(YwY_6Zh0FOXR?r$0&d#7sFDo)UlImLqng~mM9yBzHE
z=;KMzc5$(l&>zxdSxR>=YTgaEts3m{tbe*eBx1T-QL0jAdKxL(xwJV>i;1j<>KcNd
zYu+MmUNgAp2bCO&K8c^M1z*?OSw;9IG|JdcM12td##By(WHWmXhKKZpw>9^u{(>=%
zixuM`dhV0`icC!>TSMQeK_&w(1NC3Z1tEsdArk|t1excLj)+(`E{A`8_g<t@bQd<y
z13dPCr%UZD*oDgBc=a|mu#&QZRImKY0GsGNjH!fvm;1^+ZfiH5{wPW~z56|?F^Jhw
zUEqcHwMYZ8=ozkvJ<ug<NH@^gE0NHUwed5wbOL+c<16@@8`-=Zq{J_2?mCKf?|oaF
zxy<+bg@6~ozjVA#gv#1DyO|$>kc&uA3}b-~+&~M*(eZ5gJQqS~`28Q*u9%_{H(P9{
zK3@YUd#c@WU5|B&rr3??TnV*<JD24%2fsw95OA$*|GCmj;v<Q}cy-qMczU+J@b>E2
zKe99yi~YGq;_l+>1vFeDYzo}9m3wo<#L-2MPOg+Xw>oN;q3+V2MSQ5kc~9-Gv~cx%
z4T-CaU72Sr1`jgJ%?U!hwo&5ymdYKKw{>cRP1!>zQvnziwrWo=I9aI*u$%+ld#wjd
zmG`$GD5)o<Ui}*`LN3FQojl>Mp1=0gmF9XotAis7GVKEsimjaJx;VsGK7KKO^~R+a
z7aa={WC$m@ex<1&y%-G`DaRSVa_D1M%+dJLSkl^ZGj9fn@k_rW@M$eiyMcT7RR3d>
z>d~(~!E4<b#iF>KOSh84=f55a3~b^osRZ*Da4T>)QjGPC@BM#w_>(Q2JbEI<1kOp2
z=$1i`Rx)adTZ9mCa?yuaXfk{Jna@MgkV3?X@JUFYfw~1>qAYuwx=1rOoK{}gzeu~x
zJLi+3&Ooir&IjQ+%T8oeV;9UU{*}y;ebC<Z$$}xih-RDF095c}gXSBTZ_72p9k*?A
zoW<Kb#OakZOKC?#RoRdDN;hASA2s9|B<S=ZqPnSglLP<W_qwOFy%JXvZX!LhFl&Wd
zxG>TI$+fBfepN6YuRBDil412(wu-XPg%LVUKcPBXtze!Z^>^?x9{Ec<Zg*2{jGila
zQdU<*=qqu>Ow(*Iu2#wfG5aWG9;3$YEB`)ak%~Hf^gyvs-8uK;4*E-<z;bLox-5|c
z%Ys`meE&*v_Q{+NbY%Xq#$V6>s+Oovn*lSYQFM=!y}MI7=Xs!UT_7m+Hk{!{n-{B%
z@Vh}>^HBGKIptxxsc+}fR#u6+2g5wXZif4<v$a=;XWb6W8%{a@$qy8B;<Rk-GSdMg
z(ON6qzFc^J<|yiYMA%%iiM-}09D~Ab+!Q`*mt;H@cuEK#-Ca-ThO-L0#~+q4#L~r-
zL+MI|E`;PSqrM;aOZLu9fA0^b1vRGdJ@b!E98MV`Q>%9_G++d2wN9fHzP%>d6^tI@
z`Q}BQlwspL6z0);bw)J0Q1zGpl4EQ|E-jAktfKv<04<McS?L)%9?tShSXNzB)+9q)
z=@K#Fls)MS2;XQCw9toxGGh)q3l0XKv7;ADmH6$?TzZYXX~&DQZU<-g@|xKgk_EC}
zdMz-Ge{r1~+uf~uwKCzXLvh6C(%qEC{a4`1e~R=o^cW?9)T6QlC)F|7-{vQ@yI=Vq
zuJ}<cQD0DSkn*x1f#lIHzGbrk#G@znh?U3%bCop!<Zy9GTSS_K60QhV85$mxs|r>X
zD(0z_P1zWO9fw9vf1sY68ND`Q??Dn+k6F;~>64gFba=Y)@pYz}`=f8R6(&ax#!_vc
ze4YwReaIDJy|1(XsZ@v}HY5l`53Y&d6IGF-IQh}lXS(9zQS>nY;%PB_`fk_9b*ab3
z>6S<_$`6Js$GM-MWj`IE{64fVx)kSgMqJNboBcI#d6?!u^<sl5uT<%`Yq+^s<?kbY
z0&L%SQS4EV2{2x(|7e|3)@Vkig?3MEFfFv*v>N1V0YdMwkU+AT7ed~`1K}vfS^DAU
z7-!Y+`1@xsiHTiONOrnlHKy@~@(CX%?FBdhJ{;EaL<5%Z9p#m|9-f%{T@!h2@xATf
zhTpIW{Eco%<eB8nFAtGo#F39U9nP{><kGO(&%9@91yj1Qj=^QN8+KU6rgP))(BcLR
z(W_u&v?-9}-RdAa=(vls&ey4S3M^Ao3sf4JGgs?><*${P@zTsnQTz9g2tlzE;KX!7
zEE6OKtAR;n(j)YB)bVw;6!_HYZ@<qkBMZ9v!tDAzW+A!{#&}DM@)Lg<Ihcuai6xf}
zn;Xk}!kWahah(MOB|iMpA*#8nI_)$621*we=p>VyAVik$+pa4YOtaet)&1!CqlaH2
z;lLZ^^e2mkLz$<x>29pUB#$M#T2Wz{CTj#_|AK9&8nmva<>%Z(@OWa6mgBVhIOvQE
z8;?81ixS<nn@I1AwxnqPawYm+9&pjLYBi*alkxl);i`0xKL*PdRE6ZFl_>4hAh^u*
zL$0177EZ#8+r+QQ(qp>C1@=RXLs5O5hwN^%CU1>)Y|XEPk4Wv>=1fQa>cWhtAMRF6
z!=p+UGMP@k4n-L_WC9DT<K10F?y2p@zKdRlBEyQU&LFgY;O~uf<rA)?z(tRps6>_M
zYX5}TM4`DzQQdUTMrhZ`OE=-Doe$+e{N-LN+F)z0ieF@>P~}j=X&zFLt^S>hLZTwh
zj9Xb&FZ!C#p{EfnJl-71#pV=@S;-?MY?$Bc#e_(IF8r8G-pgsFPB67U_Sd55%sEar
znSWa%ut6jK^>z&r?g<FilV0g4YbjF8#XV$_@KyLUqA>$SwQp+v<h^>xq9`HX_i|7r
zh=jjsEc2X$W-(<1*+HMWDq}i{+eD!0C(XQl(S;*|>`lvBBj(vAOGPG3ysp2FpMIHz
zI|A-ry}m2Z>^7RmL9U2mtUZX|YR)8K5m|AmO4{FUVm2lr&q9&FaBeXN(MkzT(#GZo
zqoSqMqBq=xTe`-ow#%^CY{WGI%4HhIX!!ojYODJkQc|1!Eh#Onpxnu%(;F7O>nwI7
zzgWf(;H}lvtvjD(TTO6_RaeP=qtEdXA{yh7ym4j4VDf{V&xfqDZ`Jx68mEZ1RNtG+
z0pQ_SZCT1yxr1lKJ}3Fo)bzyrFzK<$IN0~G&myt~$1qmqNtWZxPl<WADsOnbFU{wv
zR!sb7MFeH(E?Ng7J82Do=0b<Ed$<AAK?Xktx$N^Lrh)VVvW6{sp5I|l{!R})Pff-c
z*22pyCr(f5U^+77{a5rOz8_mi_y(pZ;~(nvhTrdM7oSno<^6dW(SB>?fzBg{E`_cw
zIuc#^{n10$W4(Iqj>KDbs(OR-APD2=uHUw;&jY7NJ{%Yuj}_{aYaN_2uuqhb>KsMb
z$MGvK|C4<FyrG^Xv7UK%lF%>bFK-weS+l~W4hQMyLhuUo$j54Uq2?L(9X)~7k0LRD
zWf4cYZNc6(K;l9-qbdSWJ;dRV@HW1O(*9>C74K}jdRn1L+x7@by?_}1E>D}_1Kkk{
zwyL!j>OFO`I68$Xhn*Qx#-djG>>6&QkAVym(aFn52ivZG*gSih)aF{4Ss)FxsSh&L
z_suTR_aMAgNYyO!>8qUhkjv^FF{>r4>-I^TUh>bs);WAZb4M8<!xu6(YU|=cXHr%a
zwL@LU%}S-VXB^E1OO}@Sa=ggAgs3*(Fa|x25##dNSt+=8qxzktuPIJEgRJ4AR+9ca
zcS`!v+`7@+h_K!el@qvFJUf(K1^g<2Mp(zO?c@YPOm3wE5$bEL01uKOeP{~?F73s`
zLI?K5ed291y_!N`qMJKGXJ^ZnNDSxS@Eo}Xy<?!c^BtKJoycnIl8IxgPjy6D2>}|{
zO}8g8<obSIMw8IJ`$K4_K`T$c0o;^%Ver1Kpp_8~Y-E~S)!Vg*M78T0t7c<UQ#J-6
z1-mRdzm293swJzR`X=7f|AI^58yyh~I+RV5>`o~ux!hfHEVw2Z@g0w=D}a)yb2wmT
zl!gXj)R-?56o(o7W_VU*A^RtF6c@*jiO%MfDreI$RWh-Q&f{qOY{m3{u+R}`+he)A
zcD{VEkrfpFvpmm-43vY|)Rh@_sM(<*@~8z10*ZKawdBxE4Cg0b>;w1)ugfV;NoAM5
z)r??$>4S$_-E8~~uhH;M5JpfKEB_{+t9RL;_ZFvR%u0r4CCPcfhE@0!j#adYcSqgu
zuW2SlJ3Ij!uh`3tThopUEb5ZJoIHibXzDu}QS3rYas{f7G{2*7N3e4nG!*cM)ZOQ~
zh>-H+6Q)@H$z!2%r<)AZZsDB}f6NMbUf*yeZ>X)1&MuFY`^Zcc$*G7nL8CnOAClW|
zGxdlKtTL${TnZu=K_ol806pv|cSmio!qCt&xOCu;0dF*n(GIwz$4kOi$(s8A!h~>;
zdAw%l7SQ~{o6fYtju>~(^mxRK8rMJY?{!`xy)4v9(AiS65Alm@MQJ^XTCYU6*QPH5
zcP0(76yjvXSmtZ<oqrrs<}eB9bW;7R)3Wbn@Z-Yyto${e$c6kGq+W5?dF36xqVpV5
zF{R#8oT&e6MJwHR^?cp1=c*0y9*NT-?~wP~20DYY-4V<c6c+0bguU)AJ#TJ<gc4Di
zDZ1*#)66Nc+-@~wN7W|wL_m+k*_CUk1j99la{!_t0v3xvS~)H&7`wBKwy(8X<xqqh
zJ(m<*KT5dDKPT$oWvTEpI?29_0ruHETifgW_dtJGNs87zBju1mC12*_iT@_0MGP^u
z@O{JBOC)U+Zrz<N+!8!yqXpHUGF1Z;KJjd4p8UvyI+4$=&6F<SwAuvvVFWBRY=gc)
zv<0fXWOJ5MlUYj_zVjQ}x_E1_*(AJf@BrAe9{E?3go>QpA}NhL`ERLU_9mTrGv&!(
zILoZpy`t80GQvajqvTk=tdYRVLn%>m7GS3*-sk$Y%J(8?s${h<0To_rUWqz|l5tq#
zqHLvkkj~)!RpdD(Q7xM+u~Xf8Vv1h~bQ*KpRC;?5`YPe>sM!U4dOv?Mha65JT_?(&
zxSIa_cEX-K8GZ8?C(U%}yOS6Ask^L{n`{}W_s>PL$C~^iiF@1A%}Y89*zFVRYo<G=
z&5X>u_N~7TN-r_8Gs!D964fKRu-3+of{g=>7nD4I&rkzb?8JR2TYgfpeSkdGPY3JY
z6+q<-M*6M@hbCP)TllP%;<PiSi>K9+DK<(EK!3{IQ#RxPGq<znK%E8#N%(q@qwulV
zyjR~}M}kxb)3&q9=N|U;*kd%+F&a0vGhfEkC53{W+h)n;JUczhW+K^qpenMlPQX*0
z_Rw4>0YB07!{AdE2SgyM-~1LUxx>7c)(hmw5bhyF;w^&s{+*dzDO=)DMGwG)gC#<R
zI@1@(DgbSzkI5A#lPhQfc37%|j7#=QjC7Y)2{e3Jv7)uOMQ5Il^!cwz#GK4VItq{c
zH6lKn%=v?G+bmFW2p*GR<EowboZ&S<;UWyHA^xJ#B$&Y*L}SFEk#<(?=6%C5^CBYS
zVPokSO|d7WI~=fqB8WIIZAQ*#wAS^Gg&8I&u%P;kQG>%|Uq*@^3RZ!GhV)DnCI!wB
ztl8HqEn+vEUaY|SGt45z&Iaiga(jAe=AGqXGLUuC*bVPLuEa4WsbpEbv24CNVvn63
zY?q>;o?u;|vUatt|8%4pk7ecg%WCLdWnCeKX+0LM1@<R92^BoLMtip-f6VEl=2KH6
z4!c+7C4^M&axE7-%3xf<9$pn!f}+=%fchB7MIVsPKV1|OPtBLhjxn2QB1bp$$MLst
zT*Q#xU^)Pb&;M<va43tOrEmN4c^1@MjiIQZy-3f^EbE~kKSiOle{u0%_j<rQL(b}0
z#_@?&cBb-b`!majj}gd8EQ5T`=MnVv&r*({ORwdG<4l^%Fk51y89(#G#+}gc(B!SY
zOS22vWuU!HrugEkZ%Z8FEvei*fWFFom-1xramfv7_MqGNSZwY>Yvj%n!cTV4u*Ybg
zQA>qE=#5XW<*q2)pvJJw-BA#2%kV&T@bm7A)}dl^gI|$o2*Ca{lwI4hn>}aHMa0ki
zgx`0R#jPv|sU&+K5<mP-@6HaLE*aLqlQY0F&Natp)AqT<9rSbL>8WFt2lbE|T^4IZ
zAfW^M1qJW(FUwf?n9(=p?B38b&YW5O6D`Sl0+LJ2j}_#VU6yh)GdGf14j$G_YNJAz
zDAn6ou5ypkj{3>!7I(#I@)x#XYWpE|oDke-+cAJC@gw}u+{e?B36}CnY5_j0$lg)g
zgxUaXa}(LbE4$QYZGoLTA0xi6#3xE4KP#pd5wgM;>&AYM&OJ~$$#u=~j-zO{yKWAh
z%i>R`7>4+NG7P^+I<E*)+m?R|efJujsjlZ{=tJfEwN3p5n#y7o)*$w!Z<Sq44pg~^
zpC=_HNWvORu#Ho!QG=I%MSGD+m<g3*eLzzByl3-)FMH1nLNR~M<N;PsL%Ar#y!(mK
zB`)>8J`2ETFW~XZIaefR_JGD(ZrVUg9rl@GgJ{9jH^i1TyS}qr$d!66EMhWQik#_m
z@)#s&gc0p^w}h0w&&tyYsjBZ`)W7j9Uf|Z6l^a&Qr+;+?$LXIZ=0l7CBDRn5rrc`#
zZekTj+eR)&)63&xQiod0qhEWUd06aqpeFiI{Yn@-R0}Ub6P!#enP&`ZK4JgFIG;H{
zuOpTGTvXdIch$lqddK(sA{(uIlY%)h?gFA<$wS2%$)?Si)T_5$OF3)4VZgzgVwfst
zU#p#E_^lgb*{EsU$#3?hcYrt+b1k@BdhXaLif~Z=0@c72>`+}D0t=iMR+S#WNY4)I
zkY`32yeBDMs!wV}gbJSk>sr>53rLBn%aHS@-sQ%ehrf$h+OwNp&RWVOE|o8VxD(bz
z2}whSLK2&@41&kD=22L+8(Nx_22pJFSXDJrbP>)e^|H~6=0uCVhHX@Y7L-vGPrioy
z>5WhwBd=oRwiGHSS#w`R{cC&?6STqakGUz%Tj4uHfIk1{KI*Sco%-vV@7l}61;$Np
z8TZo@Sj=DS21izk$y3eUjB+mU9mmiYCz>*)8X=li9*dpMB;f2gAyR$6kc_K2OvM=z
z=B`H$=nhU`s+_8FoB{EoPfOG!N~ef<rjn+0P+Z17fCm-+d~EaB^j*TPJS#t`V2kN;
z6O!dq+jayV2gg~j2=81FkgfeSuBthZQ0{-$xVyD@>f^Mqm9v8%JH-8PQ>j|ItlnQp
zsN{#`688DXNL$0bDd4;>n&%6y?s%-c-vF@w=z}r+5`trm`nJsl{Te64?FWxjH!9nG
zC?eE$EKRX-Mpy66TG5nC?8CM*OF64!)|7d1=sT;RH<N5VEsQ;w0n}2QPUY&J-}dZ{
zve@~$G2VaJ99+}tB>rW=HO%57l<dq5oY`&aRLt2YMNXLOzKEE=2p}MJbEf1ezUU}S
zTJ5|A%7p3i{?5}9oJ-9~o%$70rn1O*=~Qg6w)yG%WSpDLOdF8{wI|s8$IJsO`J#`(
zd`2>^UMJFl^ZW|N4Uqz;12&9{6W4zj`fq4Y`2ft@d0`59b(unH+d6nvOqW^D?UiP4
z6!N&MUaJk2yNaMKo$w?1`r0a^1UJMj0J&><ezj{nHiz(@=|h+)oWZWi5j)%Z^5w3S
z^z%J|)KD`!P~X^ZBQ3M?G(xIzdwtT^=L=O7C(%2PoE+qJ$M7g>i6=J<ub!0b#*eCx
z+y9zx|42(qPMrplYSX%xfqKS~Fdx&%p+06CnM4N8L>y{UB{b%GF}jMoX|AO-CVKne
z>vkx$i}qp;UrkZ*OM?H7b63RO3FAX+S94jExmw5P?AD|AVfUrpHtg@B^E(aepZV1a
zePVn+XUR6@8m^I1{}j31kl+y0LyZt3#fgaIaqC9ye&#bEpTl)Tqx1{~;Wa<$cx|gT
zE*F&2aWhvjuCD2_RXp$^dsfbnIS1PMP@75N*1c=X;w$dhB$ZwN{aD{@8Og=QtS|D{
zjQ0m-{&<Vo3c}secX-J5COQ)VIT`Z19zaDFjA0VyPc#WQ0rlpSo;D{{m7?Dc#qVFz
zBc57RP(tbu_jbYr((sc*3nU(Kyl0+80{LGa-JJA)cr<wO24sW@c<>R3Tf!+4;(E>k
zNxLu!-MXHvKl=EF`qNA34pka4ch5fX9kp{uriBkYkNtt4riu>u%a%~3$aaUj=hMm?
zh>2VRDU-72C!JSHnbX@EI|TbYzTYkwbo|BW+J6IM|CZY?y5Y+dkp3so^~nwU?#Cx~
zc!XSF=Y4X(=Q-bqyU&vF;E^}hBejDC3dK4YulTUzl}G$=`hsyo@)<%W*(Ax*UR%w^
z3`qBL8k8&{=%^6O4jDRu#ws<MnP=b15Qmh_o4)L0SSFd=n0;Os5QCpv%+>}>p;$m$
zuJI2~qTYyO%{3RztZ7tAoPDBGOomw<>INqJM^+^pBvgRQz`86y&v0!2W&I0=u^;FT
zv^J4b-g7S6l9^0hG6pogwO&ls(-DB=>ehX4@Zk~RS^aD!$KcD1pQgOUK6r97k<-<M
z4}6J)mp=wBNa1jICb}_*|ERWe^4h*wv&fiH^ewTOm1~-T%!N$A+>qy}c%B4wO2Rzg
zTwqC(9t}SiW&-^K8{F0yZlPt)n~4~}cxSUIDW=WdU50bBz1OmMQE(iwj^7+<<czmZ
zo3qWz9lWCc7Z|^w(;Rfbau84F^v{liNfB`}!bZAn{lSb7JByw~oX$*fbN#m;D6tZL
z3T+R&SrmouYzXOHmNGM8bQwm3u;2kS%xP{iuS6xgVs3VJyN$Hek2H{M3vCjnZWBSA
z?q}ZD1H)v`RnpN*w)B_e+hpS9rF7bV#70J6X;pb{OWT%A6|zeYdbv_}&=8tTN2GhK
zpZ=IgP;$+4+-A2l3GXCYAqLyf3WTkk-4%cNLMr?U+_)+oe_mzaF@IXHw6UJX-H8ah
z@|-f#dfwf7N}$zpp01D02N(7+7a6kt1E23{5b8+4PavXgg!qZD&%t`j>0GU{!rz-x
zx0UVZ9DKhU;t?TF`+}BYfrx?sY+7vn+S6@Pg@kw#(8b(cNtjoL;+R<GQ0fWC@QQDx
zYfa6GS8iZ<pc2>2(31k6<aa3q)S=%nzsKr63Y8{rgn33y1$;d~5mtW#)ZFfW9(<Lr
zs^TvjvnRyztzULQg)4RPQcr^TN2}SbwV;{6%XUhWRaB)`RJ_*HpLP{_T^uir`^u1*
z!S~qohS=vpK6}C1ZQNe%k5Y*_S`@zru?q_%Hf3~)K&_RHWQ-A7)1K}twmEjlU@jTV
z$ArysKLAv$Lr6bB4c!C_ktp)RZ6heOX_q|>usL`7ATs-IJ2QVFIJ|-pvMa~yPFM4c
z(M2z9^<_S@R+MpuG;GyE>Fy^meS)t3lz|+R@IKo6;X@<*Oc*IOT#xP^{MW;;J2R1k
zmuVydxTiSEeFCe(v+2ChN=r(#4X4z9iU;gZsNRzHCr9t0HPJ`ftShs@Rq#L)d~G~w
z`h=PV532Vb7WRn)O~;J;R&y!gAwKf;{KtLCxXPV_j(C)8L*dFbqny+n^i!RoEA<hP
zj-tmXNPAhh75}vT`gFj#I|=~b-Bq+^qid}xN=;z*e%dZcE<aE;k05vpcu0Z2`n&E5
za$RHD!FPx=45oZ>4-rM`Mw+2_2i`q4-tFLX-Q<D&Tjmkn!MIyg1EIIuF*^mXE7!km
zl6y?alYMjzw9&T)3<hRkFgg!qD$S4;mL01MS$nF0OItTyn=S1Mc~K<iu%r`z{WYUp
zWDmF~TEWg-QoeUW+OuTFhh15Y_ZbdkgBE0n9iN3&vE?}OhV6=(u*r&_7HF`Ue#1H}
z_1)=cbF7xEQl}($)+Ng)<94Basau>g@X*WkzK022B*fCrCJ|B*<TDGdT|Fg6leO)8
z8ge=Dm`4q6=RMwixZO$9Q|hdj1vbm*idUk=^hwb0zL-d%TiEV3j~B0d9G#N7AZw?^
zX05Ei3QI`xjAI;-AL{2h4PuyUk)PA5U)DH~Ii!WzunSpxRc6+?OF9V3D)WHF4S(V6
zzaEea)>p^Fi#r$8He0T4A$a;$({B&AnHib$glL2aD-rGOK&H$Pr)J6-U7x|M$}Oww
z$WgK-(fe622@HfoqG6WXTDm}>!}QBBE%YF6@_YUe;21HX>^ov-Ao3i&C*ODlDep9W
z_Hw@Ngd)<$JY3O}VtHcgB8Gpiz=yUr+C7;M23^k`ARH)S!*=cM&u3JBypL8&wi;q_
zo0&9@s3>at(oxa{9pq8Bimm-KHHzh>wq_4)^;zI=u>Q5*GbS?d*PSumq7y1@zsSj1
zU?;0T#~1x`Qs3YBzN&~@F{R;yPIPio-$wwbX)oqH);fr~E<!>8)`k`ZJVLyPxg+%U
z=&O#^N<pgiol{?_Yq6ZkrJ3kFWv!P71xa+IJ6XU$r57{jX;q&v3L@!xBf|95KSlLN
zK&2j;sOw?h`gJ+8|IEo0M)PF<8t*KK39l?756NfSal4vPuNbp(8(%EsQtwW8LdsGK
zGR+alCUyHM5ih(r-v$*EHoI&%{UW^GYM$Y#C~c0~!EsQ9&4NBeed_ot8bW8gjb2kx
zNh<nmbhPW*`xTNZdRmb)0vqs>dNbXnQ<A>Gn6~gUm7!a1)9leiF;|aL7S2mt)*MvO
z40W2_2XdYHl{l})!N$FMs(Y2ipM+Ey_P}%rDZJywj}kM4&N@3a<z7(-3X^P9_?}s7
zr0HI6$lU<Ozc>2)aW;_sH;<+73tsrr7HB#u9*@zPg|}3rFWo@Z_gl9q`_T`II4t`|
zwMEm$$|PQ}=oj-|xZ{0Z+t!)(2juyf59PKDLgk|Ed#8R`cKUn$sgBA<b}OWy-}L#N
z^~#ohK@JM1P&`6Zf2Kbq3EsXbFBlF`L>68pxMq*<$n&OAtf*yv(H`uM(l|Ds{goLx
z_mSa%Za;g7`7+Bhq0!_%k6R+ga4_$(>tj-r)a<8z1<>2U%9^`+SFvsSPjrI^B`1QG
zKE!08HFje}g2P<Lur;#D#4ql{@jHxp@lOMy5c^xAgOhb*e6&aUZ^0C?R|>N~AMebI
zh}<ORf}~M|8*pVmsqj@T)jXg8Zk-u6vTx3~6b5CAO$e>M(uy4rJwo0Wr;l|1Qi8ON
zyYG5VLEC)&(M-<>9fqajXCj?I4wqn%lziKIzfbYDY0PPI#6XfB%1f>%0ZFCeT}6}V
z8b#B7U)OR+>GX0wqa+76=DinqYnKMtGG<6ZN(2*jTr%Qk#+4lxxMRpf_?Ko6fDwB)
z%C)ib!Oel0?}s-Qp}afku?B@|xWribsVN+gNqg75LW4;jXYoJ6S24;>?3U!jc!#UV
z;q4@#?(7kCAB8pX<oiIK_K3@v3VsDn%t1Y4gf>v|Hyxd7zV$1}^!2lFR^e@{A+ClG
zRYba++jl#i8v+<Y{F_K8cvdiAi}Ll^`j4fXoD9zT^Oy<DD;p`J<W0`8zCh_ChUN2D
z7bXi%ou-fHMW8E_Bah($<T(p0?2W%W4a@%PwM`uan|@?Is>Pr;b4+@HAwimh^;Q$o
zp{k8F&Zf8Z?G1*qs3k)&&tq!ZRr_Fr0%$zhJi^w;`?753C9UgpLpDGr(P1}MN$bXy
zJ1YJ?zZfpd<?70DUrz=*;TyxhDV-rhTpqSkmM&o#wLU(9Od+&7nOZ9^qnO+>x+%sF
z+;7I<(H$|STKslh0dH_B57|Lh7L4#T!#!{=HMnSO;_w4MW#UtF)z`~MfAC*m70+$f
zaRnDB&rufl3}P+1Li5HLtwned0|TEo{(Rj3VM=`naU&1oi;Fsl7|BuUmjOzoN%H{B
zDFBtHt_F<0GHQz>-kx5<N!R(=s@F;rWS{ryW>?=TYw3Dl?uyJm+KV2;`ETIJ*j|Z<
zUwH588uDitvOlW_Oo0*Mk%(Fma$LjFJ_X18XlUy%y5hYbSTfV=YUh#?kR<0iQ>h%)
z?CxZ&g?5v^!qw8|z|jDIB$1F4)4!y0TF^Bd2XH!&#<~i=<+O|7`MxcjfFnR=mChI$
zVx$UCDh_au|Bf}d%N6C&fL9<SPwQqZ^xcHYVM2rEkj{+F&NR@Gr<s!;HLlP~{Fic~
zy%;P{g^wx5$5D1jZJYpDqK6`=bbp@44VV9W^UvA*Pg$IH7*?&fsGpDVkRo{6-s~QU
zTL_#EwHVAtRcf)~Phcgss~!KG#ZPZkn<U<MkhB<qhqhdt<=opNN0y*qm+m%7HG|7~
zhpgrUb&P`Va-GvW?Dew60$U?0^zT^M&F~22MNxoC35r?|5oSQ>ra2-0x0S?g8Em-)
zW@znU98JcDm5-wgWTop5Wm)66_5~|8mC4aO3*a}v$vYNjV&Cv>%U^1gMBNdS8T!jk
z3`mT#4JF`dM>bb?!>)gZVf8sk6YQTo_ZUA+v^$sMd8`-FNrJQrGrJSArmn7aM2xp&
zZlNrrC5?skh<j=mE{D5Af9ycxxazM;o*y~hkc_=PKlBLcQ#SBmwC<N`qwhh>w(HqW
zRKAdFg?e$S0Q^$fm|SPVYPjx82=k}*2c3Tk)w`tYZOQxTL-LgBE3_MIvQ);XZ)GWa
zUsc(8qpN~7qIV~Sr9SjeYYD!ZpdtXuWTbLCXxZ!C8lH9&Q77u+qtD;0Ep6otRt5P<
z30g^73(G8~vMod@lnL3p5WM)X@ZDJ+T*F&&KI9BNNj1lFfpCJZZT`jEwHq}6)o(-I
zkI-+vHC7Slg$A|SfMBWKJNC~_%BI%jQ7VG(9N#1wHY}^(^*<fh&DSyDWaryms1f4n
z$csOru-6`+jKp9r8PBqjHY1a3l&#xs+fuqlZkAW)W4b`h9es`APtwsT5az4&BUoD9
zH|#MCXQXv1<O8K{r3)!cjkZhz8O+M!?8{hVUVKOp?e0cy>23t)M;Kfpt#^t5laqX9
z#s(m&kau>DjC#I>E-5a?)w8;f!B6xRH_4$^?$Hxp=s$j;-_I8<Q9L%T(ks3|PtFlq
z%(S9X7g(&JK3Go_Fe<QnganGNx;DI%40ix8qJ3l)Nxc6_%~`18NuwqtJf7*)^W5lq
zP9#iz4Vte#zR661!2SR)yXsAG)|d(w`i9gVZ|jehm6b7n&C_V$O+VhGXM-03v+R=H
z_LU#rza(Bn8k{j-JUVxi5}-DL{yx_eG*x9j8`!QZmqxk0+6LDt3>E1kjKr-Phm*-V
z4hb@#NBW^sLweiEPf1^NA$oYJjS(lRu^`B7uAXiqH%5vAm_+m8hY#!o)czQH8jb3I
z!BBI#z0_rt8h(a1f-iEz-h2Q;_F0a(PWgFE%YKr<c|pv%I)6#BvwEmbgoJ*6d?9N?
zu{~=V<8!iTug$ue%eNVHxDkQD3;ER{ffmsNmnr_#ntq%565-@q`;+FGJ=n#7-5o{)
zVj9i%b=66Rgb!(+7i0V|A$9k`?{iY*W5ZcFZQ@tMsu6De?b+k`Tu+ktvG$&24i*B`
z$mPgf0>s<&E#HQ78bTBppq;|sTU*M{^XJfQl1dcP3=JF)6(FlT5oRZMi^T${E@zMM
zYotrhiW5S7m3g`2a4QRP%ZNfqQ6bWj6+CQk8MF2vQ1{vK<kFIq-JRD1J;&+QQk{u)
zZiHR-WT$-A9-An9LD#)X0Z8*q>qf>?QY*Q3_lVt8N~KPg1=oI6*KAlVbZ6Q(*mZ_W
z{t!LCQdha%zDeN^(h~{EIt6N6Cw{H^4Mq$~z(#a;%l=rBX|W2cwT22`gz@kBKfXoQ
zVONM#caP~DHsY$Ot%RQ<X)*sR7Hjh+%bXb%tJO!C5uT1ISJZi)6<O0F;9ilYOf{S9
z=IzBqs)MhDLGCn5;SNi?^(?8)l&fLFPoh|xhMGp6^iS*%^UF7P_5<j$q12(5F`>%{
ze-CzNa-5BwA^FuaJ3Vi>HZT0$O8RSTA-G1{cR776fr$j>Dsj|tH?^(6=k|;bdD9XH
zX$Dhwe~$S0*F%Mm!jRO8Mgc~aANpPZ3F6CctcU4j(tV}C?c@%J*ag!q`HHT_Nn1LD
zx=0+@oCR1WVUMTQC~CIE_D+_=v8P(tQh1Q(n+n*o(!u<PfT_(kqq3*LwT$2yOzH)_
zrU?VRjtIu}Ts@#=t_GVjZ3#=7DsYH(O0OPU5-&xAtMPr#0QHj2uMpDk=44f&)G?v_
z@?PLs!Q*pp?K6}sK|4s~8uEO{NF<BMd8NbSb<~`m{g!`1l>ZlM>7dJAzwh&mUmv+d
zbiBJ<_J6*i$*Olsj+-CT8jZUy@Uin?#%#!2CweAnINFL<x)MEg5|Q!H?pxhg%|HJc
zIihFRbq1Y+4q`&ML!BX{lN%GMZa42!EL~JPi&G-;+LS!s#!vIN4BAy`f0T|7R_IQf
zGk6juG>I+wry*Qv&rMNO%D1aZ8mOji6ANuHBh@}1>@7RD*cJB=@L(!p0b12gWxS(i
zcnDW0P)daF4LO=7gCLYO&Xq1;{7wYBd)qHkUJUWGjmf4?%(=`*a|%R;&%<t!sugxd
zoEy84v0|utN}|#*q1eqC34pQ%(?U&SNo#r{#XTBIHQKaxcft=v2vH(skx>s)7SYhw
z!-T6wVQSxaE0ZoVQ8Y592Mu>N$lK}1b=+IPLQBkLv%pCFPoBn-DWn^kTgtn@LF!bq
z(`nbjhmzN791VDQi;rLQ8G25W)42WihLK9>1`O87xqsshKP+o2_UDBgZ~4=%#N8)M
z9NPHnAhpTfSDO`r&UE0*=-Vg~q<QnoP6oLx#J{2G6VRS2dHPVS^{u5`GD6{Y&v_<S
zahP=SONq!9m-<b=<*zcfzB9o;Oe$4lc~xIlYf3hl>G-!owak2aX!utI5tka=3=a~3
z39#q}--846+|UT{n0wos3XxE2Vlly3Q2dxoH|){(2(s2CrocHwxi<>jtPT}M!N`2&
z9^D_)I#}@(#?Mw1L=&Stm)XDGTf<`Y{7Y0z%(!zV@iPQudZz`4QnZQ;rI^aLKI0*i
z1xDDB6!f}feHyCHhQBIe5W8j1aIlS~tY|@fsRw0>k{>0pKI3J(Cv4I3kTU@}$t|^d
z`NLcaJlGF9b{w5nVSY)1b|Jyw%M|?}eZ$9B%Jt_t)=M|L`>3EdWy8fOE{YlRIpHv^
z>_wq|<ViM7>w9%TYXBjP4CnAQ1@B9wUYFVh-FOH{7l52*apEwT$1D#4?YUj0kcVs)
z7!*LKlk+@2r~X?kJ(c{4I^NypbJiW2L(RFsFM`a}Z!Yr&^be%Ce~YL<T9Yql+;)2<
zhk@s{nV*!{hW1+L4zn*0C@v=}hlJhp1}nu3cAdZVlc}1R`P^5WhWIv~d^2`>0cpTC
zyzP68{!D52uyo@X<8OeijUhY6Q@K;0Ucn-o-s{G0&oR?cpndf{lYVKl*Ahhdx9}wX
z9(VYRCf%;f4G5^&cX(-YW&X4XI#={_=S(}!Yplz$a8QXy8S24QpB%55eoCALw5pWU
zMYDYPEx1y3kKGsYN7B8QJzWnBMm!*2;vpP^n8{r`&}3n{*7DB2Ir2cd?yu}T|L!&d
z*hrb(lAkPcOShkd1Z|Gki%DQ-dQJxb0%l{GI)c^m@~~KL>KNmSFMOFY-ZI?QTeK$|
z=m<<CjvWZR_UvM?NCetG6#9r)lH#)fjSDJ*hRMT?l()f6@xvc501aN&_CL{5w|SV@
zKi-VdZiP~Xp`O}}-q6wkHaBd)^TLx_=WnW_{2NwzZm}w+L0W5*q`TWDKcA`}a3q5V
zWwTKF5O9{(QwHQv^bNO-K9kl*<LoR{R4k2J4=4xoj2$4bmyj6xz2mCWnbEOl$2hum
zCkE*9?jBEYIlTpNs%IM{=*mc;r;B8EhtBq3wUio|cp1OS%-77>Ntq*4mJ3WY_M!>S
zD#@rSDCUU|@>580E8ekQ@^m_4nTzjyG=jY<+kKr7;if2UP0(7e6b+4^O@s~F!1SM8
zLh(CGT{gQH&qw39-@ob}nVJAWhd1a4!J_iD=Z0tbTRG=!dx1mBP|r`8E%q<{`z|-p
z^=*$84!4NX8tNH6&hr^@LV~-CegsMDT~$?qi4d1nkFq;bh5TZzwB;PbGIr~2K0Jz}
z+v%TZAx^hj#I8z3f~6PQmk?Q~tZ8o~uJHAr0!8a<Si8LUupB&^1BU7!li7rL5~TN2
zR#Mh{uP>4dzxZf(kIe81qam}2-~>IuBqO#pP(yf%-rS6;|L&FjX&Op`tLGj@?Bn~X
zq08VzcFL4mvkqXFV{Xo*&#bh`F07BcWYhw2+zj(|nt$}4pxwd_IVtO^dLY#E?ppW<
zUZq>0L52g>32uA;((7paQi3`sgZ-cNaUq0@jwR7AvwFuyXgB;FT~dsVt4op2KDNaR
zkg%n1VRKkzK&1Qeey)z>Fe}P1-?d40Ts@HpGbouLT&SV7zny84MjN-bSU_X%RU^j4
zI_^%vy9*ahS&Ru*=4YjLP(LXe%@lJ3u|8;<8Aaca<h?RGpWxep$=npBP+sA^(d(YP
zYXlm%6?PDE3ya|OIc!YHniuZ2VE1rnUit{F5DX-53uk2+EgXjJO@|!?K{%CtK3!id
z8EHMU3*TXUB@KUYbXN*?1dhL&-t**XVH``o2XdZE4ZXASZ0$(xmfqQwUtMg;EZH_w
z_z7P<Y**EfMLh9UWv3EsCFP-@wSQ~!6G}E%ZTQuzq5IFMhC!TtiKEWrmRqZ$_h)Vk
zm+jM>)i(9!@j}O`L6f#$gmGLp(L^wD%-fBJ!7)F~HSd#zujjf3c0=k&m!U7i)NhAu
z-tVw&@y7C5m>n<N1t7<0as9vt3G>mb%kTF4b7ircM$ayD+4XD(Bw?T|U|PY3-s9C*
z<kB68N)?&dDV)KZ2H0t~cw=(g%-7QCVSRgMEKZ6_82KV&Lq@-qfH)1aP3S^zi|(*w
zU}7AXRyjX`F^9q2Cpfzv`o|Pa8vbSwAmuPPl_E7SHqy_3xy-5k!8gu%crP9vN0qfF
zqyzPwJs~qlzSg4}6IZ?TbDyykMYj4=nqhlB-;1fQ<JQ;5gmw=uRJ?FmKz0!<;`ZmV
z+Udu9)1yCtfek$=dU1&kmUW=eArb>Oji!*~+x0?pa|0xlIU)N|ffx(g&dcOks9+yZ
zNyanM%wMA9Wv?{JMm!eDBpPF5)z@^eO$2zStZh(a-S>RNB>r++^I#-}@2y5?p1UH|
z+%|S8?FS7WnP^gRxp)H!ZIYSlpQAt1K}D$S(U%XJZgJ-f8Qh(3ng{6oP%&2a{T{=j
z{HG6%w{ocGp!a~Adb44W!7-gqM)Qk19zXP+J8+RMp;8S@bTuf8+J_L@hX#FBupBct
ztp1cmFjFRBgSn5#K$Tt=Uryu$^z#8Lz@|3oV)51nI^@hs2AN1;L-k*f`H31i*96We
zLUBu=zpS1_byT2cDIS9_iXjc`Mhl;gtxZ1AGflq}30`>FoIDV0v?WT7>ZPj`hmi`d
z+Y`do>4Og%&Zi?cM~tv}Iq~k#4S(YbvV)0wcH7nLq|#Vb<C`IWaF$x27xoVed326>
z-cU%woY0MWQSl5YEnC(Lpl0s;!?9w@6_a>T5}ZSfM=w8|zdz#2)pIwfaELCjPdFgy
zzmIM%<3UTE)uEl1=a;L(pjlcF8+I)Caj~dOtzE9a*Oke#s;uj~%KJE<jehxL9YJQ_
zZ>#-8ZG<@X31)94O{w>66;iEzC4t_|*D-qjV1}!uyy2vr$FrkTx_Nky$DcgWD-Ld-
z!&lNGn{#bz)!;QSC<>88j$o$F$C%}cJ`~w`M@Hu#s+zL@SyuTM#o|7Ar48w%Jm+m7
zr22ZJEJWqa#^1K4Xq5V`H*y()hu+UAt*KyE@PS9i`X!}|TL{BQsc&|#pi+s`s*4G3
zb~Rv`z_Yp`L1`4KA`(w;-DYeO#chz8yECk#)vu5xiuDDDy0p!s^E03hA`Xhg=S&>n
z;K%HO;u4%QI%oZGVmSz3jy5>>GANHrVN2Mz)O8!)5QdJQOFb#`X$=-KwyQ3xP8J^g
z5*$yk1(ekWhwk(3u3XM2yZJ9!DBT!~!ev~*b2RyMelxowc3W#;(Py059;4^@zcA8M
z#+8pz3$D)89j>57lMMMc>V4C^#ndqr^gfhGTw<S}9#Wz0zMFM1yih;4zVGJ38Hiqs
zRx>3MV=z0eIDT&Z;wh8$00$N>Wg(V6B+j`_K=ez9Li78FH+b4A%nALB41TIjb`gx6
zX6W^JVfcx6fpwafSowH`D^_Afgr)dVmR-$>g!Q=f?!*u343hnMjdemE??k=ykLUE%
zA*4JvcEY#3{L7i=Zeb2stNxj*IrBG7=b-0Xpl!MX)dY>U+jyv%aX4>OE!8ayw91;q
zO-hUc3BsTEoz?u>#R69cl_(xH0F$#(w_wi4uL-M+3vd#A`6nVZ<Yx=Tw@~)()P~xe
zH?u=eRR`x5o06zgl|3eZ*FfdVU81Cg&<}h)R|V#7Fc*z0Zj7(}3&?uiLj0m`LhT>;
zhPuIscAvNQ<EDiM^;!A)=_xq@XVZO<*T`{dO*8`q9r?Wz(&a|Vc{d2jq-obP*5@=d
z)H8p~dI3E<TWohzmRHa52SB{1&3T#B3G%Fm;k6C7>a(_$0Nq*JmMf`J{DhxB3U&%g
z<}M0FB!!Uzwuq4{rdtqlcpqxVQhes(b{C}F7k<z^GsJVLWKLyPFi;@^K0WpH$Kz=;
zzMg5mE6YJn{g0SeX;BrZ(ZX0E9Wj(mEr&<@Ywwz`x?TQ`hlUO3qGP_Y@oGOSs01fS
zYL_wA_B-cKOSX`;{&X0NVcx4wcM~k!R=wM18K4{zo!Qn+P%mo0p_j4QUrc-Vtj8Y-
zR#1W9lp)!120JAZb1%^)K4^WHTZ$T)FO%qyKvvV$M7SAFrrkTf(9DmD=$Z+-_S^<V
zuTmNr6m`>2+-_m)k9NE*QhHBgYTvI2-hyr2Hx8;El$)r4ITaYAndgMY^KE;S=Mhed
zH@zKE{uGEZez+Qiz=+?U_C%`3it}fKx?uR}dYfo9_AfG=h$p(y`RmIhkE_G{S%EXX
zs>SUBs>}J^zXLxpTnNEnvap-hfN``gAL#6UIWxp2B_xt%aUc=S-CYd!8#0!5w*?=^
zov-#uIl|i<QZn|D2H?T``j&qrewA{eAMR!!{2<44X`tzQS2gB*BK09z&qU1aBjBW9
zH?6>BHK|EgJUXCD#61409H=C62qUgEC~j?cFj*uwV#{iMH|6AVr7y~mqXQ@Sjyt;M
zfjD4VAr1}c2>nTQZtJp&vv6bRW_NZj3NH5Te2@G}V{0H_<9Ro>Ig-jwJ#zeu1eJ*T
zR>G8baVEMnUhB8&e!-I717z_gLPZc33xhbw<B&(<5WUeEm^U<Z_NUIHlYNcu?ANIC
znB(;pI}Oysdw#s<K*|XhYNvBFVKz-WL9Y%4Iv=T)|HIN%_%;1~?~j3iv`BY@q%<Q2
z(k&njL!?_`z-XnUr8}gN5~Nc?Ho9AKqd^!QgZ<|B_4@<%dfoT#z2`jVdCqw*GtklR
zQS0t=32Pd*RRzM@A$1tXBM%w@NGASgqQuBkF8W4J6#TdmQxe5!1><&|rEB+)<=^1o
z`(tAofjBn5#B|NFEnbgzi$2u7faj-8Ue|e_42is5fjw9Y@H`vAt!1n-l|FowpkUUr
z6P36}KOzCZy*OA2c>U;-VP`P;_sQ}o6=5FbC*K_Q1|!gGVbE*xd)nFIN3TprwAshH
z)FyFmSp5ax@SUY4`)H4I*Ix(FW_|@I&?!hOLAJn*(<6S!3Xu8g0{eM*(Tr3fpM0R;
zN=6=VgTzMrv&2%@Ih>O4v}92woG-h?We^nY@gV`iYLnPTnkxytn_|SSq;bgK4FAwe
zp^(O!&%I0t>kwivJlzv=-%3s&H_DYu@T7q{&70FR!?$CPHEAzk7JZMPIo6msiq1+1
zK7JXQ2bgAMXx}aZNtIU%WAu$C_JF799d``wHyo?W`4hNn2`HrruP>)B8omBQ&}A_v
zw2kQuF(*VynTvYF<tDFvjts3KQnN5qPbb4PitydcjD2d$+iRpYkGxq@{k)44;)>rO
zLy~|?AmXOsJwrTq7n)KjPCsVccpoOHH{tlCpp8AftGH=vg2nwL_c%247&C5Nkz(mW
z+?D)sbq!5bBY~!+K~vXKV{oVxT%rP+f&|vOSVL^Z{~Dr4=E7*mpKXU}%L-_;k3S5d
zlBZKtb2a_?@V7SG_k$i(fBaS-RTjKeqF>Z}6;UZbn9M#tG}0lssM@n3MkOa#J|`pF
zPUuMUMoft@z^OrGk(B`_h%&L+){M-izP7hXU~a(bKJe)sows!}=w`kB&vFh@<gsTz
z%fA3L|6>Rq{JeqRDE~S#*zPRc((?VV4*PoPPvu5aLbg!9eOBf(h#)D{hK0I%14*6V
zZ=RXpa-(3cyDH4PZFBQXCYknQFF(7E45RTDzpu<Qi$;U@;IC4SHp28e<gd~%uVvHp
z!9@sF=n_F3ix=&9Q4`RMzi7%(kj8K-<(_FsZ(2v$Bl;0}plk`p?bgYc?5#Kl&aHOW
zo!>2oz|~k!JFN}HGPL=XjcMOLa|gEPh*c0!^0nxL3(CnT6gh4mJJ^Ph6biLG?q%K}
zC1IBDp*r#R?lE+|yUPy9pWi0<uIcveit6^%;l(iImL&njly7OuIX}IBHi4S*C74(7
z3fX}}d__1#(jOyKpUFv<rg~V*G|;~$lb6n2A3TWIELR}BQR!qIvi`t6POj^RdaIni
z=AS}Rp!<O}s-wK3l)xm}H++b$!s%s3zwvQ@`P{j7Bl}${|Lqs`i?fQ46~phErrav3
zcvBL&9e@=G&RbWbQjh*8^p=S=`brBu>?1z&qpkt}%LV-K`~%(6E9K_vv-vSs_U1lJ
zRgys}gUyHT_y34&2QAYzkAy~K1P@L3K^(+x5{0$-4{hGwq!mKzq~4wm*8eeT+#{b)
zFM!s3;WT9VnPY2G$(}c)Jm=5l!hd!-c0G;(yU{q>%wq?%$e6mRAILR!D|oOLh_$aG
z7!1Jhte+${JU5ekx}Qm+&pHLHPjEdP*kzSQ=cxS@+(>?S1=cDCruW&Y8G8;GQuI7R
z|HTXLHsuC|#-Tf-Mx`G-SF5lvPCGGAO-W@qTu(_8xYs%^8P5v1<=OKPmAQ9IH!u-R
z!Z=Vg(Qhm0aGjH$^&qs1Jwb^B$=2Ohqz^R6OPxObHdD=`SD}6Lf+t;j3u^u1mba#;
zgHQ*QnoH|nLg*1#v4pLb1&MjBn4iUG3XOaC&Cp|K7js5_q`s^$#C8i_m^wM^Mu7v+
z=jofb!_K4EYAhYJ{;1>!;GyTQc$uC7U|I6%(l!5n=qv;JwfbS`MlNPzIPtyK^^1?w
z$}%PB!qS|O-5e$kRe<VXy3Qs5c;gXc)_kPe7Ak|=w$#5LZppZ{pe|}XRqS+SP4_|K
zW=fOixDk+C&%>aJ7Z9%V;j}O(tn+Kd`Ub>&Oa0Bck<jYcUIf7#H{I?Or9y7n&j#IJ
zBP7gy3dbirPn>kTm3MtlF26?bPCkteQnWZvIvU$&i9@|lG0wi0QpzDk=`;y#ad^#P
zEHEs`u3s?*2yMXf19;y5i+un(bRx8C8Dkd3L+&gw^nwI5gZdluP~a;eEjw%9B03_H
zETXj|lww0yC*)j+C2`f4z=GhE*3CIh@`&B0s)(#aUPut#>=_GR3z&=NHJ89`X-F0s
z9q{N||I=;PZBtw>&?S#{b&@h|NRcWE98E<TW$#*FoXVO5g(az;)H7&IWh$9E+{yp-
zaHD;IC;SSEWWenkV&v&-zh0?rM2<hl(E0#s^s<}#!Qa8So*$eGSL3!JmafhcyAywF
z?)KesbjJG&fwy2~X3BfbdzDN87r1w<hfbM&CrXO8EHyszG#-m}LDgM4oi1K_ADrvx
zoFZ)SZo14<zMk9RZIR%r7n~8GeePgfJ!)^vrJ%VcJetn@{>>`HFLy}t^)%o6HhAfb
z+<2rdL)$j$c>OeUnsQF~Scs;~(m31_vf%wwkK|?d-C-?wNA%$}M#>LP5TQnIlu8C5
zhB0JW25A?*b1qd0jn8p!-f@s#?%`~p{cG{n!zKn|As#fFjk@3GGTWO5;<kW>GOYrW
zTmi!BKPjj~<erN8K|i%rdFlmoF5=8pX6bk1x47BMbirAN*oepG+~^blC%CM;KGxH(
z+nX$*+yLahFy%ffQF&?~DHSRd^xIA*dS&f_x@iQzK>|K3|3x^$1uqm-`2*<&59W_U
zKZ%zl!Cu)=w!{=f&YIVPB;K~->lvh0Ef5v(79=vLcb#8wa3=vqsuL|EnP{kyhm@-M
zX>}qfoN}f=Kl(M`&}_RB<#@0@n~lTT_Qzh8Iy5M!^2`vdP~%@>mUW)!P<)p4>770I
zO#l;+?2VA^b4|laIAdA*_~$a%A@>e(AUT`#oLf}v_gdL&g~0kCj%7A_|J>DGYQEpU
zlAYSeZeNWB-sF!zJQPZb^3W**Pq`3VUNmSE85*>|9qQPL-<FyjACsf8i0L80J6ORX
zG*^e8EgwJ2Hj&QPwdE~P`Z*UZHrLgajbmy{g8cY|ZZ4i?TiN%q?-(As;I4f9&krQ<
zlbAD#|B<CeBoNa*in+eenH1)`u1@Vj#&X>0Q@d%;Mw_ZT^_K6x+sfQ0Rt`NckhAFu
zv;gy^Xz?m%PjyIqLT!n^oL@S6hb9Ek)f?Qm8iKVUv4I49^ChdvCKi*G^L0?Qn>R-?
z7RSn`l8|AnSzJaj4f*EoYfbtSPw|BuWGl&MqP1*kWBb4n=s<Asdw9NuMJ_V<&?<-s
zd*zbvpBU6cYZLzC9$`BE_g66AxHz&RJ0ZD7SOh6XQ*xe>h$=l-!88fpt1D?v?AGo$
z-RlAKpB8q6RzX@dwzF%JJt_!eE%MhU0sh8zpaYHZi#BF2K^NU)PGCa-GRbO3hC6ET
zNU<v~$Erh0jn2J`(`!A`S!S;X+BV_GzJfEG1Z|SpQ=ZAZY`*4h!t*RPD<ob1va7Z~
zI@t7|j^tMEZFyBBOB;Mk>ep!~>~CsYorNyHsMd3c%8D%1%Jphp7IadYzEQP<Vh=jW
zOz0J$vkbhiO9*`BjOxSOYbx}eYxDRl4LKe;u7zdJ)zS|9du>1|Fp*zg?MGmyY%jJ}
zN&>~#vuTTd4`PQdg!<LQ)D%~Oi442EH7Icz;%fZ7Rgo^@!|%p-(reWW7b&#^?O(%t
zkvD7HZL>A1ekSG~EJ=O^9vWbAvzdLSgYUgtm;8J>_kN&fpdFp*@Bjr17v&}FU#}5y
zN5=c6TteYM>2w>%ozHFy<~_{tGs_+5T1?F91%L)E`amXwX}Q+Ej|u)Ivphl~#zQ!Q
zS@XFQ8=83D-1~LD?-LlxtUy3ERnRLhQhaWxC~;iu)ahK9>Q9ahS3}!`lkOY@Vh{Mf
zSJ$q@?mPdr(cp?YpWH;4la4DCp>sg0w`4enTYgnx(pC5HH5Rbn7TQZ=KVL0M7~)`s
z>vyvr8_8jcA$O=hlXjiKkKs}O@CyfZCGg>Du`O^rtovV|CdN-hU)Hxj@DeZYS@+Jq
zQb<n;rz~OYIn}fj*%{BH-)0n{^kLozs+$SOi+*~`D1Oe?PnpWOTHDefL#0~cde8uO
zavT1HgU!2cz9IFg@1pWDI*dnnx)y$8hiaUkXDka8KbvT>+z4zq4pik8Pwxg%yNKar
zgj)MCs3aU>F{qgiL-nPkycrHiIiV3}Ix=}~>J(H&{2y2GB1F6H>g|5y+Wilv3?mtu
z#yb|1(NF)adM>Q?aj(f>_5-5mZt&As`7Q^Ogu}(b`m@MCgBSkAQi0B5BO&qbV|LDT
z00?4_ZG1yKo$0{tXGmrjoR(|eOEQr*ptt)md*55=!?PZ;8EKK6P}e;_`J;^Ge0yBZ
ze9n6H?$tBz0!T(pZ>w%IPf;0JI58cg3!<WqKB%I{<Fl_>QI=~~N)y)}03rQ#xT}8{
z&>Ok!zD_5+uW;F4?&P=!PUvAd&;xxTG@%vhzh6g0wh2BjWMC_M+B<kc=vDr?!Ns?b
zY%VtVZqah|8v4E*ehrmwM8Bzs3w}A`g0gCaqUWsK2tzF=-zT2v_bVO;(DB`k2eWWN
z-e@FdjL~qG`sY~`eu;*u&fuBk(U1Y-G&{t*Sk$~6Xnl)Im}yL*J2+Up3M@kv7d42o
z9Yu2|fZ<S~KEs=sKZm<pjxKEbIa+(ShBG(pN-25XE8I82i{Twr3620a<e=~#-Ume?
z|LP+rztO-D<+tHHT9ko{Zc5AVE~7q%2EHV`N%Y_ND!EqaBTj(tKZYjkx;wQyUv6B&
zP&C@s=10ij5q_z~v;-=0jLA@~;25N58qg>FT&$%{Cf|xnlVztL65Uq9A8aiC<0eSl
z_~`rm;jG7A)rXt#Bhum7Nu1tkKF<MgSmVZ8@ccnt4Mw&!nZu$+i}{~2_^9h*Ame9=
zjmp@d!0YLD3en+mr~+n1lmxsl>UE6>@FwcDmPFoX;qw|Bsz;vfMk>Xb1X|G_bp8SG
zH;<1L&Ff#LWOvksx$85F!+TEF5RZUPW8yuS|M&ioYyB>TTl8VLL-fJ$G4Q-2IHKo=
zJ;ru~;K#wT#cv<bgGSoG<)mT|Ee*rsq~{MO5qQeprMBR`z?wv2UvgP&=H&unp-csy
zaVGhOWpIHlkwQE29A)G&(z1=C-<_i*WTeaOv8Rz@ww(kR1;brfE=Iw`doKgZ)%150
zoW6N{YgIG;397h!hCRIpVJWIITx2LOM#?jr!E?kkpS=C{NKrR0(w=cpdzV19>uY{9
z*KF!o9AX&HiTkt>F}la}DhTl;7?X+4+ZA#}{Ga=-jHx@LF!|fU(RvS#4zY5JPY&LZ
zz@!KQ%(js5-TX3jM`Evvig$k~q%)E2($MBheC$R3;^S6D4$MjY!{WOgZecvjrz}T?
zgJb)JoUHs*7lToDcY}^|QG?1EoM+Ox{ohvn?H~TDaC(tj{MuU=8kW{}u1jlpfM-sx
za@&w#@4`(g+&L%p$RO`Z5hSLF*5%0XC5YxR3C3XVk>RC;3-v<0sHKdr5VMa1#}b|c
z!9kdQfv4G2NUn8)cJIZ1l;3wax?uSa6%_c_2ZKDQoqbY7dNplH>gk%VH!PX=>}W5+
z;?SL(2Gajj4@XEc&8#Fu<&uE6Tg?gy6Dj=1cUeUnEXS~M_Xpygl|LHn-l9LJa4n`t
zzzqA;33QAptox(8)-v%!k`s1-m#Az9;&yf%mg8`ZQ}X#_r>Kw#o$r!ca?8d}XWum3
z?r5hq9ZhS~zbU04d7e@PG(H^k-1>gc9(KsP)SDb%5QzgSNdNbHuyDWv_9*3eez1wr
z%Q!#TrdSIbwf>U<+MIW9Dvs6+PB`Fef0|8ZSuvKl!QCtR&<evGxB!$JQPb>uBUuap
zj1YJAE~BT{zw(UC=~Pt$OeU%(1q$YA{psrc>U{T`1@}Wl2`P^VVgH792hA9^m{Or@
zl&Gpt7MKYY-dN=6|2>_;A(}5^6$jEN^LDI)B)!2AiY3Im$YktLIxfdCGvOfUSX@C^
z%#;q*L5F@i*WEVBSBNWP@%kqD{2ejJ66oL=j~iPY=q&Z}*?ACma5(8sg_%kIPB_Mc
z3CM7eixhJO*`a>;%TO+BKUmVB9qa!`qnjp3lVGBAZ_bHGf7f!;IDO{5Ru)Weh8fTy
zth;`?<O%>@dFEP?TI`V`7Du20IJp^ch{uF^+iMl6-8RZs2|4zp37o92tMXtpE^(q%
zP><h@Ny<TQ*3UGR{_IFd_ii;v&&Cub%T&k6*G0N+V%b{PcbWed1&n#x%a4a|_<^JU
zQhmYvdfe-<^>s0mMH)T79X8|f1@{u)T)4pu9-V(JYAEPQUF!R>{H3vE@2`Z^6)|Nt
z7|oJ-7T4jb%4w2lQ@kKvyI6BMHqLOe)Jua{q78QK8RS2$G>~xro5L!<TC&ZG2HjeP
z`CuA!lX8otj-^xY)nmT9>+X#^Ov}VyBmFKKzOYtUS!=9Dth#Km>R`J^7f01WM;3+R
z+%C3=FCWFL(NC7@Gk>XPV+vTnI<s*q1!a2srto2F`-#jV2_>dwCs5F&@LiopUEsj=
zC>PEwsbrq4(q*K9#G=wKUm67nVdt=PB!#%xcos7Er^NB+#T+|$uvridy7A3zV>NUY
zp9B5(C+4;=^StPy_;`Ita>OJgud%TkHQp@|{o_y6Tq?r!X(Kc^>DN==V}VRNE(Nwl
zTzWP7@t}9UnLU-P-@C20zSj?KR-cmYj?DAZmclk^TA^M`=7zTkKF<^Fzvv`Rh_M<x
zwX7@%5ONwHMwWvsd7bvmbIna_-{mm`Tmq4!b{G-fEda|q@Xl!gA7@y%_aA{mCV|1v
zPN-wIb`mObjK}aX+n@6?dTD2yIiN>&Fmqh+k_cP%#g}B-GVOWohBQK}u}Jd5ETvWx
z?{}hQwDaew8!-Vjaz2hrGq-aE(}nrT-lY2mWs7Y!RiwElYgtx^7FTJrI)xrQnX@<o
zO+aK8edqjLM)vwUp@w7oZ^#am5Cc?#-(R##=x!N*?7FV|n)R^V1={~d^ue^j8D+Pi
zo*AKtaX9wJwG6x-%||J(xDjzYFiv5-IW$I3>>ZHf@?wB$ffr@)gV(W>^;;rb*=dIR
z<+dlZxZqY?5BmT%&FUJH2Wo<9g13nT&+pAB+AIW&-2uIZMO+ZQ8yj>vGVw<EEu06u
zpCYU|V8BqDkf{r-zTDf|i0?59#wxu~g{%s-`fZ0`+o5s@{>C2rENI$lKVo?L4^Ou8
z3}en5{huGOA0iw6ROx|-_buz@_qQkK_VH4M2c-&0d^^{hfKN0JmRl+i1KW)0915GS
z)6yHz>xmnE7-3R=wAQeo5d7z#uUohb?8=IKjx4l|gPaFrnzT?UFG&*ubB9xMr#HFw
zuc}v`26G^ImkcJ#Zj7jgh!n<*_)naY^39S7P9C6BCiS!Xy!Jmkh`qu(L>|2Ge+xPv
z3iOsIFvuk{O@W7epQXDEj~Gku%K?|G>DKI9m;(BD+#Yb|3Hi(afrRcq$lyvllr*j_
zhP=m$2|Ko-4XVZ7_(Dua&7LmKP&a5wxu0_wO))*)c-_>Q0V}UlA^ko~B;2{}i?392
z$42U~#ME147IWa~=W_NbV_uOS7QvWy5vE^AagZBkKugUmnaVYnzI9bH5{rIYDx@%?
zMtq|>+X0X9YDgtG-7XW45ExO7pW0Px#oL)o_tKL=0F+h$-zauGIyt46{we~!a)?A0
z>T)xiw_dh}ALeng4ACu*a<!f5car9<%d=d_L2t<3!<7-F_sYrPs~NgXz1j<MTOGj=
ztgf4?wWG8uXV#~7dob(=XFxNO|G5(cQ>f9sXzfcE9DO9lBZw&kuyK?s{99SWMQ)=8
z6OHGS&vE$s9wPwR!yUadp%B45%0dNodgU_HM(+lmmZDKxe?$zHblHS=te4NBbnTO8
z@bcN8;YJ*n*e@*&fV9`quR5hJ*TvZ5?>{mZj|~d6nQ;))CEgA^{5ltz`DRpR;ZVa9
zW2MD-fc+(6nk44%8PxF9Jw#w8MQKR>&ZL;@U>nO^O>dv9*O#OA6XHt3e=>NpF(pU(
z@SXCacW7VlE!ZU|5!rYC6~PYw6#MgJ@ak;sS}lhv2Z>%3AG`hr^ca8Wv-w|}1_TZ~
zjQt?+|6l2I%JHyPX0=w`M|Uq^bwMhDqz8z5XmM~j{)*B`-w`y=Rxu7rx0~pPQV>1~
z^=i?F@3w?8(@}HS=vnLM3Rudr@Umx*@6AxYv}FB|(+LNAiVTyVy?Bzf8{MS7A^jEA
z&t$0-ZK9Z@?f2gb0ok6=yY8gO$O5?~@?!ig?eljhs=|#As=lhw$o=>W;~`U6%92hB
z_AHlgZs)oj^uJ^p)xTW?DtBkY#U0$kLS3>{+bpMVb}1n!pG2fs*9UnCcn?YQKMJH3
z9vs<;@y+|VkaYqMd;fmif13MKqkW=4I%Lb&F|+QR>%8pLTva7+xcbgxcR=b4_MgVQ
zF)!L<UvO?tZ>r49!f`F5?2qn2<2#Lt<EMF+!N?-|b0NHLThu}DDQ4ixiDK@h=!4kI
zb@y+*e22-8eQ&J(35pTmPu0+s4u5xtd7rMh)Hg0NygT9?HRJ6rA98m(wi+aYMYeBz
z>B^TW+Y-*D8f@qaCMp(xa*m_?yhgdzFFEKEzBk?u%y{pQaZmPhbv;Y9)LqGOvS5em
zT-A-z4o-eItx48fXlEwQ8zM-Yt2iRv{=(gbYIW`O^^GRqj#KQ9n>UZF?7qM7a>ej}
z!5z<H6VQRSf#{5Uzkg#$5xmOAcH;Y=fbvadL&+(Xv<W?iV}aqIuGPGHQ^D)RfW|<V
zinHSdKb^8EM0`eZg`{RYX6`Pqt?&dX>oUHZ7I6(Q3;}+evL1G5h_mnPKLGu{5%wvv
z{VpOCn5F*sMy|#ofU`Vaubqo%!#8_oPmd~qjbS=r9QExSn4o(lGuyml2!{{4w-$g4
zb}A&tmw{%(w;K%(E(rGpOT-^6kWf&6Cw>2z3r2Xzw?mme{qutaL)`%6n}e_6!IjtL
z;T+o$H1yF+kUSKpqSm;)&)ah=i#Q+I#O!GmRELre4DNJpUbq)Ea&bRIcXwg^V!Vb(
z<bC|)ApvK9qb~c(wMrkSl~j#tveR!|bHBf+$*Po^ves6sqANU{D}z(_&qO<>P0gIx
zqZ?idq6N0FGcv=J=^Oic6(7?%C~i<qulB(KILd+WRXVBQ{H?AN%FYf|(XxB*roD`=
z_6cjPv6yy(TNF9KyPwkiFZ};+`3lY3p5!Ev<elm=VZ)N#Fp8js7|GVyvh&Sh+d&5R
zUSO1$BXm>jXiw=zPhQp@|1<$Ke;HMj+)d%2C~cP6Eub6U5fF*5L|VeL8g=l_RwusE
z+<`H(qxam8^CHCFO$9{kM~dRI$ZDL(?2Wu&(%mWSZY`7v*TR!-(WL-6aWf_O*jR+<
zoj(iT{>pAaOoKqu$92gbXvAk*C7s!P^0a_6Eq{e6*<<hA6%utk+37f!z=Oy7Olr`e
ze;~DoAL|XE<Msa0$TFB{SSG#+B07Ay4wDeavj%Z<c)0WJIA%fjI%Wl3RZhy~r;0id
ziiU9IedVUU@23~K119u_LtA82#i2VBH9vXy6S#l_@)K$E4MV<}*wL2qT(ySQv)2Oc
z2QPzaiaC7p-UofwyEQFB1CY@3;~~JLAXd(p{IH(58CX|Q-be7=t-6bbLH~MjF7sUj
za!mq$e4LBKTSZ2Ik1(b-e{Dq{9?_uHDbY=|zkiVYz={CJ{CM)l_tC*pZaSf)$ZWOT
zYrAkOWrl-G!zmMW3k1DZq*uL&L1}WrU8BE@B-7F*$g9bAnYM6)@*+TT-+{aCoT&D!
zAeq&IlX^={D|V+_zoiPU;#qD1%2(Up{4&e)op#IZL^c5Dubi5I`Oj#ju0&j+wl0&h
zlu043h|*J=#hJAFoaq~w@Knu6!udMIl!1*3^nRm&NZDH9@Ns;z4>QLtbLudGlL<C`
zUL)NL3*y@<`p~XZapqGzI&mDZ!jeq0XQAc*eznh_n~HJoHPP7s8^fLKmCu6tv4nry
z<@7@EWr~ZmCAu&Er8(?hp9~V&eX&4#$RZs<@F*s%)+$VOySPlMdKoCC`KNDW`@=hD
z92!KcAWfyXB>_htYg(M_>qHJH4Fa%6G)E-mVd6a_cUm_{gYf+-(S3+exfQs%9pTtQ
z%8YM^>M2^}#DMK0rtI>ZSBjFMTCnUmKi1TXFlU7?Mf3O9RYVL2FK+6y8JL6Bu;)n=
zu@uO+?O$|)!L0X8TlzT^bJ!UVt@JsbB|?4sB`~HN*~Cw)KVD<co$)9T9-loxZ)CK0
zg@?v(H-6MmF#aWc7D-SMu$OS+o}wLw;;QwP^Mt8q$L~eWk-cx*2G9)j2}03h+QGDI
zzH`SLe}W-ffY{h&3~T|eU9SbjFknUw{&xeR4=cAP`ARvk0I%3~(kvnBgpGx$v)+jl
z4~MCXtd}*qd<_1zTciWU*$#;ZavZKE{P^?5J(KpOeh%QF25HSQK;c7b;dt@YIgu~q
zjW)ovtHh1NhRPlXJ2`D9e}sI#lertyK33Mq_UnmTaqVE6E)^FY|Mk1O5ZeyAJ))YA
z8ov1vS`?{HuK5A9dyj1Hjf}s$Z6)kZDBcoI9PnDdIuH96oYW<I7YE-;mwfPf80R>N
zvwLQT(r?*R&+l6uAn=a}>~%ps!N?F`6oWm#4Yeo^M$&n_&VCidc$tGXKSYgi_@1*V
z3Qdi~^-jOtn863Jv(XDDzZoV7Pc6qSf@1~O!oDd5yc;M97zJ>jBpGNS)FB1K(Mnlv
zCsSi=yuT@hAkTAOosdp*N^{;9=(~b^duj!C>$SCcP2q+`@;NV$IbMQW1rp^=yLvY!
z$b~N{Bx+Jm&zJt~0QzS9Z|&MQMC8YlqrWrvH5VSKn@Yb1fZeWe3*O~Ub&M_3f0$yK
zQGB~B7}qfH;Go5O=Y(_7&M9?H?iHy~-du!8<X0!6vzp&Q0tyaA6}wfe3eQ8z<^<^s
zY#ldwKBj+i?HFjL;-3Fq>iaf{1vnH7CiN!sctt^|-T@)5$MzFrUoxwV{k(JfB!pkw
zcCn3GvV1K0%%t)H*x7lSLzGDL#)r{xpvtZky3BaAl`VUhxqZDC@w0eOZ+YtM6V|a0
z;l!L=`?ZltwdrpzvYq=Zb3RE1me#V_ftQGD9dN;36lhpj3Ot}k?vX1I&Mov%yVgl#
z7;tm8(#~OtV(|6&2-7~GJ$0!(+zqpNoj&UN^uK>)z-tJ~O>#R7eC3L9=XtkacR+#T
zKX%7A7Vwb&CjWga3(0f~3(4@z(6q4fh`9t4loq^{MOrir8`cdHv5Ow&&<kt?P06`O
zFP?<Um7J<5^G-*s8;faVO{Z7bvs?H_sq5Bm)k*|g`K32_#hyJXzAN5&v_D`Ds=l(@
zb9U@#43a;4WRuHzTpv6qP%5F;M|M#em)}T@Hf`g)scz$hEJS@^%ROBW$-kKD&bbG@
zLeyj66N7ymx-SS3yb*@JSD?hF!8B{}Q}R9RVt?$BM6+?gBs4#?Xobq`2SmA3|9&m)
zHa@lW`fW3wa69`>3gnMSjl+kwjil0|G=e8fw~2?QT`2>eJPZ<KqS|gW;kI@4-)4cO
z*J4(ez8cC|X1o$1ZGZpkM01{2u2?lxt5z6vS5DEsT1;v;Nce1Uf2$UY{^4b_JVLeR
zK2!}TlTu*W0gt#XbmFB49Im+!I@7Bk^xzUbr$LjRTAszBNrRBM;)gXrjAYC5E3Jr!
zGQQ*LNjns37<_jiQ74K!U?tme0-ueNR(w;g$GE2xWX@#aPJjE9JX1|;_*dw*9jS}O
zoKO(q=*8ZcO;(oN`FoFgk$mLB)<GNTRtpE|e2-);f_Lk(FsRM_<xuHf{O+{Fh&Zs3
zpz|y5{vy|H;#kRySjS)Cmk~MV5|d%7EpL<qj|cD70hI_da<9U%|7s%-8J_SmKttSM
zCKEGDYAFsSgW#?{Md)oYWxu}38^R<XwgEJTPy?%P_F6d42R6I(Jw&b)d&2tGWK5gE
z3^YY8?%TeRHeQCo2Q&+T4_9Hbm=vAljGCt2g9k&onuMY);lG$S@V@-j`MY*M`$NXe
z#Q3o?KGvxGv~)HkeB-nP$vrd{1$**_&sHkz5Ao^5S=WDFP7_ITGq~mR=E>EZ2T+KP
zO!>q?CzI~HT)B?9WNxW5Tm?9&(UD>zUDg2Z!L|w12Vewo1*OGjvh6^Mdf6S3rM1r+
z{2fUf@5C)DP;a${1QbQ9^M^b3jVKWXHmv3}Xfi4cpRjqohW^2FA|HH;vCg5v!W=Bl
zH^Tc>=`v#DZkx9$O1U5E7if2fdqFuqKtg8OJc0lc*>784@1O5YtF*%9HpUBd(tSs5
zEYz}G@lQ*MOhV?l@wPL9N>88}X0o%&MVC_q%&;bIU%VAjD)rT=wA=dX?FvI8$M+Bm
zmHFgkCEq8Uq0<e&l@R6U9E%i16I0El{G+pv<8lOyLigaY2~n`Jxw1@WLNoo<fo|d=
zV+$Iz-zP;%^ork!h2LY0i{s;EjsQ9L^~1zJBv%2lSwA|io#cWZ#ZxolT6{b1Tqiw~
z__);n9iXcPP?E8OKU;{hV3MzSxr0}LU!3^lI|u*nvk#z`n}RmIGfdg|(7guyj~#!_
zy!SfzFL)B#bLg?|KmXv7zb<wLIaEH&sYH0*$V)^u6{Qb)Da5)-ZJbk6ryprin?BRE
zS=PJviO4^nSEw`q5`TCX9Kr_#Kb8K*KiImVO<Z_Uj~u^wjHysIubWFaBjTQU_EJzn
z??=!BO>nJUZL?wg6DLp|h^r(!94>tL)<n!N?yb8#Xb;PGYeM3F&sNxeH8s2gQIbB3
zZ%wyZ`B7`XLU&|78AS<9TQt0>19&UF4S>m4)RIDV$pe4Can)wH=^xQThNwN}yfb8T
z+mZTmX{p7J<O?I6_`4<r{C<-fR0dnyIYjGat5q_<cc|xw>R57nWlVO%#DsJ)O@mS1
zYMA+m68>SHp=;ntiYdl0S_MPr_qcEJqm`PS<N~)3Hnmf|7@<8XyOx;bbdl-+k%OMS
zP3(=#`PukIYohiDoik}B_uF0_W3L&Z&1A@1UYRp*&A?6JgFknA=6Q^DZ&W)YQ{2f6
zzGxZcK1C*J^YeLROO{{oEp?V)Ti=rHG{Y!v{4L5d!}YbCZi=QkI|ml96T!MAMdC5P
zMGOI^<+I^aXJ*)-hEJsTuz}z-Oov4TEgHFHfeAJkaSls4BgOT$Apf!0hjU6tfQny;
z-HtH-FLoEU6+D@8T7R1tS6KHd<F6r(7t^&x>pOT|jet3?cXOHP@;`IzP7!`ei)#0e
zO3Z9J9RZ0bwIvZ2qe{aR|0->jrIOeYSNSG}FR1rB8Afi^o#1<i!0NEl<9fFPzY|9Z
z!*95|f_7B(KUwK4%{fFLL}V}{4IpY@P=^>a_&Ow|=f@<bihA}d@hV96s#i@clSqg{
zl0A|B7MA#+SfoYpncD3%Mbttvb4m)Yd@D*4iH-N?x2KE*DMShl4lC^-f0A7>RHae6
ztiCU}R!*uL$tgJ<g^imxbs9ZFzc2XAM4S4{#XBJ9!NjIK14p_RLAtUec8Ud)x?o{(
zHIq%!(W4%gri6K$#|puU+eN9LC|tJ5=x|$UUG#wG1XBhYKvhD+{ZQEBsbix%i1|Eq
zen9nM`hRZup9#YVoo-{nlL+eu7nJg1rk1_`@-=p`M!j?h8HQeai9z_5m=Ei52cE^O
z1a+1_6$@xkc$C+#5`jDZdj&57eJdrw+=H){#S;$xXnkxxH1F>k+lvK_`__;YucQp4
zR!PT4oE$YaH1;!gH;IZ-bA0&WXO$E_<p1mnD&1Pu(jb#j?NDr>Fa9Z>rq}Elo7r3x
z55l2sTxrA|i}~2)2-5D0v8vj^Vfe^mTy-`|4xG*3PN2xC!V@-*@CNIojpR3SMWnHV
zd0!zuxXJ$YeD`-D@&(bVoAfkGS@zadSfwB=XM#e(oU7uRh$flw9>xJN21)R#1gi*R
zh9YF1NYkK=u90q9EtV`8s-EEU4?dJ__xUhvj+chfwfM%GCeBb8C8M=DsR9mm?==Y8
z@+OsUn+DMrnraZUB+?QjLG`jGL*Mgzk#Hzd4_HeDaM6f#o&FXpOh%NdK!gQ$`k35o
zm|`hiNR{4ge{-R@IL_#TbhZ}hHV`@Nj3kH?M-jnd99f6BEI@EmYGRqZ-QHOO{$I-?
zdCH9wUn#34|C{Zx@nfmC{)|eeyq_@?Sz1j!h1M~HbEh1DjHoD3PbZTS)X8JoTiZ%^
zukVok*T3>4PUyi!y2Y}nw=1Ld6EQQE^6CN99jS~C)xLe%Pb^QlNzX@d)@xh<*(zq(
z(Q`EVM%ilphcPzsBYQ?&Nj+)n^Wj}_^Xi9ptG-o(6HhnbZ}+o?R3PtF>;&J;2g(uU
zbievp>gHF4AUm(rpSORLsP5#XWTnCp$fnrGdS=2fxeIAn2Dz;DJOVR!a|n`;Rner!
z=!a~}FItp$<@Dll9?Wd6O$B%S<519_<AP&8(}=#p(DOaSX(h$D!<ZL+`iR3+L<Q*e
zigqs`z)~n97I)+=>tAl%@3q7b@gI=2WG8)kq#yTZMPGl*02FaGl5hIG(z}Vb2U?kJ
ze{h2OTl}l5G!8I!dnqqGGR-Jn%EU5zOD6B)bqz!o&)$Tbkx0dKseQSwcpwR%3rcO8
z+4bWhj^o)b#5yXZa{$$*6nXfT5Kp>Ao5k?F(xyS{OG6oG(7%{t(ekc7)R-)V<Jl|5
z=z6K10F_y8+9~V9Ia_%DYhxx#xO7-mSXnBfzMru!K@LA5I`@ro<}{>@f*;64al%^I
ze|dgk-T7)rwcEdHb$!@b_Iu<3a7@sbjV|u`i%hELp*RhF*_oQnAlM=qiaaQ;;&4%>
z;{?s4jHD!3d$}GBUG5URuNXf!6c>J;FGm>tT`Rgfua-rftz$j%TS5ytoyDZI3vezi
zvy1dd4V-ddcq;o1I!F1@v9;Vvgsu=c5i~kb3#!@4y89j%Yz$nuzN!Nq_@K&;Eiq^T
ze>==gHmuPTDs{~fDWuGf5HL=TN~$ttEsf8;U~?pqfvPgmB%>%QrhmjrVW+2>U%>_<
zs|+=#&nY!I=S$2~I;5n^^eSp&ZYrQ}OL%cxhw3OCgx_pMxo+BQrm*JPdwsg?>S1hC
z5Fy%`hC!zqFTX+T$32;KVFbQusTT8)WQ($k&YXE7KlnYL<Wr5>c(wJ6LtzFVMRwT2
ziuK8*`~Ct6;2fk{8_Pw5CTPVJ0GPGA<w~so(*gczPhy-HIGO+-a?6ck2-rJ&%K?4_
z=($VmxCponJ4~(Lf(-jM4aJ$ur`F_;^wquW;;#p}w*533hQI1YEEFXwOXhpHJkOu2
zQ>p}w84knXTszM#EL0i3O-nvy?%shc-v@u!^2%g(Su1|6<j>QI;7Bn2U*jl$f`|!5
zj=;|IP{;g_WaPMOzglkirEAujz82zex2XZN&z2fZs3d->DZ|w1Ym&suws>33a<w)2
zEF>a4@D&Z1?KXVNwdl`xYOLxVJ7!N6C=Rn|c8d18mb`1Glyhp7g|A^&jei?tQZMI*
z9QUYQR2j$?MeI+V_Dou{;zR1`^zVzDxs{gVhF3PLOZzY}Ah;?L8T=K)(JuVLr1>XB
z%S|Ub2~SpLtFqy3Ym2Nqr$yJy(zHIFwF?{>pcv>%E8K}L64&7LaNamcswRQg;dIix
z$~AV`;?qe1%8F_ygNJU{#E1iN!8+=>s?t%Y1p`d?Ck$b{f4ZY<e2M`@05v~P8{>KY
z+}+y5#xbp3$;M3k?9CD`=$v0^)BAuHGvnH@T2j9!{rMA#!vW>1RKQmhFp<6Vms`K?
zm}bFd+PT(98~Vk3=D_?rz!yHbp^3(xsw&cYSqToOcnP|CcFO<EMf)5eg?NTdk=XzG
zV6HqgcwyJgxjOhXRG6dtF^scU=c+3>n0fV-U#98PLq<^8=c6e64=<&}_;9_B3OF3J
zqUcFjST|H!uRRR@G`CzEVL(7HUQ8J3!|d1X&aaO;zkSplfQ?H89Y%#selF{li3(JC
zGE*SVTtD2~4;~I>vcA()j!cL?3NJO|4;HqqDvZx-XCCDaFx!NCE`HNkMQ6fj9p=3H
zU&-dEpHAgQa>~c}zM?V;el^!N<u`rlWqrIaw?+s__{ec;8~GGvxX%rUT-C$%%#~t0
zXyL=j_cf0ftHEKmtM1las;FVr-2TV5TbvkcV}yS_*F~&kOze4%i9L_vAu#Pr{-&47
zWy8<@i>I1!7T<CkdBJh2qIU!SP^h$hjIcgZ@e^Jji6^#Vf#8Ie%_%=f)WnR`ez3*?
zj>qCZrHy%&_*|f^%MsQhv#vVH8V<LSX39Mj>mJ)zq~q-6a2!^basB9@B%SK#t_CCy
z3@Md6XZg;6UBmEQ-C~2l1mw_+P$8jHMl(vtuy%XREYwa^P^yE5WcSCH!Y3ci$jB{6
z#Nur?Oo@gSvS@0F)1c!IdIx}WTi4Czm<^-DY}n&4mEJ+^fals?Lt&h8B_G~DR}Q1z
z{v4sgF(2@I5}8!W@jIiA)uZ@(OG*`z2Qm2zlWym6{bp)>!%Gdv^n*5k$)$@>o6bIx
zZ?6&Vej~(2a_`6FKM5iP088%Q*~jxHll4L#%@a6XJrB+*n_7z&9-U0N$(>VC_-fKV
zAFaa?yUlWOnG_$n6p?HRw}^~GgGC;Q8t;1uXlOCZd*Pg~_%a^7Xd&zUQfi7tf#BTT
z7CDP=GZ351brD-$=iJNHK?ay|XH3Yw19}j0X@}Zb3R^2cQ?-ny262cCr$aw3Ag2B^
zuq!cp1qVYD6;)IpUQq|UTO|$<NKAM<YfKXO)1HEJEMb=dX`)YS_@J9rr)fkVn~+Iu
zM2C3It1T^6U{ABhQzl=+PcDWp`angXL?QaH*qWxC=tc(ZK8pRYu=|7exfn_B(#df5
zHI~^;wc9yvXwP0K^~}i@3$UsuWnPc7KgLrefc5O9nV*DNPWMld{b^e6MLJ1Ca1EzE
zC^|1$*kXHc->jI(uJ`Ts{1$D+=vUA#_7?`>LBFlj^9y;w`al^mm?C=gAc+(sK2dZy
zv~Gx<k|b3I6r5v?4>w+Kbtw&>w1v({ItX9J6u){!%B?x2wu&-KX3BGd^qd!5o&AY~
zXxDnZEBIPF&PQuqdtnK1<)Z1SoQm|ssPv)_^E>}L64{S1VbfY1sguyxwd@_D6*4LO
zmRN|hM$+1fiNHUTW5=VvU)-Klz|=_sRU*=^`WA3=aPoC515q+qP5IQs5W01_4%mOl
z`SD57JQ5&shQB?Sep8V+HzksLW@Vx^S#dpkZ66qZ6`4fNt2e|`{?!kvM{kr2Nc@{x
zdAhx0b>B;N?zIRBjCt?e#=iV{3UMFm3grNL!Ds4ku=GG;97_sAPZT3^Y%!pv8}Ty@
zj-FUv!L)cNMM`XB<KHm^J&g~9^{GZXA-q!$hQa_JUK&3rfiAL6oK1eG6OO*-Qk<x9
zfNaAnC%z;2;uzfxUfrZI8^k3L?kQ+0?p^PpgrRZiXQM$?FEgIheB>F}ZLz8QYZY01
zWVANTl_K^kgwy0x92zsmTXr&82Y?4JBQJGJE#ZARCz@Y=@UThm7bTcE;6#mmVFi3E
z9fmeJ8W-S`Njyj@bS_A25uAAO5|!{z$EeVhY^dM9lZlJSKQX0MzXeT3rV+uEQvIIx
z)qR;^JJxiOG~9oaxT06f!AF8r!@S|CwxnR&Y0jyTEfggG!G!xzZRz*zkx6_1hiLgD
zkriT+Vwqfa>_o*P<0A_M;B;q^$xVS1ZNe};_s;2_JR~ldIQQG641si0P>hx88u#tQ
z>7#51)Nwo5v|0Karf$NN7wo^I68sLG3zrkwkFC#tds~k*Q^m55W?zo8x$Tt^W&F4g
z#HNmy%8TuaW+?SnzEq7Dri0L`SpYtV25@l>^&XlCGxAAlIxv8aTU^e&5UDA$v2-FS
z4O(M+O`>)hQprJy7cb-VKrb}+MN#nZCrUPU5vi~}yq%t8FFvOGw@QMsg+W!k$$b*L
z8RFIzE_&pz{53dSHtn;ctxlRs`S(;83pJ{2>s+K~KgkEwjR|F~->S{~-UliYvU5+C
zQQQNDLs*sl_O!c%_l&JVkB)h43gE^toTb{1pGYDa^veSq6oc1yiS>xlN0`{n)mxuJ
z%5XthT-!(Tq<7n99^JQXG7%VX_By)-&Khg!wq{LB*ZNFcneLMrVL{V)qHJu;<xiC-
z8ygkV?<kud6gh_0^dxdv<nlApi%IQ5o;mrioC_P9M+$=Wg@z9QyKR&(<`Yr42F|wf
z(_EQ)Kgs=4?*DKhkxsx+&0P-fUlvcZ48S2$S?TxGMWe9mC!e`5*#}A+0gHqG!wkpk
zQPuM(wiBI7O#Q7mGAl{wahGY}2MCyx-M=ifm=Y~H4Q(RejhtcU%3roS*)VhT(Y~bx
z*GJ2Y4}3vbVeSTSZsoeU)|y%rZv=O(U;O;ir~g}XyL@o3oq_EyN&IAp1TGOYUfGtD
zlkQR<h)?=sJ#h#|`htsVy;ydi>FFI0O*Qw;mQ!5R1|#8T#FjqW$EiU+ov!lK;js*k
zy%~Gevadpg`jqyQZG^$+TQXcP;7<nS;h`_MUZ{>WI>Q3v(roU(G+^CT_mJxAQoZWf
zWNYO8b}nb!wUiFY@~LS_^PLD-rEvKp`SpE#`?E##B3>%U3!}qf0#VO(vr3EQ&tI4;
z6`yQ7c|uHfys=LenJF~hF4enX1b{s?70QZFVJ1ukyl&@_CuG9C5tgYLDWlToU=dZ|
z<KKOGaY}GI)XH(%6wAM{k-0@PRm7ve_$|e~?XRxEUO3E8dn+_r?3p6@n`}jeBB}Uk
zpTa{*vx?yDkI<l_5;MYE`iXeI_itn-wYjyP33C_?QTKJu%8V3EVwr!;)twR9`EK|R
z_~ega4^v~@*1W}=7<{DgBS!zj94m?5d0}n88LJ+G5AX!4z+yoV;0f}NT-ib61aa7;
zXNj5CkQ~OP+2EvfCvW17PTAwBy-91{sT8S3FNa;)rP~t`chhHjlQE9(Rb|Mxs!!bY
z_VqXTU4TVQyO3R}EWqY`$C6T#*q6727hO0(qpHR<^_u&VoDe~Mwa)1Jtgh`;b>3l{
zpU5@GzNoe)<XVrn;%jI23{ux!`uml0nJc~gp}7af(}I??`EC#Yg9W!Z3P)6j$0+yK
zeM(zP61K5Cm(A0CuyV3?rbX%~9(@C$*3iCD-Z@_E&>wUgJHuNUd78OvnAaewTK1&h
z^&3&luI2mDq}=0?t$MkLKBvlgBbooQ{>G1{d7tGVM9suGW@N1bfHeRXV;j$?G6}*L
zWDWEknjQ!~TEL8%G$>5HUwDdnnSFxkkS^#KCW2zUXEY~%Zb)fnV({0lN^^aK;r2p2
zu88Gk%Q|lJ50?YmsELUi&fe8a>23qs1C+2UxM+7KAe@PJZt9j<Th%nZHI3uU9Ts1K
zcnheS`s%1;qC1G%qj<Co*xq8^ncAot+$UQtKP^Go2*2K$_UCpp1U27&`MmiuEk4HT
zre6I3W`xuad?FGk?v03fXKn!bH>Mt3ee5_ffcB0FqY)*+2*h3sKFdw6fxcNG?Z(ql
z=?MzwY^7!3h<F+flcwQKk5x+pt>wWwv0y<9>I*9i>*R)w4BB(Qx<JFBY=@r*in-?7
z<GaK`gI_s^>B|2yZl!e>YGp~iqmT#j50SO01?RyweS=D&Bl(w)_;)3~h^7jbgCDhT
z$9$}S`#DS?PXW`ZwZ(e$ASAg8S{VV?r}HmWUqW~Mg}e=F(7w)7UbHha=0IF>f&TD#
zJ<3fxoUd?qK^2w%j6-8I5hh~mgC2rx%yXJFFEBB%=-3lzDIBr3A7c>UG3vhxkn7{}
zqWdO>0<f)}Or@4di9m9u;~YlhEh3_KQfgBsktmr`G9~&@xi{XT%o&zoW1vTFvCjm4
z_Y(Px#5b=m&hHGhx_+fvlYlv|VYkFGNH(=X4vzB-dw>oFzgH$g*Xx%xqlbj1@*4`!
zIluOFVvQunZOFu@vRh_|)X|v;cJu|AVX41Pa4Cnb;T(U8XgXNiN_98ta&LF{aY>g8
zX6T~3Dq+{6QsCj}iFCv$hVv!Bhsq!<#n->E+)7NIIZZD700I&SNk#FR{`;d8v*xvl
zqxtpBXf;&f{!|2rVwuk^&A(>O-a%yk2g)JM$}{+N#{5ET%1=2nCu#BkIzz~g*5D>R
zn-pcdIDSx}ftY}9Wj}KaA1hl^1ol56qm#JodkVIBQA|tdcvmdtPFKr~tCK10x3QzN
z#HDJ%WzC_LS?2W$ta9|9*3Y-q6g%JZa(31E1~=d>MLW9KpRKifkxjOQ7+WNN8nou3
zp(Sd0E-Yd+f>(eNXR|(~w);99XS$Gqo+*-3*{;5*4_*X`j>s`l`5SOf6<OUBVe!{+
zYw?fH?HGyrf@dLH#l|QDjM0Kr!@$x=T;Swy_n)-!JA0jRp)woH;55%m*L6+Z59VZ9
zgC1>`um79OW^owV)&Y!sCAt`-l6(_bzp2R<NI`Gs;aJ26@0#En)SZeE^pWyR!0-r(
z6(QO$O1iM7E~VYXeq4lGz1>x~)Sg-sZ2uEUyJr<nN&=RRx9JoKgtggsX{@)SHzKWu
z=Ui6Ezghk{Y7eAoa$a6tdrEqK?09|z9<@nlhi*lfx4Ylhn6Ds3(m~Nq?M{4jci$LZ
zQ^5q{ju4RWugxDDkPJ3;$ZpYprIvO$=5@sPS}osXGjQDej_)>m69T?a>bqL|e;v%q
z^dcEhyNu}m^~5ro<()jKc9B&77jSYgVB}e&-Nrj??z2G>MH7C$|3q3RnP~A#io&hT
z?+dc4+7HcerWotl?PRSvPcK|$^SK>+Q(cN@D;TriWW3k<^kW1x%>CwL{Z`Rx4u`D-
z0IXBi@2mW{AvYODUzqT1UjV}x5?n1hoOS8uzYATs^s^WRg?-F<*0w@D4^KFz{YwYU
zpO9F#9If<fDBEPz@X__o_2+Y4=%i^MlWg`}^$9%oUjRQqgrI>}j6%L^Y!_$Ydc3!D
zZwCf|&ZuOmVJbBC$N=n7B)^Lp#`!6Fk)X!g-*Mp(XW(u)_#%hzyTLEqyUsV|trChd
zVxOANpP+=7lEX7zK>?u#(k4U(WfER>^aXP+*JVpu+(uB|pDLGf&EjO(Yo}?sLhkDo
zWnPI#7ZC?O$NRMB+}$^t|LPTQEkBPDF2}YyB+xt_9C0D_;O5cXzJWlWQDTh5|AmV0
zEgx))yC0hQoe@SG#wI@<&y3nKnmK<ypJPQDv8Xp%$8@KqdC`OXm-{F{)WZD5ae>Wl
zP|M~{I`5p1j|n?hj?!sYKtwoNkdFgCdG60@t}mNE_Wc+sA^4Z`(}yZY{7=!4^AVD6
zNlYevin-I80aw*-zrz`B1Q_W>L!}yuD@9lec@>cMhA{@)%8T*EewXi)%hHLIgc!z8
zn}@$88G25fqjZRtOjImjHS(U6UY)8Y#>YpO>mBO1RpxhCec$Pw1pn)>Ky;Y#X_a_=
zu+L1|$w*9}FX0g+n%C>JK+J?{Wh%C5ciJ>tAFLB}1c@jN^51PztsK{!jfMWReBh-D
z*-Ai5qHZh}JYM#dhF0T>3A_K1XIP?wJMp#ilw4f7bf)sMBYJL2!I`cC+A9Iv%=+%R
z))pT#uHnTRrT+OA#4+iCem9&CpC>OrE1RgR)#z#QxV?B@kteP916-Zr+F-6qQ!}GV
zQlftFrDx;i2i=ZxyZ-cU*|g8m={?bQBb58$@5(TytY71u1(IEpIE%Gj^F#Ld(y3aA
zz4I=xiUGe-V>(xo2U2sNwu=Cat(o%aw|FY~jICCxCdx~0g&93anM1<nWBT-3=oVY$
zr;o`b7D;#qgFZpXm=;8Ge(&s0`_{PN$24ee!H3W@7s3`xA<Rg5gie?Zm&M&O#RZ4;
zV}kCHFD<8jpL*AYhltz0*L^oj7KMIVeizp~(w8SHUr|=2#~b(Xe<WRHK-2BpRS^M^
zQjunKNKCpJ3WBtRgv3Bvx*4^HZbo-E(%r4Jba#*LW^C{LzhC(L<KA^&=iFDElT(`c
z(>6bxaGTBD;Ev{8{;^)V&9Z-WFiftg3Ox1b&)PQ?ZN}}Rn>$N;`=!Zj&iyx$;Ex?A
zfY5`^mI)JE#99>icAdag3DU^b@Q=T<eL%umAC{Z9S<q&&XhDiVS-}h9ip~+B7t!Z_
ztR!CTLhP7er34N0+v#wn=`q1i4RrD`(OYHYkAYSkD<K(^Vu9cFzT}l<mBe2Vukh8T
z`MlHXHDVe2$rfQ2T|Om0nY=Ug`&>oyr$;a%9L9pnDIe?ra2jM4yl=l*9+Owpc)7lV
z*iiO*ndrG6`)_gWKs3zB3xS0tx^znZDiyuJLcv6Pm~b8ddQ{WxNIlH?io03##`TX;
zC@quqhM7~>5KoZY`r`h~H~NG9>RNNy8O0FWo%6S=D}<hKZ+altf#^4znGCeSV&HbV
z41iBRTA%werGX}<=(x6i`omC-$%D%hn!)X*op3DHcYOeSk`n#g2W*?_h2rufzbzdT
zpeh#!Ck^JT&~)kpSyz8xu-iiN%o$AYlE3Oi$wApHPdzz^{NNUbJufAxcZ&Hdu;2%_
zF86MpdJfE2fPmk=Cuv6U-8Ox{cVo_RK#lDF=L2}){Q=;iUsS>(_CV-E;$pET&v?z`
zOo4m*jM}LgaFQt9L0iwJ-7ev>ydmu7{EENgl73~yZzs656<-~Hp~JVIYv1ek$QD*7
z-I(0wvQv4SEL6GvLO`&>USy2I<z#QdH)FSjl*kaYU35{2azjODB5hIhk-Of0k~IQ0
zES$(KX8V<g6@ii=^dPS_LYW+8*feVaMZ(cOeDr7{HXKmVzH8gkH--bD&ZK@tj*NDJ
zk&7y1!?Q?Xd)&7g3*6?)CR+9Yw-;Lq8?}m(x@aCYu^at+oQA$J9G~x|=`R$gi&sND
zy)d;W+)r5yvk!EcZCSm=Ah>AQsw?7HP=Q=&T2`W8w@jFg_G;oIWBh(!gc;q_zP;Wf
z(M3k!j2C%#y$REK0~cji6S`?TQS0C_*z8DAH+{m7xFrziYCueb(IPEmhUnfFr+@!a
zV#Y<{WA$6UPcc6tmYe$Gj`NcfS@UbnAN(EIWB3Dtz^d9Dp$)pm?-|8dE!$}pEbs{$
z<Qzvtx!_I$tzLBrCEwgR(oWXwPK0k-k8k#qd(zXtt~dmn#V-6XxmU__?j#B_>a*`d
zf0lj8FIX4|y}`6vD6*+ufG$}ue_gWMME%ZuXqtah{LpDI7yd6&1UPR`Wlqx@+MNYU
z{)qFs7H<oG92+keFbe43ktN5J1;=XZmu%ZkmwbcKNtcZ2{zP&;PMZ&2awUIv@^J~b
zkpmTN2SnkHEh;6PK>cDN2uVQo`w>$+PIO9<Z#)bGGk`Ok;+Krvt@nx!T_GUzro#H2
zx6^lld}oVhN)R`$<29X(1rAqji`sO1v|uR&v5F)>b<X%v@N@i|#l(56j<fY?tDOA1
zyrI=T^_C`=o9i!;k*aoB(k_Ovl50;@7VSF4Y@MaTbtKW8BkKDKLu^a~li&4uBEqB=
z!3%kLFA+L2y_I#2RtL3MxRXn@0A_rf1ql9_rEt%`G@&xJFr5E$M&M=FaO}Zo|0j8M
z|9WKgE+4p_BG1X_;B%l6CjQRosfnJC`vVDSub-9WK&)>a=AMjXJ0UCR(52xZ0q1$4
zC*!!#rc-ig1T<iFhYY1tZ}UeFdEbN%Q?~#86YGCUMj!Vw^DlTuU$-a`!M##AhjF&Z
z$K4dX-tIeo@&4KFBW)OqCeQls-{b*kAWycv0#u>Qd$P1IKVvr!UP<ZXVtv${imm@#
z*RIr$Piy-gNIe?FyANorX1BCtt;o`;tzplZLqy&9cirh1UyZH@UR3jpbpFY_cWQWB
z@*OKnU#1K{N36D;{lUPuB2Clnzp*?|9dU2F{vPfOBeUjL@|qgY3}qLaP9We0o3s$?
zO+czO0>FKs(||l$_3x_G{ujanw=3*9#NifL76>Y_)1K$6%!9zz{4^W4@FhDYtxI|7
z-(Pot;Zo5-xT>Te<#Tn)kG+K-gquottZ2y`IpJETiIZV16t_A0N<4v)o^vTPCBbPQ
zUEgL6=}Kv2PpQz)tz~!17IIvO7{6<3`-6h0!$mnsy5{l0A+6|0>LwV;1Jb`)&ROsB
zy@W`dNUHYLcCgmo&XRPcXZPnyC%&;9R2=%;-h~6YZokp4Vq{yFMzR6j?L$KsZ&y7x
zK}+mG`9IL`5rBpdMtVV3u;+;5gY{I(yWAEUQFKq5^vSW|sZ-21-0ktQHzlHBGHrag
zxY+XDgYm$hXeCD4nlHF(v@F_K3XVx{=Lf5=gcI;H)Qrn&EjfmXhn_Zzszpu<e{x@+
ztM)n=&H@>K)<4}(O!cgSxt}adPX+7;n?D+sb|^Z8Izo$W0GhiprxoLvSxdxlqpr>V
zmPc$Qw>e48-(&<QNofx&(4kctwCs~bFUs2cLcmnOxe$G0OVKyBlHFgArv1E|#L@3{
z)Cm0-ci}Qp(Db+*$y2h7Xa;}3gbMjww)0=kr*z9cGSzNWNf=|VwxgS$rB%c=WziZx
zf8X0$P|_P!A*3HbPZvYKoN%Vm6CNiXun}BU-=FA51Tw+QS?#*RS9U#rmsY+p{H)ms
zZ~Wv+c<XWakMs9}g&R!UU)XgKI*(uX0DqmLgs<W2CbLGS0^&id>n>XOpVSdL6{td_
z*c<d^HbtQN!KipInxV?#fAKRf2rskk!vx%8%O4bI|JnKKnwtzwYTdIC9XD5BA|j5{
zgdU~@7TZNjpTlU!!}v4uWIo)D@&8e}RgN?5Qp^6lXK}}OTjfyeOU^T%u<pkkNvP;d
z7+-ilXZuipta8nD(<YGM7Y4esNCSoS29{xRO^oKnX7AN4bofjFUkChX(|K%KlkAl%
z`KzwpYu>6Z4?kLhO0cv(_n2BvyxBX$6-TI~T_iNj->yDK&zYU|tzRoYc>QzJLF0Qu
z#3|{WBlH};XYcTLv?zVNVh~5|`Lc1iUXKLd&goxDx`cQ&neeiDVqKk$d+%nWx@gGH
zR-a;z>-{)Ohg!&uX5p021Ra|iJVCH^%z4m=x~_Daki=QU8L`OzvV~`W_DZvKTCpv6
zhy1Mdq5-pz0eT>0$(Y#PpjYqACmJDWm^|X9wel{b{3y9DECMPvDou)#S$-@R+#ZLa
zXMmIc9r0(oarTtkve^zp!IGwRUYiXz`21V<@IOBP)eq!KYdKm9;@Rk?z1P%cPUb&O
z+k+f5o5THL%E6<YL3zbp#JqBk=4W-R%@c0%?iE5DhIc)(AQX?*`+E~+R3N}VpTJzG
zbki#ko(nG%tviURKlF=H3o|Q2{mzhZv^@GUv}e8C3=v-o?rG+Kxk$-LoE_1AlL19*
z<DjjQ&{~|7XahK&o;16j&~-MTCyuw>PQ(41KJR-At&w>K*z93WEnC^Sc`C7t$&*p`
z#1K<&$sAJ{pH6x9PLD!<@w|TRF7`8}si5+Pc-}zArsw?WV^@X5WYhI=we#|h<_7@=
zL-l31+00^9i`=%XjrU6zb|X3~84oOFu~9rTg@P4VL*Kp89yBrAYWJBMHpB2-NOu31
z+sbQ-3mMBJ>2gfw1OFf~w*h7LZq@7>GwT^KbS<r7($wjl8DjNp4`utOz6~v`MT`yx
z4YWe~FP@BxR;v#fc_vmuGrV|m$#g*4<Et&C=NI#Vk9z_ZPyaso_LsJpwA_1<GfV3g
z<+c)#4=3e`bh<d~tXh31rH4kvkw#(*(@D?bjzKT3I$*SPbzfGwbB3|ildSy*S<WvK
z&)r;S@#sXRmKS&37?T0JwslB}il<lJ74eEdydO(K<yW#U<>8DG_=-V|`a>cj_>pc}
zEgdEg2;h1EWP1qcj#J*W#Z7^tFh&HyE|;$EM$vR+{(pgTwmiSNdD3?CXt3zowEnSR
z*CK$5^i@n4QEGPh&(t4#J}i1IY&Z0Uk<qn8aUezI&z%h~9miu{ao@j(jt)tCOSY>Q
z(z-KvJ=Z4q^}Gq<pX+?E8(;1A^O86@PqKIhyo<%49209C+)4?><^0KnImg>%zMyzw
zubFo12&!SgI-cNZ_qT0Bf}6`;Y>NM};BY4#m^NX#zK#4wvA@~*kX$65&65`+J~_Eg
zwzos%@FpQo<Rl)C<^K5slW4Gx_gBn#ZLnofB>p<^;&XZ<OApO|l&FW%oOJ<@Ilsi(
z=d??6&;w`GQe9yL>JI=Fl;)1Rblm`@LIVK0TNFtA`9p%4=mTVqCrlsn^k|Od_ID;8
zK)~I~qr^9oeqeJs>2o?wxb8^a!~|vSLQ}nKZI~yiS0SnTTPNOyB^<dG4SU5Ik+K7)
zr4ZIK&uRIgXEG@{5f_lmf}5v_Y<TnU20}OegT#v*mv%n8HJzmL6mpcJMn+T%aLZt<
zvy(D*6Vq~D<ifGm8V4dx>D<=M_=&bq=G)Pb@0t5W@01$(uif`lA12~*Y+9{!bE@MC
z$(I$q8<bk%rkhZ%K2+6B%T4vl0h(dFL^F(1!S0krV8`jn{Tm`<GECf>R~>a15Oa$}
z6DcAg;ks9-g5#QDS)B`l!m*$8W5PVO+wZ$u=;2&=5uS3%EFQPFBeFHSH!3$tpr7Ok
z>7K6FyiDwp*}TcCKsV(HZG5}P8LxrMf=igm^(dFSJULb^XQ#PWH|P6*N1gDN7zCYZ
zH|yA@+9X4h^gePJ3gCSX+&o<b+S)??%_yTU{I9hGD2iY?cT?qUf*tF-JZTE~4+UK0
zFXKjUW{E<-%xHO+mTtbF9eTOX%r4S&WQ+RV06P`kO=L&N=dUWNOQ?|SHz{LA6k+5C
z;oD<mu|G{VJRl0<0;IpgU3?$8@Ab*a`%mR>aYCEw?#W0<?#8+_>Y(B_$SF5}2)(Mx
z3YwX|?bw`z+8&=-f3T85SH!i5p9k&MK+nUwzG!qa@k-4b%4wDc81QQ5tJK>?6~q-f
z(S3pN4GS|GO99!G*7BlaZFOOLU(F3igll(!jFiJfba`D*!J%sJX1x1Mz7ECb;unVn
z?_KsNO3!gH2+}^-EQVqzV|Oez3-_%SV_%`Yoo2cPapmp0A-B6<=Zr+sz#WzZ1y}H5
zFDKR&T@M7n?l(~lKXh=(dZn#W$YW!sp(z4&f0cxf9wGs>M?o6kAc_}$UFfrXPbbPR
zUgBY;Oa9*i7GUr~mmj(mP#Q~Bexanxqe@PYk^-*x`*MLde{M6t4c4AzudtcghZN&m
zn$(WM#>i>Mb1l<(^s-7bGxQxXxfwySfH>1&1m~ZpAXE>aN88rBr8_rnl%zwOq!!Sx
znlilLZeP|BNPv4Jh@2al$6sXQG~u{ZwReU`foGQUbiI!6Zo33J@S>34EHm3*<kv4G
z9Y6VL^qyTA2YNvxxB=d$JWFSo?nSv%qk@*s-!9qkkKn!d_lE!03(tI<ZM^q@%eUmG
z#?cDCaEP2B8I79FA}aepfqOZ1J7GXH76-$;=M#!PI8;eczElB@8jqiQ(A9LO#`~xW
zBv%yZV7K>hm85>j{n$_zG)j58nmqcHV0_hfBxg0zdwr<&Sy6x9o)p?}>GADY=YHgy
z$Ro-V`eVCA^h9i&o}R{=F4~UEaG)!I?PX-scg=YiBN6!8_LrY&7TMJqbkYNXt#p5v
znIUhMPLK3WruUv#3ShB9RMem)jvkK#VgYB9XiLC<fI!x@2Hgt)mQl0^R>>C$t)v)E
zoacO;wAiK$6{u%`k#hiKe;>_fQOqP%ndH10&-*SG$ju5K+_=;O=;l&$MV!%e-}~T`
zt4Zg~Uko{fIQWmMQl74yx$h01HHS}Ps58^<NgjZVA_FvJq$%|LAA&`e3OvT`+Ju%l
z{LwoOA9o%y5eg`xTu9%WgCBVWO5^q>h#+sf#Z}1Q(vU+t<voU8WbNzCjtxPe1;Wx@
zLK44p{Pu<zsigihpch2|+B>VM`hi}#d4=ADpwOUN^<1VflSWSdd7jP;k?<0VZTH;r
zzcLrXdOdAT7!@J+m$29*3NMC9KuT;pi`n_BpkL_MltWBt-(FKfMz)|V-u(C)^8vOB
z$XL8f0$_KW?I^Nl81mV!b6y@&$DhF68>(bcnDRzoOl)f^w#ED=M`(rb692BjekDje
zv}Cj;Yl?`9IRK+CPVJh9zqhv!+Q@|~V(xE(USmaVll14aqS^6CFUkUXsqVo#X+VlD
z6dO(x=}#br0icox133ZO8d<R5oRumT*DJboef0=f$(ZR3Fi}RFW0Dt3af!w}k5N%W
z>6G<)%+G;yA2=kZCq*t%EE7TE|7szuMpd)6{Jb~hJgBJW71l6i8Cn|jtaY~og=N-`
zj0laD(Ke5iMkjJ7b3M^ni#cH~!DZSQ*M1ILpNP;(1xCTm#PqXmq-kM6$qZ@!W7u`R
zP%ml#c3W(7*R6g?mJy}<CZS;Nw$Ggs1-h>8@aZzx{fEhlc1SExpl!!?dhGdxg~)uQ
zxzPu3W#D#h{qv$1lO_^F4bQK>hR7}oaT*tlZ-uBb|MldX|C;d4bA;&W*Eu9>S5?$o
z{qD5cr>K#RcEGCFD3+5DQ~$5Q-05%kJe-HSm1yDCn-!j*(+mo_eKBG#VPyJEYsccd
zah^iU+w=*1M~O((8)~G)l4m3dzuz$URpc!pde<1H%5P8+j>1qDd{-#;Sp3fd^B?Ar
ziK7nDYFDQ*JFSE@5Nnu`^J88@;ly?c_#jPY<Ryx$-6t_K%2oY2%OTc1U#eII!M8bQ
zfxcOcaocg%g-NI@C)&PkwF@VcWax^Z=Wn-t&6h(JS5&m(wx{JS@{skntJ%mcwKeRV
zE69$_OZc>TzK8llB0V+T9XL)t!C(_=3qw_U9?U3vi@tgxNq{aITLuD#>3(*7xVGE)
z$-&9^u}8T!tzImVeF59!U7t}=d@6ZH{(QVl_d?9e_yz~BNOuSN;xk+S5f-Z79HYIG
z<_-8j)8(`Jq)@tN<r9pp+w{;bFrHpDWxHde-y{j$s%1oD0c12kk#6V@xE1%@dcMA`
zMOMr5xmhbL9E?A|f_SrSw3+n76R~PF5-gZ$i~dHcaMZEs{`!Trq{Rm-<A1oL=6SV^
znzM%We#GPEdp0p%a3>}wi60FXpR?I65wiShoZ9X9OZV%bqCKSv*+3tk`Sfmmq>uX|
zi~A4DC*0{ePL`g9BK51@7b14ZAmp3P=E;JpD&d5?1}l)kbYi;yuGO5<$^J=tP>Ctg
zB84e@`Q%v74`byQ0nODa6alYHmh^s(FSt=T!bJdVr*cD7m5{fc&~E~0L}I4ye{1O|
z0#JsyJv!n$BwWOB=&n(X_@&a^E!IrWEoz+^gfGz4b4g+6XP9e*`znx6%58ifYgH6?
zHoEUO`xv(r*8@lWhvz?b?FoQP-Zl=Dg(X|@cTeulUjFSAVhph9;@deMfawZ;nYRcf
zsg4H(6(`HR4>MZY;zP1Q8bcA0dzDUxKX|9A90W2ybHnXBJ1!~!oe&-@-5Gkd@T<So
zKZW7diIB~can}y{S&-&}J)V+l<Jl|us_s4q-yXd|99pxo(HNIKPbvWlc@I-4$?&fJ
z*D<_Ew_9Am7on{L=8D}QUtdW|eWl0a(sWM5mYJ0D=A&*rAjjrSFX{&Mz_WZ+9O>p(
z%(Dv@*^&)Ki+b`PF=oyszoB(x&<jU_d@^?B-QXw7S~Q&`PZ_xf(0yMz+u;h#&=^C&
zjMV!T&A6wk_{_oY5xb_C;ZFvBr-iG-Y5BgbeDtDV7ou%n6LT54e*fa@nW}S`QU&cK
zE|%PXYzOb|>%2L3H$M=g6^g2}c8=nxBLtaoMFOvJRkn1*u1PeV8e)e=5iU1G*=wFR
zmPND+=H|9BN)NPnOcP>RVL;bG6YSc|TuL?_TL)77bfGPozczySdR_M}KuP4^A$xT5
z&EAZ&^s~~H#JFpMFw)P_D@+E#P_R(~geuOyL+d4@{pAkZZrtZD(B8UeF$jTDq3(o$
zOphJh`@T7c5}-S~SO_xbhe5xyT;WTwu-yb}PDYPJgKOZEse1NUAoF-@IW4^ifL)gZ
zHWmBgNSG(QJWo^5(T_c4GgxjJbG68?5`J+6y%~tjH5h+7YOQ<DQ7$VZJxD@8R5CSt
z)TnJNF14#kcTYuia=M;cTL#!n73KV<q`|yE(EHU=2BJr4J70w-(DZ0+KP9FyLaQvG
z%#r-vD1#anj`H?8!{EZS7};z8Ww8n6=!1$9h~zHq!MsUc_|g7*YwCXtmh;*+sn}Ca
z;=;!Ht=(le(rwNl=Hp+`EKgVQW}Y@ol^OGBOli1NiZz{*iD$E7D}MdGY$};?N}EZV
z-Y+cI@0Q&Efo;h=l3^2X?~d<>3ptjb7B(B4tC>iQ=VSfM7MooqT{^GosI-Ff2rk0C
zb~go2dH|VJC#(-jL`dgPrV>XdnC1Z0`}~<i<10qoPry=o0*_39D+-`<9pghvy!z&5
zKa$9BCyuomXo$dK_WVUpy>-7-qpx+C^kWn1+y{;0@Km|xcNE3rA?3$F|3HU)X=eh!
zgP9;BR<W;hrLx|`q*N@mZ$Z!jJ3M#3paEFi<Zi>@2%AjeJ3Q8GkwBjj4(hvDy;{i2
zZueE&)@#Ms^T?SnAxVQPk>hsI%+VO3cx#Qif6>hy5Bwnp=xNegQM-U^-jJ`Me*mvT
z)a{y}9httLv^YVB+CJ{t79puFPBUKRwCISQ7n*t<_AwE+*v<5f<arJEqJBj}Lq8Ds
z-*p;%Fg|=R<3U%haIuLRke}IRl`r+SKDXCyFF3Z#qb>_2)eAJ3K5wE;L9?3PN8ii;
z$36SpV|z);on`Ciw({&!Bc%efQWL+_1aDitIlv1B=#m9pd{yZB2G0npXuHR2JZnB6
zPVNP3uxG{LD7i+#e`{|!Wj-ccE4kaXk9r>M3BtutK6)hj>X)%fHpzi^o(-k|jeC=I
zH9R5(Ws{t3i-D}d_S`(t^*`euI4cA%N{>a^>9t<^z5&e4W2NhLcqrR1;|QUz4Dew;
znMZ$8Ul`9B2N(dhzjh5eM~h@xA_}WMtQ7&8=<&t(cF@T9uTXSN?mNEZxVN2-G2<JX
z;FE8{Lpa&$_}S)KgjC%0Q<|iqPoN`Q4(SZ(G?8=aGsh-lh1$oi=h1)OZONgw@i!|5
z9W5jwsv|xv2Fi@8r7a(;Z34ad%G);Hha3G8SLt_bS@qnAX^_E<+!8PyaScA)v3?$4
zTz(x*yl*4?{YmR`&B&E_VUuXtwZ?r+>Pn;`;8cF(_I#KYWd(2LG)b0Yaf}sNsb8!S
zskgN*RfsNDI2Z!E_iEZr=^cNtuts$;uTqM1oJV}5M(f;jA%|Y!GmGwedzgSd{0zl<
z5^_ne-*?{+D?gq&-e1*HIVc2Mqox`ESn}0ou!@|OY^MfMpF?8s{vyu(-hGd&02UAA
zjR*B>CTiN`&lD(5TA~FctNWHSt}X{&+^9h>t*SsSPApGWbrW%E8>VEH*{uG$F3#h1
zsU~FlQ~29<-03xL;eyM?W{tIeLZ4lV^A|wN{{D0ts@5J|a2vo@=C?tf0>I}fXSSJ0
z&a~8P&%{=_`5h{h4ovW^D>8RAc`G;wc|C8|W}pSI+02|Q*po+#up%Kl&;8J2X6TgO
z7V34qSfS&4>bE}bYMb&ino{6XgtSksgAKzf+7*WJBo6T%A}cTA8gHatZn<rV_%d(o
zsI$G#9YC^e<IuNg@Y2`lUBa6wh*0gp>O{!F%*)mL5Lk-GovhtR`wbH2G=5Tva*6P+
zS;k#80jOx?(oY)eYq!s6{&cc5v3z7i1(>`yT)jTE&-PPp))sJqcda)xeY;8RYu;MS
z1Ue&v7=bMv&@*;AZ<%mf!TkrTc><A^c1?6q&Aq9LOM3_O2i+}sg?Wvx>?GPF9=%Ip
zQLlXBDA)+hw5pk*J$xsh#esv*H`ju|r`3dc+TODC31?{}eByBhF1qSfF(9y$ud>DS
zWcE+u!2KibHr*KjSEnj01!>WA>e0C#wD~&-^hC|>7z-pWB^|&2dfr?w)%khi#SV{9
z!jD^Ercg*GWCz#&x&@Uknmynt_Q<$5aTk0pu{Tmo{#`HLQMONWK_eHw*Ocg~`w^yx
zmh@RTtl@doy#;4>wPJhaF0Sfa0}MX*LfurZ(_CS#uY}ibA5f(DLRZG<wyz*^n!9~9
zY}MdHTqSxgu!3G{>XY%WRf|s{IeFGSlsxE(z8o#4@~avBUk+a3e+g{w3lnFTB>Mcu
zzlen4iQccaTPd7?(RQ(a>B~73d6`R@IrdY$vA*vD7;7r#Rgx`)iYa70qKcW752#Q%
zeml;>7!j8f)13n4-`a)%sOzomCt%MrP@c=+eLOtl^eSH1l<ddK+M!|_SupnaNzDpU
zJnb&9!SzATtX-nYRO_0H*%)&Vpk7!fu1g#LfH82=HH*pCoNWQIlo-Iys}Sj`IR6Ar
z+_me;5L<S`TO_1*>*jJis_{M@5a>}<YQf{YA113QG!Te$AQ6RApc0|zoRmMtDi6SK
zo8~xuRQ7%+pz9%)i`Jk-TWxOB!`IV&bD@`Lo!wWI@6fo7OG(urWfV<KR3-mHinM7r
zP6~icjweGWCb`92fH6EE7nwfl@y%m{Qu=$F*vPg7o!Nlh=lNKb94O0VK+X94Z6wp(
z+gkd*Ea}O7lA0Ks;C6>wKI2i|r8PGvSB6i}IDBI%_uDY*@d^@ZSI<vQcev0Chqo$X
z4%F$rT7WXeCZ3eV-8dP<?<IUUt)FMfW^Ly0(os?_)#e@yr{c0;e<R=@$f-B(cGB+b
zKs)Whk*s%AD#3o%r#+eCGC^yZbjA6TW)S$AYeHtD4i|M$Be-d+KQ1PggoQ;7Wk0^1
zV*Z<UgHbIhe;H~LiK^(>xjbhL^c@4+A}g`bI@{-cpxBUW)ck6~(W2o8Qn`PGTR`xP
znVJTE|GM4tFxl#>!jF+;CHgKOvNsGp!n(P=G3U<7njd)vwqH_H{?@W^zLvN%C)cKC
zHfPj1OrpIZlz+`jl;p#toqrfAN(;3!jm&HW+zJ^6May%JUP+wOVvj4NBDtHs?!$wq
zZ*Z5n{UGSOf^u|GJH6pac41ms$aUq2Dcx60h_{gIOL!#t-ezIHnspL~RPH1GP3llI
zq;<)oVj8&2)8@5)2L(aMzDS(}gUHbJqm<rGxd;?`wuBPwJ#Wc{ncYF@zCVDr;~W+0
z1u;Onb~-m<=%*vgzo+9e&Eb_te{sWq;qRE<Mt-jK7h*leJ*w-w5T#9YZhZy&VHjsd
z9I&2C#1%jt_F}Nw*9I^MoP2tmUsRj+Ma@l+?C*Q-${IpQM)gB~0P0aY?IBxv>-mlt
z4)RRXx<xf;o#}YjV~I?Sh%SFs_;Go8^-A+Z<rZ6r;XA%6tu3zP;dsRM8&5qGtJ`d#
zrNC={K#Rs^*%eR3i|)VEP^S^Mj>*5gTfw&)m4)9z`X>6I!6QKwrL5RqeZ8PYUB_^!
zM!{NGQvw^=|IZuE5PR?1!_b%`vKc}}N~f~?t+}@jbltP?r#+kkS){k|Vy351G}<Ol
z@s8m>TGLY$@28oAIC2qnby+<gdKHTPd!z6!bL)Au*f}R;5cKxyLSZKl_@3bHvb-MQ
z_jMpUqwu{<U;64=n)A3S!8iSD5)*RDm%se<cb0(N5W5^D&s&($dtY|&ZK~#)2LK^e
zUI@R+^YXdpRY7^%{c2TEZgvbPZ#6Grfp$jZQRT$;ER09j!?x3mL}PPhF5~xv%5~%t
z#X@PWNVXj_2gNY@A3fm1XL<?rO8afEH&KW45nXS!KRwBU`u^DL7;Brtbj#d{Y*m{`
zw^lU&p#HCzp_i>QLl~Z|^@bvyvyhY;EAbWgL*-{~%Cl`IZ~RYv-zWk5;pUMcn&(eN
z<$i}36`C+oE$@XuBLx*zl{lbB&87@>p5-4}4ff7XerG1_AYKHS-{dEjwCd%LTzN`@
zlZbE;aOX}C3Zc0+c#;mvi@S3A`Jg7mQWRc9nP}mp$e({i<s>uoMq5<zjq~Xi)5l_x
z?@qMotbO+tP9H2fA`qV_P@_Cx|FD*}=|Wn;4bbJBjPHuEu^7+`5mZP8_V~M}CiO)b
zZSXTHfD|jHI5MhD``nH90=;!aF+(M6)K~^ySPLsD|8llpr8b$a8khn1WX#lB$;BUa
zNa*v<%K~s5sIH`h3sc@{w(N(-rIhkMCV4DDRO8s#@vwnshR^=0Mjkr#^WzCvG5<Y#
zZR+-vM=-c<w+O@8uJ!=Kb`-jOMXncG)m}-S^|;8F_F0ov05jXl&btFqJ^MF<S3w8=
zwH=xVkr#@eGY6}+ac`o|c}6p8*%<}b&I0r)P?NnK3E-CY>3SAkQuTj{#1*^u)c@g6
z;=zl}4{iqSs314v$jm~}&zIa0lo79IC+x#F+}_m<O2=f9@Wwdqgji*GM4gjzFOxVx
zQe+*!CI#)Q&qE%m8ue=z<Er)JWbE1trL#J&Qv|}^7P={yuWjbbGFwyT6rw+9Jt@@g
z&FNi-_va4e;(;d_s8}t^W?Pq5x!Lek2zuNQ2Rj7Ofy79*YnjCYC>JtGneE9wb@5z*
zryfe)8*u`h3AY|*_D;HlPLKo&f6i`D;2Lpfs8Z~y-u^A<0SpqfXo%~CE|!89Zvg-l
zLN@`9M%S*af6t|6sbITab3q<byP|dpX0W?lV9$Xx1KF3KQ8|2$5!DzS-Tg1ga_O@M
zesB3jEfb|s8@!;BqgG*#a#urIiHLNGkXZ#VO*akQb<0QT*m6^^zf{udxCkC{C!gVA
z)>i>bVJZ}k+ml|twRvK50|i7BW8=Fu67@%tItPbnZejxeJNOgL&wO5a9huc^3d~Xs
z`aEU?NsAigfsgdHNB4)=)0)V`x5%xb-#Zi-5`A`M6r|DDyT{({ztM~yB7&i?PwK6^
ze(KaA(Pz-d>6Wv<ldBP|yQ}h5XPM?2y`Wj#qmoD%eWNVUn&MR|(Z671Y&O3gCMxs}
zG+UgHzDgR|_SDlqpGbp8s(!cK4|1^U-nldpZ9DE9{7lwJX;Ue--K?8jkxPME(<1xb
z+!^BT)NLa4pA_yVCFOA8i%HM+4CHHTIvx(({h_UDGz)FD%;fSn0hqNt_~{aG?qeMK
z0qz)k)(I|&1S*CsI&Mm0ZJs>iOcGiHdmZUibE>6II@fSMI_T?;<ml1f>-}V=<JpZN
zpSZ5YqdXe&6+goAcd>C*r8ddjsJ=StUl2K4KmYF%Z>)Jt80Wqe7JIougrX_f2trS8
zm3wJAAi%e)nLXR9q^qN%t$C1L4&~~zRZ^6y_zGw1@pYYoUp79va(3{Jmb_h2@cWd(
zB~}jrFCjp(P*8SwF3Q0x#0vYPdF*O`=nD=DZ!jfxQ*H$g^|Tydf;8M5ZJfb6@->k&
z3|`9$s)z&j%Xy)9wv@2GWF6;e*E+~K$qVaeOx)bfP4XIxE7W(b1TnIxx#~3Td%#EO
z)@;WQ=Jz0tQr;%uXYr7ifi43_5tIy+=EV`YQ<+!5d4Sm8;MaJ1rs*-#&P~eW-rFY2
z=_5G<B7z$==C|rHqL*cp8TTb~wpifa%B3?<Jal)JA9=9ZF%ow3N8$$vz0m&Zn-!WA
zD~)%sI72;;>THkR#B6`uBN~`gfrYrsWsL9QHEPOTju%)-5R;`zPU~!1$!XIocCGR>
z<@D=!7-k^?Xz{QD%oQO4ojoV@+QtXFfVMZiggI*@d5K)PeVs|Um2)Am7*{6cxtC}D
z4=A9*$2C+Fyd!4(_*<e_Shqd7qiMjBS0d$t<(SDjdm%J!#Nf+<`|s?zYHJGo=J~2+
z+uIc5;1?&eRJJAp)J6idhVy@~T3qS(X$@`;Z%}3@iciFfe~GL+5)(Gh@0kX@Fvij*
zeyjdf;%#DMs-V(q#hoDmSthbKu?kEf;|#G$SMmzI#-_ZB496)f$N%}_KD6_uvM(Pl
zTj4ngIQhX#)SMF?N5mR_Ay3+ly@wvV4xrO|BSNkv4<%|1He$2>lYP!CR-4UNmDej+
zDXWDh@qOZcrK5%C`5!;LW@ja`ulA}SdMxyUuU(mS9%VlKO5}MwQ`TWo&0MlHkXJkp
zJaL%&cuIPaHhY%oU1Mpi!B27}25ph+W_vGJ#L)Uf!;fjGB~@nrpoiq0;%oTEZ-$--
zCn988OCoQGs)Ra(qe*Klc5lmY!c=O}RPp$`vdt?QzV-9kqAxTLCf5abNz=t&m)8Fi
z$ard0i2#UK;Nb)=_W8~U+AGwL<KtpQPElds)*NIIRdY>N96EF!R`#3Pw7B6Yx8THQ
zBq*FTTT0g6_#WLXmU!Vrc{iL(c@#)g`?gBVxpL+)b}O~?iaL*C;O({Ml37}&TwpC!
zf63{4$UW|$#Edx>Auap6YBMmxF;3O(ZI<y;8FVkW<cK7A<*Y`5a!r4*)^cA`@w@Ue
z*nG0a&>9J4)c9{zqNP-Un3$OVJx)c^mEcC<$_n8xn4jWGX;_CiwXi048j52CFgc|b
zI?ALn%L8lTZK%FbFdcu9_$P$%<@h4=WK@GoBGFbzJwsmE`e0t|^OpAhdis@zYn7p|
z!RoJ{LWP$ao2Y$D4|Hcgjw7>OjwCV<m|*+Y4@dLJkzQB=A=%N)N5IrE{->-|Qo1Yx
za7*hM_3Cs@O@Gq;nZXt0u@8x<bbo~6{;3CwUZ0*_iCa)Z+v*_H=6C58B?X*B05j9F
zv#@L$55ovlTqB{)T+?!lUUp7Sw>0BAaSipdv73SX3(5<c5FD0!LA_IER#v_6ZNSif
z`IM}HqQ;mLyznK)V*H5Hr#f;hdksIc<-=I<hxUp&dI<|fIuJ)>XFdVVD>vb4(hwz_
z2Cr*2<UmM+eiV*He2=dt0W-SrEVo}MRqrZ(C^2Wa+6F%?CtQw+ezRE}fyLS0tk-*{
zCH;l*+}_}3G2$p<qHjHK^$zIgEOjQsFR-D>w`cYfQDOB(ki(LELNUWlZzn($*|*D@
z*p`#?DL3XcROspXcd=`DX4C=Up9vrQ{&b!rwQtHrl%~p|T-d?N;3iFM9qnaJyrz*4
ztcEe8A=IwJvh=i3BI+NrUy)jG`$p|4a7(4IyvTKUu74e;p-|1W!j($))Y(e)+5+Fb
z=hT7lyX)d>62JIh#-beR?%XS5<)V@!@{@;;^oiMHO6*dkBB@+$2EF^eRrd;BIXvuT
zC#He9{G#)%S2-k|6GkxKbn=O|2YZ>3#j-hbJb}l$mSxYT;!XK-qDKZw8LVP*0?$%^
zqwl%x2mpwn4}tJ_aW(mO6^Un|PnM96Efx!do*%-_0)f^GP6tQz*0$uIv`NlyVI=b7
zE9^=KHm3;d1L}2RV#cXumG?W(`&%02H%(sY*gD(YLFR-d6n|LI+0$HOnsuymK#d`n
zxcb&VL0B?(KXzRA2qZ=GE(|1V7vav|rISRc*a%W-a*;|{4r03RW{I}2^*U#GbCdqd
zB^H0w2Z|WRks!)@aq;(i8RMuh?d?9bC$$n8k<-Z;^>dV26kN5xcq3;`G)OT|msgDi
z{OL&vl$B$bzmR!6^9Mg_3vLrYsUqD@77b1UvpCV7QUj9STOO<UGRVut1?Odr<x}^*
z58{`vu~uJ{RJ1iQ_83V#W-W7A1ool^aXG1Po@Vk)hIQgX5HgFGNnc%Ql$I-P+8W!F
zv{h6-p`+OGMcM3o{YAd<jaahO)7$5NC+Q!;VtI>jCIKy%LGE<K#u>^AQOdRC-$9@k
zUx!#E_SgAEh<k@RQBqWb?+PMmm;U>YhSJETHdx<|6PKnAqXbmD@XUnl#&aGg_fq_^
zf75Qc56PI=HMBDY@TGH7$Z{-xY)jVxE|lwKdM<#G_-Us;nbyI#KDgKP3{y<Zo@<~k
z{D<RdOu<~(`8C{2`)YPk{E^S?JOj%BTYYv9w|EkOy4;@P5_q!ZW7{C7yS52x7%xWX
zQTm2U78Mn-WdDn83_7ve84b^+XGuKo-721LY=w2Rnc0i=b<Y{YwcIml6gtQEp5KWw
zUqT>7&K}#s1j@4+B41n7D(_<FnGT=x*#@2q^+Xcd4$n4cn47)+g`yQb^|SQ!5F{Lt
zcs_1}*z_G2|AWP{%rNwI22{<|kbWScanpLT+q`vzxAL&)=B<2}3-<F{x!k|M0ulTo
zX(r1~RE8{TKgv)Vt&mip<~kzJ<$z+y;Ome%1+;WMi7t0h>_TcgeoIszbQo^zbx_?0
z;zx!F(4rG)yuao!2O;YaaL?jAB9<U0Ef4bDVExBT53j`?&MYQ@+v&bRgUy_e8XISv
zt_%C+k7`(u;|AeHKyBpS>lHy23|-G*toyUNQIf%|_sj|O34P9oN&Rp_^S0B+T8%jp
z2|{c@Z#afhV0z}dkZeKyip#)=pSuO#?IWm>{5JQp=mkwl#n&6H*SpOXFJf*kIt9|7
zGDA;EbVg6CXji2)1}*@|j8-`EdJp5s^i!X;TMNnUW@Yh5XNN;zYvBV8?g`KG#|I!?
zg@<1h-=4+ExrmJS7x<WKn?7#R`R!_>i&qPSDYiUJ<k`FPTjfuaK=3bkHM72F2V&z(
zNs-oR5ztg)n6-ArZh`gB$!hAZdXin~9*Y9IyQ;#T5hs6_kO7_1GqXYSMA=VnK7&Cr
zN~HS7PQ&GP!&dms(ebRN_N-c>;ybGOk(C!gbL;;Ry)g^}S}CQqs2kNYwq7iqFhG*U
zINuCgOA;&V&$P*KN;dJ7V-P(4m&jTq`H}Fj{>zc{<6%+ngV+v}0h7dU_s3jVS1cP~
z_lt|9T&5l>991+jS!w@x&*bT~a3h)m>rDLM)IZd46qCNt)^8#E7rzz+Q7b1oY<6tv
zO&KY~Sg1db3M2)hf`Aggpf*@iBAv}wXGeAC2>AsP+MtZavG)BV`4kd_fpjmZ?QlN&
zkh`Dh-s5nl<=xgTfP4}=Y1uQMd$$U#qC)gl*6mMP&qrHNKHX`Bz-LFTQLTar7mOEj
zA+r9=>V|>rWju_I$@o%ix&TW(rS!zEM-_y?9R1;I{)-PR3kvd2dZSe6SSIvKh7A^q
zdIm1UrJ1b*NI_e9SLQnI3z<PGDDus_%$LCillNx#9{U+s>mfTg7AVFcBE|I1p%|0l
zp_|Jd%M|ErZ6B<-N>bm7ZsRCpCkQadd6P7Cpe&%!0Nt^)Ac-#h`*8p184<+&{6k*m
z0^CQw+_WX3Gp-M1)UdKVGeCI9oWr?q;}Z@IQ5Ctq><JNe`TVE*fB6Z2i7mfP$sZ9r
zZJ&_*Bw<$W4_@dNb?#H`KaQkivt}51o-@pSRmw0+*Ux0#k0jtpPSz-Hg>^rd7&GTm
zlC;a6=HC60gN>q_cIT<EETfNrByH!T^8`DP`=VZ1kOyUHI}ejs_;Bo&tySv*jNd2(
zY2HWpETW=q(HaL9R7C^4eykPCivh`sj5Q<U;b2j>H&P5<9Xv{B%HRSJQWNZWL4#9x
z-&oc(u4TU25mm%I%5eAo{k#9Mo>&^&?f3@I9Iu@PJ*3{j{!2@;$!9^8k#F)`!$)E4
zG~S1PaC>n>UB@M{jqPWbD-$C@&fLv1b?bag&#wleX=d`hAZkL0j&y8;d=ur>SnD5|
z2dDk>0M|Q}xKwBsec8;~w!ezL%J<laVH;X3Er^>KEgMhGL6$&-2ie6S=+U1YwkA|s
zrT4xNL4y<O8T5E7G|9BKwWsfV^!L<F(mce|R`-FIE!S^OV}WVLyL6hCGk0LWIyT5u
zG*9q}N^dPM-BHN#Z_-`D)*e^SJKuUGeZh@^C(ELkLd8ehN$Za~g*Yyy=3fMfR<fCC
zA2K0wOQv?so2YjAax%}o`iE*3FW$prOg>}{|K=m3WsfJ~;%7xsQPe*+tVHMDlZvCF
z^lE=&^_<#Bk?9#d(6HWqMTNn%_&I+pJ#1Lt`(?9UHEpP~FHm}!M%J?Szcwq<8GB)%
zfYPbe3u2dm>MXUP!02z1{bAAl{l?gue8!10_>-HrCU|G#Tfw3eQVTiW#yrBzt6BYt
zn+LigR<q@pfa~_}88=#hl%!r4lWh}c$!w2I_fPWs1<&Ywww~%wyQy8N5<Jn*|Jd+`
zlJzoPV(G_sz{tuV2Kd<*;}y6Ow^90iYqYtL(gLL68$j-dg?TXnB-LVI@arQ@EaRG>
z$yJNJaq|aiRj(EM<A%k;*IqQLt<X)p4!`UC%$-{TYeDtiHf6E)mK_N~{0nbHpV|sR
zPeh*9z2DC5=)L6U&!451sq%k}<XnyXnGgOnMO`;uhe4xH?jSCnfsuMe6I1)4BLu{?
zcyW0M9O^lz`?68I>1Q3ykbkjuHL-;!c(%T6u>H;i2a*<h<y*>5gPIYLO4a{2QUBoB
zc-aH6ls%pF=D7Z4nE>ZrScMN%?_K+}B74jKwAV1|m!@+?Q?3AL?j^tJ_12E97>vcn
z%YGaZuz9?kU3=)bgWDaLwXekR%-`rvbuHGFy<X0YB4Sw)_i5a7`Ef=0fN>x{!g$AW
zU$$wb5Yr%$r1dzC&lS{m;GApob%EoBbH}z<@*=iU!fK+>RvT)=@-GE>#7sFEIjW?*
z$>b}*i`e;KjRP#P3HINsmYUlH7Zev2trcaU0UfuApHjjd@1s(T@X|*^It4pU4n;$s
zC%s0<4<A$P-QT_6b1ski_y>p1Ph35oi`0OSlLvN6X_-!A41%2a*-frOtHcWK3rTR}
ztFlNFv6Z-KEmN;ciZIOE)?lSiRit;O(d}L`+Nay&x!hI)U7RdiSIj2|Ml(ZQU6HDb
zI)>T$>eNcVc(}4VgrdCg)%E2ore|nzEa}hhsjtf&r91MPs%$e)cCYy99sN=-MA{Kl
zZf6x&H(1pX8EH!>Kg$9!WU<(u^bd2{mu;O3^^eb}P+pHR`}hq~rn#Ex>JtB`7$wki
zvSck3)W)X2+k+ry^1aqoq%pL$Bbf}UYZ3)@!Zyg&_;aget}M9w654k8`nqZJjXjM1
z10CbZV;TR-YuJpAu?qaqw$y{EN@(dbEqO_q%OcWPOTbMdSG}J$aM(|gW;Mg`gh6)8
zx*OZL=+29ryKcFNN~L|%8tXH=?k~<K)6Bkb{9MN6CW<;lfJ6q00<|8t%<tT}NVn^>
ze1IV<`DsfkCCSN)`GCE1fmy2LI`;X}E>H5)j{sc9sD;+9nZ>p&FS1zC;YGzpF{6dV
zC7i|Q@XvlN_gut_Q$~m7j8r%s8oMd`w;d-NC5w!jUUQGP^v&Cv&WJF34RX{0fb4<W
z0iF6K|D6Xp@5hq`gcv!~XM+Pq`ZM2J?}<X%e%64BnoHUrE9?5S!8N}wq#}pbEHIxw
zO{Lzu%x~nU#;_Q(=X^ahgRkV0_Qo?JwvvWfi1qGXJM;aFpV6J367lWdkZ9N}F}F}x
z0++l>KW=-u-iyt*1o6(<&J4oqIUzpBV;NgUmn-*s6|O7#^@u-Q^C7E0f5qR>KZkIV
z>o>p>!emW#W5d21;f#zOq%ad=)o#ULA32H3`ODdes%&yzDhln)k^cl|aIKsk%Qs`)
z-n=dl_y-h2XrK^o-sS;UY-TPJzxl+E9OrcU{25dIwLTYt1ne*13i#qhKXc99Z@P(R
z^q4Frr#QSrQXotMmAjC#ggKd{Eb|J%zE6T8yQx@0w7#TtM9k)$>|(Q<+(LT_hlg3l
zClgUcTp6<>?Vj1SkZv4m+&)RS%Y>Fm2iz4I>8*H^Z!5~DCRM`Uvu*8@Cus#+>IEvX
zYBNrbOxJRywns-=99Ey_zOs^-X!PF5z%uN6y!IDABx;>Z7{=)Z?NQV)n9NENSY<w&
zJ_C6p&_TQPKVk-nGLt)*qebw}KTlKUzLU~^sR<1j5JQOyT)f1ei|N7J82}i;`o?%e
zlK3@iu)lE*d617s*7ZMI{(|Ro?SL<mV<#4yTT&uB^Naeiy@8i{{-$o_hYof4%f2)V
z8CzG^Uk}!@)#v7B9o&3A!Pnx2lvpxtCuOJmFyu{v=!tcPc<WDTY(c}#dozRH&d`<e
z8|weA*Obv43$ACC?Nke?zQRarZ3jf5i5!|slTW|V=K|VwCIkI+#2@kgv&tbPXxGL+
z&L1bx82>U0pJpA{gAguDC$|15x_q{E?H2_rP&#N-$Cnonc=r<0lVFL>xOo0SkAJ~A
z2UWA~PYee?bD`?Q)`8q@{p~brSe_;vUr&8<PCf~+UX-znw+I=GjYxDcdSHc=v`RYv
zh+;ZCAb2w1ayU)a;X5Dohw6H@<ZOxhgOPEIKf*}SYx|@GmrUu()6TKx!&Z8M>&s7o
z<dIwOG^Z?t?9!*5ZgKBf(Pjq}VY};L*pTzX=if^n^7P#Q@pOo!S7yTy&*(;L4y53m
zHRDkt=AkE$e|z(LqvDjC+|ls6GS2yb)EGg|F|_ad18S*s)Ym6z7acgdw)q1>DE+iK
z-^-rBs_Sw_J}-MJy;Ez0;*Q0)2J9*<gtbyWNzTwHtrVDkq-LfRZ^TayKFMt;CzQj4
z*$*Jqw?``GG4;cW7d)xNsy4a`P@U$4$&3@!tv9v)>%|__|1oR)8}9p(nFp<>-O&bZ
zSa)_qKvR)+^D|HW8}R;BQ&zwD&SeRzJm)f-Za6-XzIb(1>twX3sL*IF_-9<}L2@^x
zTKVE^uKOl}G;nNYJM@CnhXgrSl0_g71GUojCc6A6;6i3vE!d;e>-3pMSp9+cTlGHZ
z$t~1o`IR_raZ!@lKgOZ|AJedjS$nM>&oFo&-bYp~J74JNzFZ!gA>%^Iul$jJ+$A<%
z!O#Bn@3;&_ttR@AJzw5zhs;<ew;y^{?^{kS1Lh~PlY#?QqTXpuTcpx92ptcv88`V`
z_+Z>Vp;MM@Tm=$+F;*IU@^0h+phqLRPS3o%&G4?;I|Vl67nJ7LPgZ790RAqor2j+M
z+vSnx@9O=ve9F@lPursbJ|FJ}{Z?z4Mv94sWgC$OsC9}(tAx;GRw{#I>3|`_WM$(Q
za<!T~F5l&d5!`G*ZEyNM!_3j!J`hJqcKxLF;750tIoDAe+go9zk-jCuwiFGUp>+Rh
zZvt5|{cIy0rOE!Y4RAw`hGSwcKB8jT=VB$B;4H^|QSkfDo6KGYf#&!m&cu2m`QLE?
zvPKf4gZ({?ee82tHCZD=-J~B0uLbKVg4Fg&Su1x|)m@8QSFVnFJkvkPktD&X=@W96
zZu~4Kam_=sj2(=+>hxH&V{BvlrsUgre6F|Ks9y`Lo*ueO*H*^KRY@g$@OquTtXIV#
z)r}sdQnHX8T!!my@F{p9CS&4g^=dg=y=Yq_Q7dPl+>@8;>cc!!Bs^?8c)kLysZYAS
zJFNz>Ia37Xo0IrcwWE$$sFvb(zCYC*d%CCDuWa}!U#+}Zq0mTWiE3NDDXrRPdwsok
z3s`R_nXglctDo={Yj~wmK)YN%3O}!Itw&xZc()Yl7ST^~H09ttKQ61o!?g2VdAVj<
z$IMrB$xtRmoZ+Nq{N}M@E?de4`8Fsjx+ltPn1o}o@IB85WTx(2XIA;Lvf#7*TYvy^
z7NiRvDJ`n}_bhAeUMZw3{6e0ZH1&IxF7@*6_cQK@NO(2n5IuHI%70X(dugIOmY-C%
zG5T6hN?$Eea;?{hO1o*u;KwbeJTE#AgUoLmOHL&ZE6cxk0o1(x0}VzmZQ>j2eLgqX
zdtMA4$l<_dd%fEW4+Y)H+#cH^7!jxPB=`lkV(TNs_sFl{4a2Mr)zuE*r62X!_oFfk
z)=}O*P#g4vlTkvwV(BJ$=jqsH2d8XtQKd>^uKF<Bn7m`lErDyW5Q*V_);7NRp^T5!
ztQp6uPuZIbW9`alCP&?9dU11tj6&+Gby1}7ri$Q#^g-(a{-+k3<Qbp<^iq|E$VzzS
z7fvDHu>W;{w2SCFn1B7N5u1X=UoLE-y)p!>!QEvQi$!(6Q(ON^xd>U1Pijy+;)Xue
z0Iz%G9e8J6Y0iMsPZFg<gA(#;GvjUh&lJK@TnF97HVZHrj?*(B9hb5^I5nRnnC<<0
zhJUf`DtOzc6f}go%*?udm-JF`>px|IsB@a?yU&Az1>*Os9_e;=JG1T&6I)*dF#1(p
z_o|}!kv|Ntt;D8)<~aXH(^oJ=`958PAR!G>(jg!nN_RIB(%ndRv-Hv}AzcE}-JsM0
zOLy1O-3|M$zyI@ogZsL#m@{Y2%t1=DrY7FxO~CBYK)or-V}YB0Vlzh)m>y&F?v&ly
zG>yYn`%OfxkA@-no#MN!C*}J1qXBc@-aI`2_$A!63&Q785=+Rhm0wwumwwlMrq-3*
zCrwxT_DnFemrF{yiTF6R-v+FPQT>1K_nO?S#z4D1ralcfZ!5}qTJiDe{#$^xXF0E1
z#`@IQcmxY?t8#M08mbhob4gL*I|wIE4}nY4eZJpFrb;BE{?Uwy_JpJVnC`Fjy%|Uo
zQGU)lavNDK@lqPZktLbrcgU%Z?A5ufCxtYIW9VQ!%jqiG<h<qGi&GD@uG_mDptcdq
zs(u^l@Uje@M8^-c<c=iL`8DPVB@c>yIqfu|8^S89<NFd8dZ6gq>JzJ_kLAOCvqj0d
zc^KGb$xLCbX2(WA&|p4POC$Zi$8;;O-f+olR5MT;jgd|q8htD%RIaqS=r{1D;wB*j
zJ@sp@mHq_&t_cm`CstwQR#`(!n(PBs!1O_Vob_G4KQUJJq{lJu44DYQ4bhhV*rLC|
zRCKO{uf%jxbacQ=wefr}R^V#9NQD8OBB&lmvL(_k89B*8I``T)-HPGH)1&LAATh^D
zI90dSq#5IjB|H6wLCa**_h+Hn%Y0Q|FGsQ_#;k#R$7%`$Su-1l7^tA~Qrw~7B0-$D
z9{*hGz=A1TW>q<DM?sGy3~XNEUiVNa%`~vNu3%{?CM5{u$#23vAQDX5s-#gx=U&~*
z9dAz9_@(DSuH<lbNw<)Fn60P?I1fCSX41yG9gJ5QaaeVq$eX}u56kfo=GE4RRhj?>
zt3;!L`ZDZW3P2rIG0A+TW9Jgde6{0v8L2b)j~c}r3Wu93?9*}3k6y~9;<h<j>{wT(
zY^=hMpRXlLu(mOb+;3P6!av0U+G>fYpHKFV8e`$=eV>my;5-b{E^YMShIg*>USUjb
z;(st88exo|*a12v#pz@m94!`=p3cVU9F(e`J)VBOwE~o{wlH!Ee5l!fU|eM<dP`%<
zp(VK4@Y>uyp2()|QqnAieGO9R)8f)umb^F9MG(BcT)2G-@61o`_;M$VV*9fL%fLUn
z#)PTq7?^~|xBd&mS1gl5u*YaS?TzZMnkN1Vu%S$Duw#$j)T)=qP$n6Q*IBG=L+^fb
z8>V(QE}P^dr$gha2Rq_rOCfG<c8wXtKzuQrYLK#I8)JP>W52%&$a1vQyCgtve0@*h
zYBm=@X`Ssn&4mW)9wh8(G)!HwqnE%^*?aCj0s7|I_O=PgONGV4YHPbJso6JbE$uH}
zDm?J!p?&H4+o|2k0sH;K>X)Wc-Y<v@k&T={^jBJJ1(ul6)Vi4OzkqSfC+}PlPQXbh
zdGnbCbfm*q;ZZ^nD{U{jrqi>FL@v#cSKq-Kh`z{tB-zD&SL%aT+HPtdcD`)RLo&Wb
z`0u6>Swmw%W`hSacEzvkGO_Vayq0|O4z}18f|K&x`*wEet;f+EWCIoJu%a2Oq2>4F
zvKYYS2Iguy4$ivl5oqtv{T_cYxd4L#$y15>YWh%`8Cy(9Ys34h0#nz#Qy4~doII8A
z&sqoS`Z3c!+pyo!-FLc6=)Q=dzXCT2w_6jy)4?XlX0Brq)3!N5Cxjz&*8{B+wE_r=
zmsvWei;)hW-qmZJnXPD*3{LSGri}rPX<x!T=x~KY$!?d?>bRv#R+31Wl|1aOD`iW~
z`Lfk7MQ`8@uynHbpM98VaS3-G);Ykc|G4d8W!jNi5`@65dsLJgqDP+Q#6}Zs!Zl>w
z544Ye--Do~X<W-MJ*!zn&@!4ZKWQVkr7qT$R&i*bc;@ebhwb68W&~BKe(Zm5-TcDc
zPJ_qHr)sr84(HO(%8CK(a3z>PI$wL_KuSzOa<t17AO{Zo;B;H-P4G<H{f`m$jOmN3
zKNadFM>%A9g5!b*<SKCsznnl8zSjMbSq!-JC@K_+<3)D1$F^Fh_Zm%+W@3LT6uKWv
zqoHIHJ$RoqEi~O7OA%EyrwgmLTTEO!ve(OncQdx`&m34EYw_oMrN(<M*m^Lqyy(Y?
z6i^<f2ze%c=?5fxtVXm|lxka-f?>6xFV^-9_B!_rPhLPgE;(S9nWs&He~}DeBzRnI
z(M{w2{4K$?ZN?BfvS02cx1)37uLd&oOz!@@#a@2PM~vJwqxmX>fM5PL2>~`NuG%?b
z+*!{@B8%<yvR()5Y!dm$!4XB5;K$o;)=I5eejs@Uu#%K7Ak_K};keb)b;~9IzSt$@
zaph~S`Ni+&bQ?ubw8t`P_(VVj@-S>VE8fy|=~zbg3R20Xp!2vyh`_WRNou4ycMJv8
zOt`sg6}K?J^5A|i(>L`R8I>wNf@2_KV@Vj+`K6!kd!eO){;yo(9WSKJTk&#e`ey^g
z7G=fvO^mCNOl_+AZn6Jd1(fP@wacJ#{$BVx_<drWXbOvXXClg%VjXA$K<u1&pQ-#=
z-jttQ*Gd6Vup?_hC+@AcK}9j!58cM3M$MIwRQ~J4^U7sH7S992^!NOBtABrA!)Hkb
zS9&?H`G1ZyWL>+PF)LJBHC$&}B8<CH$0%W7t;QcL#kJ&K2KlE{N>Fb&)Bq0MyuTZ2
z-OAMMuV1GWq3b4zlVADy#Zo|zq!Z5#c1P}!1L090CA1})HCxT7$-qK=x%xVuvSp<c
z|3cN8S#EgW%Iz7UyAk5dRpb{?sg68zP$)akQoLP%YZCqrgUKLf*3N$2N+y3LWST0u
z_}I&Ihq2{Bef>M?O`C_K-C3pK8S0l07L2W$X4<b2g8Rz0sS=9@3g*C6UhE-9Ax~9L
z`Wk_|OAUP&+%}V^tEW#!B3Mm4_Wlbu6E7yKhoJf<aYI6W!IZaZLWnQ<aS5~ZID>dl
zus}V@8~*i@heCQmt(O}sy?7^P-wEIdW*6dL3Xm{vAt}UHdEvd=ZN6_C^&R54$EmS<
z{O?gOzlvyWK1H0P36*McI?ze%8dlZ#QHYuGGmOn0+29UaZd7@<0=to#+Jm?~;<*WJ
zs|_INPaNM4Ee+<+Ghblgj$HC_FtZd@%Y*clw8&fPBG4nLj?TgO;p-5lOAPy_)0>O|
zRLi$>`t<ZFA1Qv=y-6Ht?{X(zd3rfoj!zVv4Cvd5%nB@=8oG|)9RX9i*@mpPRJ#bn
zvOj&E<W1g42zPtk+K7j-_sc{2OH2r%(fh>e_{KqPo0kd`niCEO94E{ufd`&|I$wCz
zyTYkar1x>|xtjh?)}AT1k&&}^S<Gn(mA&5DymMxWCZnCbCz5)SmXfaTAb|Y?)rwp`
z_SeKTE=Cv5RXS3r?IAb=AO8)kO2&+G?A){YK#Mit%q!y_!;bk;&BRN#en=saroqyl
zd4B@&52F=R52~{P|1q1<%mJ-f?X`AO+2hLhcEUf{eQ3^t0NPkZzT5rzChO8ieXgy<
zho&G>v<HS8b40Y0t|B>DNe^)RqtHPk;+gCM&nm<z<af4`E^l<F^NaL)3?0O4ym&Ug
z5Yr<kQFxw<+(5aAq=I4-wInm+c-I>C?bZe@*5&-KuFL78?sBl`^$&QUy=f=wLiezL
zU2^QYNBua8amYL39?%o%oZbW{ftZ1;)8TsTPsg_0t#9#C%(95<Ek3%a&q~viCbvC#
z+wYWOBks?eib*vGzaCIwPzb(0ubgQ!XH7SoQ%`8MK4AY_RLnVPOLzp*3N@+<#LTd_
z=)^vR(`iTYW}TI44+(+Fn^Kgr^?M){j!8gWyh)oWM3)qZ_dj;umc^DvgG?UiyWe`|
zdbZktInI2|?slZ1J)a(>-`TeHVnmnXSqhvBZ<_l%c3R&{2$4MhblR|hAAEHBO%Y>p
z_R4+}Kfy3DZPb|qdw11S5ab7FApnD`B5RcF`OY{%;Ohlc_UgK_pny8R3bk6Bozn51
zrn$l{9*=66KA_c$hboB&ACnmn<rxfj3s0<o?OouBSEO8WS!?_rS^r9wq{DFY4{opy
z>3n<)ZON9C`c_b5Z-jI^o!|^rz0$(aAvlP(2^0Nggd{SfV+L!GM0vXj@lq6zZ*_lO
zTxK$yIaVV_V`$}+Y}tSCBkKzUy3G2(dp%l>2vZF`FWknb65yzo2zRjtcqgY#mo;(O
zY5CWDOhd3<Z^VAdZj457wGsc$GnlHhA7CCdHG%uPOAqmKW6w<WAl>-+F6dFB0?7X=
z;aqnC9js)6X-25?eR`M(&~Jrq(*69)IVSn{j;$M}6)xvR7L^dMFPV`h73@~NPKkAv
z68$h!K%z^eZ$SWvxx!tG>u1WqY|Vw9{kG~5Vjiu>tAHoDpRyWGCfQxe`(4T~*KZRa
z9Vx6UA2~#>=)7igU#Ur#pHDp&I0^Kse3`!`p|O$On#JQ`hQZ+BP>jU7r@k0SV~O7Q
z<qzhkWWYgv2sw=8Z8wvgy~vG>q9k^M=yt+n5vVYttkzgG`BE4oF){w;2U_yjJ$j#k
zcWSv@<lo3&3=(lY=9hjsBlh9yQ=`-7xjp1e(X&Pgwbp$;dpE<$0y*$8pR_~<j;&UH
zh#mH<-0|3FT6c21oHVSH<N06uuBTB<zp4r)Sv^->vD$hLWDH`G$}rgIlii%oH@Lez
zrFCU?4o2{bTWL!5zIg11$-!pTFQ>_~KHxwASvlEDC0OpyN2Pwxc&KN-QyQwZ315X^
zcj=w)<H=qU9_}b;-{un{jZR|VQNso*FNo+(FFm&vsjI-3EMDoG%u8c2E^+5p$w}do
zYiFH=q3N46aPIqurL&H;jxU3~6=utH{HKH8McT;J*z03+ON^L9!AA1<sS3^=$2@BY
z$Q=W>pRs~u84@qF{O(1*07MXwbKG4>=$`P;csd-MvUnCDe+Hzdk{#-j1lKI<PW%K9
zy+T)VSoNEr?2nI|uxpS)o(k}b3;Xg)(YDJCQ!VWO@AJ2V^3xWqhu}T0KW+`&XBw^B
zIMz%E<?K+Tz#0PGW)zTki%T#FF!@1aWb9vve;m2BeLj2mlA(N3OPZ9I;~H{e*L|4B
zaL9ET>NZx~hH4|QT--56_sJH$7R{ZIXDZ^YbHTl85Q_Ot){n$QvT_6G6`*lj8rPRd
zXXl5vF74Ok;C;Uod9140N};g7B*F$0vAv0Bzq;#n$r_YCzBKK8drASm^L`EW<xiHm
z-`@STIUFA#>~KdUEHRU`$37s*V`3kbz*njMB03_;H{d5rk8b(HAkJX_9~LoCc}eb0
z`w9|y4+5;Rb^PCjAiWjb{5tw~+x)<s=x!>^ScBfV-~zyaE0&c&-C-uD=oaNiyPHJk
z2*TL#Xj=&{o#$NJxsCK<>Zs(Rci=X4F(mj%@=d2n_j8Ao$;i=8MD}btrqxOJ353kn
zti;Zxi#e557v?tE7il*|$WkBW<n1jbc&1JzWaWTS_0-oIBG8~nD0vzGvdGg@4m~E^
zw1A!n)vT9+Jjjo=*9}gXbvZle^h3526d&`j5BZIqHZHqRD_(nuHobdfGO?w_u!S`5
zlH;IMGygd8>2;w|3}aXc@87$QeZ7#SV&@}{hiC0}++ybvjW{88ZEb0ns8qAN{VQH#
zN!;fkI|=>cmA;e?>kq27s!OjpyDbmnWZdYy(l&%bVdTG4CC9AO6!X8MJltyiX(p8x
z&3yB_+P_2E`r_lfyen3Bq|Vwa<P@#Jxah$R4mTfKwrQYsLy=yhGK1?A*q27uLsvmo
z*)u8jAiIZI+Po4nS|+b+E^3lPky|GEt-e|Z$2F+TLjH~Pi~j4MdkS$fsI>O@J>dMX
zjkdTT_#cTCjG#0^#wSa=L~90TxApgZRj**A=;_)qZjG62w*+20oeSI)BpPm!>xpP?
z5tn{`P?BmfEivmjPU4e_N1>BvEh21`kI!K%N{K8BlcOFhDDE#qJR=(8A{E;L|G;rV
z9bP3`^HPftw`}o2qZaL22>Bx5E`-7{EoPq(!Dh9k(Zi2U6tY$7nLFz<IBxxV>-)gL
zPS$aswuUKi+AZ@Adv##(g{p~|zV;bY9_=vb%H_T#;&LD!%25iTkd6oVoSC|=nrmu|
zSpGvjXt)iPx-#bay9bdqvf`0&>{xbL_X-D<avESY)eJ2)#kPc_E!$lB;G`k@S~r~>
zMfR!swu4)Ba`;XGpf9=k_z{;tV4~-|dK_-X(HN)#ZQTUAnxFf=?UjGpy(FsXbd!E#
zNyYE&2IQcZYrG0T=a3;oA;iB8GF-#mD`O@h?(yKFOm^@xdR92Ic3==rOs=XpK2FDT
zCKD0MT_bw>sbKbb_-Zc%0tgjW_BpyApDy?LMWO)Hl?sezc0@(B#vQ@}WdbFZ(Gv&O
z#8}>SQ2NH_cYs~OP3_lo!<}h>z3}I*Jm3n!%@=8_p}^<z90RH?oHxlk<~m6B8Wy#r
zhSY0GW`5sXMp7LuS3~(F1cVP6`|f^dK`V)OP}h5_1b8SZbXHqkKD;XMyuEG?LTPba
zYb>V#+KRm5w`?Fl>tC`f<L?iUHd}K25p3xPACqRA;g3I`v~ERx6a*hC2n1Jh*A765
zW-k8mV{uTYj>pu;&77#H|NCyT#8Tkm(z?TCzt_r%$3{uoJ;Pk?eY!&$oZ0Ut!TMM8
zk+p8W@dJJ2<e(%5r=w}&%fZu$nv5g4U-Sk999uROYOzZ+OK^=?i8tq$=4G&U+q$>`
zb%xxKAGs)J6PTDL8DZ-7Kk+j%lBOR2kmDKTS5xj@To;hM;B0;zzt49J=%>4gQ^CLH
z{JbdDUQ2n|^$AS1G!5M6N1^q;h`5}@{OC={JY)N$;xM01|7KCf=kT8G5H?)%yTgYg
z)=&6oWd8+4G0A@EJwtiCe7xjRS(-Un{)G4t1#hum_<PS-KQI}dQ?Hf|>|R{Dwzr$j
zJ$*R8rsj^>%%f9RnbEC!?BVQUFfYdG@O^RdJ$Za{Gr0bR$C?S*Zl&pCTl$bDKYO;q
z8;Fm6PX+q#GgSXo4i*zC&Vawj!bpUGZKLHcJ7%eKc9_TSQ_mXqo35uJBc}>*niQnJ
z>YmHM35x97W-32jx(M8#Gi?g1c13g<ukRy-9+((+xqj1knEo{dg}=A!v~G8ZwNIyM
zxsz8BUaH@b-^AQrDW-F=UH|?=5~+<=3k>7Wa7#}jGm*J6Is}dTKYB|hL<Zt!togJP
zHrOVkF0;UT(XqDOm~vT*auM~uoV+;?#erP5c{0YOW$qy`#V5}1k-%&we+5T4qIIUV
za@n!YwnhL)Qc-GoKFj)3?(`G#W<rEi1RHLo&+aY>|E7vRQ8NYkYPkC!_(b5mruD}!
z3UnIat(}6a1Se|AZx%Kf$zuA$8^?>Dul%0TmYGRH{Vcn?a@tN&$C7&QfKgFlQ7|5e
zfH{I_3hn2e-}sph3Hg=4xn5k*N<yJfAa5(mSgeh5EUEkuIL}S=Z{s{J3Xo3>wJqk{
znvqTju0n84lX{Xx)o=ypyU%r(l0pq$>u#uzD~t1jLv!|$`{JgmC$mCeRr%L6`|Kh?
zxUvAm@hKi<I8!#~;d;x^w78~El2sJiMmV8W#sczjMQ2nECsghGwjC6KY~2!6z`1A<
zr&)U^2>p0SXPn6Aq|4Drj94vx*Cy(1lEnRsyd@M9(gMPcp(`3uu0pQs!;5a~=1pM=
zx6#H6M}C5IG7hq4o`DAv6896lyL#-yDeb2DEMc$NlbVZF6&1f^Lsbr=|K4gOZzLMj
zJ6TsLW7GlK;RR2EetNPJI=N3exNug`q^#{Bv>@S3<J8qYSzp1k7Q6U3{bt&yx2r&H
z{l~$PUD_FS_|^Ar{pO0lSeT+RDaUx1eBOx(V^kY$#-JSo8zUV`WE>3PCA3}oUY+*5
zwS1gMG?gXpO?92|=5G@7wAhe0o~)x;7m<d#(uNPrjUX;0?KuX`@R|Woq?SEoo*qr5
z^@XEQ32qXq68nQbeov3yX|x%jhIDB5@(zo|L~_j69jeR(AotlUr28Zqfzlvr-(l#&
z@kZi?Ke|J12E?rBK9mxF=PA3%@BcMovkK|!HGG?Qe&*^SMzwb7zdT<oWUkDibAe3`
zo=@-Bm!9Fb+f-YBBO_S{`WNNe2C?;p58iRptva_h$Bf=bS~ip*cka^i?jIBO>PzqW
zr?@YF5i`XpU9hATPF&&B{F3!U?>M?XnH7(Piz=z+CL)dN!N*0Jx8S%UHvh`ukxhNc
z@U<@wQnG9Y*!1o<h@=e~6ws+l-YT_YBH>gn%IdlOK6Fo2qbCtz`G^!NdpLZynlRjd
z6#n8S9bCirHk@P9g2<<tl38j~gTsH$AcM+n_(J5g|L-E#tGiyNsQ;hGZiHf^JylTH
zk=Y03x?B$f&c-Ku=&ir@W#(Bp?9fO2JM^C;j8D9ushr~Jsafh?JQpRyQ{PL`)?ic6
z>-$&ra0$HIqh=mj;>8jUPL$09cX}51yS$mYAkYNKD{JQRX9Y#vD?d3d+wN&D+cVw$
znWIpeJpH?%Lb|uep<8rU=aO_v-Hi9bL@PG<6x|d8{w@mswjUpH827{y_G0L)=qkbU
zlF4@%uk}1js8Px#TN8yPQefZ4dGdMVEq#Sir}S(|vf)92GT$pORld&?*>dQ9JdV#T
zy#@92fMV)e66D={e@c_D$}HXCHY!EiVr6N1b!mH{2D6uWyg1G;B%#`N@efC&tM?85
zkMNeG4n))NEG3b~MXu;0I~W9?P`Bw7GT(sw`05P^^0S*B7pNyE!*en_a8ViGYVTxV
zZ`abAUT=JxUiZxMNN>HT$u&JXf{~oxCW@3gNCh1t2N|gOvAeB@;@C^+w=>^D0PK~A
z<ssmpP)w`!5sclCEet}ObKfpc8VwC*NevYk9zw2+Ts>4L{8Mk68^qyzkHiaQTZg0@
zpMW#>W}n`cG$s|l<a-Ohs%h-PXTnoA6;I+&80MxQ5~}-y+OWvY3fD-BT1F;GJ0|m$
z4NO0#c#K8?kv!k$fBf{=OS9IkeflQimILg#D~<2iam*b$wRYPk;wWG$_fANxfd5_l
z4t9hF4o7je&NW8<75A^xVNg6L#jLh5H_$@Vf1|J4QJ?RkL23ZF8t^Defhe9X1Tm^W
zYc|j8Wb^f{dJHEwi+F)3b-h0^KEAmQDtFAhQrKr?{1yD~90~4A^=IEMcU~;57Seru
ztw;yDnHc<Lr;;~?e_r{~lH^4|M(<*-_Eq*xYWU*EJs0g}pHttS$omO}BC<%=D67H8
zI57Hitpk@FubQ=;#94-eL_%_wvp~@?!)<peKiE@pWk9fUtokYVS7qD{C>{AKXIftR
zYn#POc#FNXSEd#>x#Hu-j|x4^1CLpLFTO9iDV*k+ryhL)?4hU0H#UMp7yXsN&$|P;
zu{tE(w~6%WIV>Wt$#y1EDQUX;C2vI=29#SK-sY>{i5Vi>I8v`dzdW369W3dk6~Xpy
zW`_YEf5LwfD?#Zq(ct)1pV^Gv32hzWZhG&So7?Z9x+nLow2~dfT3_@LI?EUB^u>w9
z_{ES7;^JadEPZ$1r{Farm-gk&NNbCm$gG_32&au0SE;V+pU!M}-!iLoIPCV6!6{mE
z;K5WP6ojn0{+f)&+9I_oeQq~3G8f-Ja|m#Ary>wk)yO~v?;!{JUh$UwD`wR54ug#X
z9N$oN3X+$+z-AE=sF|#n@3cVlKsU42Z=-GQU_ruL6uz+ry{^K%r)qy!?4ABh%Z$@8
zM?+M6d^8Lg98sM#hH7=7I6TjzacYs)k-hulGR-GJqykLXgMe0)!sP>VC?(WNu50*e
zXf{cV)v1`-^44Q*b0ZO-7Tw1iwsSo)7F%93_G69iB6QP^?0-E9zlvl}mq!nt2(5Rc
ziZ+X_d{CQBzJm6#EG@LU@$cFf9iv%;r&6lpV=SCifs>9CQJ%)EBktZgGg59c-wwQA
zyM%`!8ZT}}EGII}2&nZi<1ky2-nG)?ejWQF`_N57u3m5e{NkK{TUTYk<RP))ZC#G=
z+%~#So8WKs3>L1>uTlX=KZ{NFBPCaYJUr5NbRlxUCqHMf)ZD9ENWg-gAtr3?s4%`y
zLsW*>`k~i{I+oR|c%s^0vLAIJhLEOhfmi17CfV5m(`I4q@5!A8sU_*u&oBN{_nA1n
zxfw;3dM~^&Vv%1RuS0)&JX4CRTt>urEc0^u%9f=+`#(r5zU4@)zdOv-!d#liWjXy2
zv(htP9xq{;a<%+gT=}kj!P>Hvaf}-Ale%q6tsdc;OwY1E%o0bg0w66x-(3HLVhL+o
zNgRDQ_>GEd*GouP#P8>XwvWH?%)j$u*VDxqIE~EtUBi>hO^Gkl_nH|{PG|796IuO<
zCQC(<f(R^{-KNB?9k8bs@|Pi#J`ueyswFvIa$Y=VWnM+gtG9Xv1$=zB1B#-bk4v_l
z`;=r*HnpWKonX%!djX{}KeM{OEg_-z(bc>|uhy1@Ma6<1Gx}H5OM+L9_9Z%2KHbHi
zTfBd{I3c70x0A2V)eyW|nFBNrDvUZe6Kdu7@#4{j?T}${@<WUx!M}!ND7Vw+b`rl8
z;>4yoj?{!CeKS;9%jxO2h|#_S=7l&rka-$Gn$gYnj@XFw?nwFWk;YC-WZgrBQ|_}z
zp%bz$ew|2Ubt(%BClN0uCwGo1Co%<OM|eN)K%7nlh{P)IMGasrUS2pS5PaYib-gcq
z&s=m<5LE)9wj=VQceX^7sP(inzlzNS5!>K!+CXebb{d9niA}8Y2a4aF-_|4iXKQRn
zrUOAXLsQHo(8ZPwMZF)hL5w_SG93Xe{_LF>Scl})+uj?$DKv2nYx7_*Nh%CfP#oTj
z2R^8!&rV;+%Bl(M$G4~%Lc{1!w@4kXe!ZXfwI|&AYCf7f(=M)E6NF=IZ>3`+k>b#W
ze9M24V2b<NQ_(sw#~5-xQs#u{Oj8WTCj((3ZW7f8bY3mFh8%l<k7u2x4710ReiXX~
zp%h{-BCk<MbjCcW6)h4Rt}Mld&HG0X?kPsi)$T<i_hMVKbQ1x(a&_%Dd>niRn0*gI
zht64qUd`IXe@=NVWkHON=n}3r&YQE;j3z3y+5d^|G`!x^ugJ!%@Jb{2xVR^DVek38
zzcwyfQ}m`xama#mZ8wF1C~-&;QwOY<64>9oHVi*uwFycU@-dDTZ&8d;?^~7Q1Pgk)
z)w3h|sD7Q9d=Cra+^8|QU%yYM`pMzi3NJEbY)r>J%8o{G=GVUJCW($r-z9)JC=R{T
z9f^mQek=`^`9vcc<iGqp{YqBRl$$hjVf05-P^e5#=ik8-{olcpvstdcZ^>?#6CxGa
z00<_HYHPdLVvZ<NFB9!Trlr(Cs|Hofg|Y!D3K?uWaE2mz$8J&&W*+1=%d{<4g(JbS
z#w|yp%UEwSCkE%k!p7(COiC;iT<aFqZv$F-st@Udg<uX-bHt9#;#p8K-6$%<;Suwj
zJZ&tYm#L6cMsyqq&{0PxWz~B{rsXXE++5K_={a4U3<@J`aIIkke80GuL7bZErWo6L
zm`acJaCkU<<J;jf?*5e9j~<J}bzJ1pI)b@xvWdyZ{o$Ggmda4l$Cz$t^(d43j=s0(
z`+T6N=V4E*s$mtJjaPSP!8vx0p<HkkS-(_5OSs|Qy}Hqp5$L?bR(rXdE%^p5vsV+r
zwLn-C(N6`YN!$^#D%_pC=jo8)ZZufyHuo2RVi^HO#_eS@1P@-Tc|U|t2(=C_3#H5+
zMkf>(cJXu&K0uf>Lv$=lVTFWeJqwx&hblBTdm?oxKECU}#8mZfjn`1zVyL;&`zm@2
zk!CucR}wm!6E3tqr-~It%q0)Kl@c~Zfl0S5wTH*U1aKE1blw)4Mv=YKc*yi@;Vcwd
zO)o!4T%QS!dpgNk!aU~GYsS!yNwhItWS`GZTekN92`7ac+LTl4L@C#~C|tU2rjr_;
z+HBq@;}a38x3kg5<}dYSo}$M?m;1Fm%l-N8=u<2pCw}?)&yQva*w6kaa>hr$a9wyy
z_tA61Sk6y$FW+U0bV5Fp0oZCeU-0zNGH7$6%m72JBVCb&Z$%TDR$16&r}2pGx|$($
z>^ahQ-nj_Q%nzuQLDuCiWD!W6Hbxyh+=~2x)r-wP^{cFi4#e<?X6^qQ;~LG;=MIxq
zYY(+3JWZwaiycaL!_F4AwUFDqrz>OXP}A7W!jz4-kZ7~C?}7kSak}KR@rm-Bji1^T
zEMYj$dyHCALes$76$cmu#mr6LkqnQYVr%(92mXFE#>c;c{}+7N8<GWcvEio7Ve|Z>
z@Msm{O?MOZNQY7JbPVYYQcMS6Ha_Nz+J=g4SyTcGXX#3{=mE%RsdNE7y46(u>7uFd
zKZKr%H2C~@y*t9`^r$6HlJL=~y*7UwTW3;5fG(Ogb}Y9+wQXL0{Sxe<*>`$B&HLE!
zO&zc}zf_=)t%L`Y<warF8BkGx!w=a`GeL3w8O?@*ml8s%Y1H+q+)NY{TpeA+a;J~B
zvY;t$8$++#NOr`>4Yb1m;yCzAez>*UPfAbX=Wygke?6qjAOLyDI<q>0?p)(m`_0?Y
zsE2qMDr6*TORE+1#x@UB(e+c?F%NmMG#^g@$;Ow(A8lW368TQ0+3ohp?uWYsC?^Gv
zwkbMO@7l<7|Kgkg1<qCIV@T|yq)&n4v+I<W3$6mAqIVD`p2(83rdWwc1;}cEzu6M_
zCrc3s=m(F!!fX(Ak@tn)#5}j@OEWZ6mO0E2IFnevw5#t#6k!(mZ9GW}$gTA8!nMEt
zTrd8oHw4U*Q9er27KFV9Yp%Ab9wjc9@VY;T*s0_UV8F^tm+J^x>+rD6BKvQ%m@jR6
zdO;_gAe}6&EHdN-M_jn?<Y+ec6bp|9EKB5PHn<OB{jQlEq#JFIZiU<QQp*#<NcE>#
z%*oBp{hp4&R1*PPrA*Uhb?hVs0S1<I!Sl&g@qIG<nFk><5)>zkHqhb|g`$G7+LEq3
z{oJpzxj%@-W*X;KvkSM?Sr?hj>o4Qry?a`@G#Xd}tr2Xn(qDA0DICpFmXAV1WLTtH
za|Ji^4waYpnewa2Qpx#ti$}igG^yICzlbvu!iZVTEU527cb<+aN3JR?h`p6qNmU#z
zFtHKWb&S?A#Mz!fM6{V=IxVpc3&QQ$p+WysoAG|DZ(#stZc>FkAd7eIXT7g_k!n*g
zmTpI_ETN$0;ef*GEzTzgk)+X?VxbZHh5U_L<CkqP;vmYKdheUd%``5;lev|?GB#N{
zgWoyK_gz6@pI4*ckzG2g)Gt1z<FV!-kv;t^q6|0K@K6Y!4+ZTo<UQ6~IT+xzFU*Mn
zOWh3m(v=-}`7E{GAIfxK6w0P`4H7GTMpB9RRY?pK+&o!wZ3Os{L1F#l)MG<kg1bna
z1*WY3giP<k?ce#*cpiOxatQ~Oz7iP_kb5RFjOGX>XQIp=@tJ*p<xNZKn}>7#HkgrU
zLYUdYr_gxU!+qJ$8&EMEl0Di$YcXQ3U^Imm8lTJv%rd4ib`;v>P6uV6@O)n!83R{f
z4WS?%Vk!7ja-_>Hq`Z)cDKQg3?4_+`=Bf&E&tD_OiwC%Agy*|FZho=?o<Rzpu!>jX
zI5noESDiw(gr`}@T|~8clRt`uVL(0IqhCW<a@VQfNL||OB68N@J>i2XsYnwDP-Zm6
zcaoz43)<=9|H5H#P-<ad`p5!Bn~T2W1CiN60`nJ+GLeypA7+>N>DA1Dsp}nf)q&&m
zxE!k`KWM~Fu4LR2J$~Zn!2IbW7k_&Q9aMryKTdq%Q_^|94~fotutuBVVj20sYbvyf
zT&ySB9}euJrk~$2@PKnNswGltzht2L=Ww~H(t6Im`Pv3$71`qPQ9D2%Bto_b>7IGL
z?%M>ecOWq`?lQsDIi+9sBU+Gq&_$IcAyeZiYl~q?R&nGf@ejefb!ikk@kobm14}HM
z7dW?*ZRZF3=`2JNJ<H>BGIl>*CY0uh#@)J-!<k62%+BzPc+-E;Je#S40B~{S=|i^^
z0T9O0e~CTpCx|0Z0jMzl1Z2FsfA{9#AUa1^5?XSpy_Y`M>v5snB{*BMEZb{8WY~B3
z#AP?)cFt~~mAAd`G_vC^pmz<~n9qUJV_BLz>M7_PVoh6o)296Q_jFAP_3Y{rPHuI{
z4nsd@@V9yEx$ZH-Bh1Gqv9c4XfQgfzV3K-)cl$1)D%rump|I4eT69_cl*us)P5YuV
zQ^UyEOm^1USrKj-vmQCVS|3BDQdb=$f`yQNd!Od5MrLPi)KZySSDl_)np+9`Pn2iN
zOENijCDk5P#>uk2@9$o2@&f=?*C3nDk0O?$3gs$$!TR)d{o@+In)L7(*ML2Qv`>E%
z=9c$E{XgmV*|tA7z03FGpeTxL;aWbj+amDYl0;<eIBv5Z!esfIe>2d4^~GC{kjMF2
zz~Mn+FJI{X7_zwwXb+uDY@VDagU+<;?;VPEYY`mLRInjy#&)fmWm9_hQaA|KKiw`h
zdkra{Tt>(WfBjsPHu|Le9Vw!ZLfxRSn`*+w8!w9W*JZ<jPQC^}(WjlCW=p`*6Z-?r
z6y2<2qdYWoDfI3mqHX6zq9d7Ml(_BR`KkciKVFLo%}r(kPH+@y%qMkP<ZmVR4F}!a
zpCw>sM>Y7~x{BPF0UO!|m#~8H^LeILyboJmfoau0UD3O+)X!^v)k0dqX0DQy5IC0s
zbI>3?-XMxx8WJUrFJ0O}jH^c0dUi_g1)&9f8eZh|6&wwhnoq%K%vUz0(4Rd`-%+e&
zN}KH=O&8`q%=tNtnBFImC;Y09c`}^u>o`LzX=#Y}TszsgE<HjAdHis5!!HnYIj3cM
zPz6}@mJ)jCapO^ZK0aBUR32}I4tt?u&B7lFhsh(+yJeMr^0h|(NwfA?cVSLXLiwAG
z|AqvTH4-u+oq8A1++o*1C^)<;NKm9d1g!KSY9)O5A)@~kB9hIZM~qE*G|fTbi1yX_
zQ~hx_oGEFQVE`KpjSWedRsa8$$J$Z91I6@jMs)m&3A)A{uJg{xck_GW&}ku^^ozOS
z^@kxHEp_Lp$FiM=xDbAV(l!;$34%3cP2FHTQM;a-X_kau4xXRPLjflo`>uYsZ*8i$
zS9CEU(PQL_pC+DZkRdQ)6i3NlS=`A@DDPXdrZ#Q0CQ$Jp(vO0Dm}xbUi&esDOV$sK
zpLh^WSn}}z6*y7C0U7{I*<M#Ck=Mr{+}Pe=FkymCcmNls+K+l?p;1u}q5mTOd+V~$
zTW$}~v$F%xX>GJ}btG}LJisRKdLrmf+S~iJg$Ad0q>R1Vhe^ModHSe>U-2nhf@hQb
ziNfg1@G|eRsDhd`agW)vg`5#pevTei3(Vr(hQp_2STDxgJEfzn836fi86*E^IXg@$
zQ@;zJv|0Tc?*~jH{b+WaS@8nDM8b0Eb2hsYh%=cz96N{Q|M2yQAa-LJj{VicgyG)c
z*+TGiqh5t*mhFs=tp%Z$zwm1Rx4ah5c&(21)3JZgIbPr__)PUq+ST`&zCf=<^-Dxc
zeelDV#NxWD!ZF`=$lTAt)@JZi<9OHa)`$GeyjHKy-~XE$@GdMX#ceuJ-;5LmOCXK|
zb3u^k*9RyVMQ)_eLe8g$zN3gn@qqM`zkG>Y5Lgz@-^XtfH$9nmSE!^{3JR&O5Y`bu
z1d;#pLDsZd2_pUesp_Mrhu#ERB`U=mAp@@=*i1YL>@?3OIUooM*E1%orBAtFK>E&O
z@F^7>Ny?PGeH}TOq};}_;JrBIQHJ`WyoV}tj#M~7W_M%O&lb7Kw(-`NuN$wsYwSR7
zgsNHyeqh1*&NEG>)x^MqGAL^W*$@N*hP>};nQXm_26{@hzGQ0A`?KGHMCy4L<0(Pt
z-<7&@eemZn;2EE!j4XXDbg;k9V+~#?ocM3+8NGucrMLf(Qo7S3-_K1l&ZM9wNe!0?
z#UG%;3_2_(FapP9__=#|uC?5vJ|au*!c#wT?~B${72|K^HvnwBu9#Gia^l|<;4SxV
zALIhR9Qi0Fm3x8$M@nABJPXC|elVJHgh((@&bF-jARw<Z>H0meW5t|;C0fU4yX)lf
zB|~4+tsnYm*}QA8*b{%kVH{7Ey*r5W6pWV&xR^=@LYKA;!w(=F3eIg!engMU77noh
z_U*K(bWWu=4vSpO3hPd~2m7egus;)^$(meVn*Q#;sFvOe%AR@)G@Ev$)=uIXxu~8b
zoA>G+V#+j}LU&?sK=NX~zJyz1^E-}JXctht0^Q~Ox|uO&OLSejOc*4y?<E)(<&mDE
zco)EvVZWTve*&&u7%tA%W{B$maVa&i=s$FKebdGh;_^>R1(BW)(;!c)lC80H)qOuo
zGo0m&^E(0~O*2D#KC%;ALho~{Fjk%%=dVUmBZb!_B>fb9ziEv8YXDSD6dO(7(qW;s
zd_VnLj!qaV4Gqn)FkKGXxk}y<R=;dKN<KosA83ZddsOFtG=J7d!kMI5zvOH=HDcAU
zANVk`@@_O2x$kqryrbgs+X`#)$ars?n$YYQWdGeMWh}QsQS$S+!192VH(<Z$YBbb`
zC1w=AN|aUE7=!OlJL~@Hv2uk5llOM*lU<UJpcSv`cRUnV*3WxB*b9f)#r4K$_axt#
zD9~dh${nrA)Noc_Z)}%#<Y!3?IVk=kRe~H0QP`9YWZL%k5Fhrn+d8t|6TH3uh-ima
zJ4p4c-&@f4xZ!}ce(qA5|1+1p4zGlrW60f^gcIv>7umac-?3MH+|6)v;8*NXu1%UC
z>0=uN85LJ3r|WE3fIoPDD%u*cw(I9v$ViJ>wCswPmzGKrVM}TZOVP=cHQA{<)J1h!
znjylRkmAv7zPkMaw^dz~l%OKMu1glUy-Iq+X=yfY#-vHVianAj$rF>N{6o-z<$Tq2
zWNqV`>eEtm7B~Y7VzfYd`wsaw?k)XG88$N`@o_qF5CEJe_6>;59aK7AbLQuTMIX0J
z=hyp);WRG=UbclLwfZvul3KcZG#6A&qFnz51V(3``N~`kSG^?Esf^-1Z$(?VMv1a%
z$O7%@mf&$cotR184M@_*3YR6ra5?ci^<+bzY44*$S$~^Mj<vhmJ%9HvuSzThHu~W7
z`%foj-IoJmooo-S^MAa%Z>lTF2hyZo-d^C8#_^SKE^#Gd&3lD)zb%2@F7MqaW4IMM
zPZP4*H^WOR-I@w`7ZA1@{I(if=N&>PZoBC-AY=3GPb^H$$8KxfFvOxS^iw%v5Afor
zznb`Tav;2G$=CtM4|DrQ_bg*i=Zy3%&ZEx)JxYDU#K~GNca*QVpjbkKV7!m`{p$?z
zU(4!$8{e<-*GdgbdEr`9Z?z*ym=q7;%S5Wd)DNXClLD#jD5@^0epD+gPH{59xsT#x
zD4k8K4CPhG4JaHQ<bxcBR!gf}Gk4uMtj{6inJ$vrsOcqQg%}JG!}4vrBse9vo#j+n
zF#4Sy=A5n)#c-p}&}`t@KIQ$Hg?KaN@T@cuHU}zjk1gywC+0-6Tku|f34=slQ&+YB
zgO*8G98_E&pK|akxdJQwHU|L3#f4<Zg~D`O@TI}t#j~B+ZY5Svs^9LPRtF!icN}}s
zob6dp$7RzXesW34e273;s>Vw6OSzT9r<A69b?O$a=d-INFQ1hzhnt_=lS{z)Kvg(z
z<`Lt1{@;Fr<;}&CBWgJt`Mm>2e&ks<z%z1v1bNBq4zp(emk*ZFznQE!5JQxl=Cgj3
zR94e(ly^VhIn68^^6xb(=`}vD-G&33zO7iZsxsC{mppQoGhHR0h`q;ieRS;XG{6!@
zq&D2n7=NT$FOY~~0<D}U#Lo6BcoIo%r2;n9*wNUr2D;1iz<XvWt^Nt|?t#P<&_fQz
z|JqvqV=B@Uwu7couP<10cm;AfDD-@E7h%Kth@Kkz`8Wu}z1dhn#>%|>lv|y*1v}!Q
zGrhRwW>icHc;>bC*XTXuEl9cZQhsJUiL04iPQ;{l6h^2LythInf6Y8am_5%oBsmhO
zYQO}&jg@w=$=ec5t2e8eB#x&;&I*4PF)zK=J*BQvHdCKAy2AZjw_<ge0wY|J=41SE
z)ia|7)nxlr9R<AK!_(`}2=B;3sD@nmq@;{J_$PBVokn8u*75v><Dim*3O-(@-W{z2
z-P0CV2U@FsMlUJ;{aOFrJ)~{KlpbTr1tKT%-Wwg0CA{+K8{*LLbKW89pB^_6N8k3|
zdGiw1+U;4UT(927+8XB)Qhfg2BXpy+2DkormTQMHle~76T7o(gC~)xE%4N8#%ZHxr
zWG5DsQ!^gPW@qP5bsVrQTyI(SZgsH2p<}h7aot~QEh80^W8o#<|AZs-&i$Qqsp!zu
z5Dc9<7v@q<#Ez+tV$i6YEP(+m0&UM#RIiYZjq6b3%6UBypu0_p?^PA;GB3dS(NPO_
zk39b+^kG39PiQLcZ|1xotcpk7{7z^`0(*j4b4KXcUSJ*s1CgslPT7(!MqH*k@A`9J
zmmO^*y)Mt`mV`9BX(0&S>^4;6oG&;YI!yw{4R)x<ihw7!Fau2OHo0a^nmVPY_-cCx
z(S1*)t2+&emRy5&6ZsduZQ|vo;?SQX)51rf7tpjZ`jQ2MQHRE1kRLiRMGP`K=zW}F
zNWe59+Yx=Zx+IJ>jR&ALsN<|MoCKJE+`@Oo`-c{YBG|qS?Hx|77FwYMI24<i9K-^e
z(wtrV#e9U1&>`%wk}q2UUm~mhC~(R!pU~W-CFfk7v3?>%9;trxK*gh+Gt>omoN$Tz
zw__I?K&brKT5pWfK)XEyeMD+G2l!1c2O4|J*Gr@=&;B6!)~dc(ppyN%ckq*UNxphj
zS*0_k84TafWA2wZr{1OXM3rN&8y1~*3@1SutRy}--JMT0-w>B8d`r`@th4$dSQ09}
z7_ToTEk{t=gn;dzmi*9UzXnAjibjKOpxw4?eK!!+=BSc`m%WZRMEuBhkHe0r>&k5S
zrV;{(jsxg)4|VN~#;U<y4A*}{nKT&etVN6=R>imnP6K=&oWnXwRVw7z;d~JzjM7vz
zsJtgO6_I|ZL{I@D%>&7DJS>eL8|=q!us>MsyKvl}MmsnN4FkJQd5PXAjliCGuFWW@
zd%zSzh277=^UumJ!F6dkv>M!&k{tVH76Henv%=3^0n}-(U_r8Z)g%P@@M)K9I|Pk`
z%4ePQdhl3Go`Ib*w6ZzQ5IMl!b$XTsnPZ^Pfv4m;@>a?I%PrEz0God5p;TcUfXh!k
z9$-?<hE|DDy>=ee8nq`TB^4&xKL6R{$`RbW(AV4iHrjXRQ7+EDlBtOi&4eS4NrIq+
zuHH`l4V3WYa&t3&nVzoS7>To;V{vH5h9r!feM(yVT_j0O8=Qd*bIhKU20zD8w71^}
zUF!4uD4+>Crr%EDMVPYNFo7jjb8a(*=_|-S=4Q|iF%?O>z0|(K0$|f?z^by`YawoE
zg>pDvBXn3hjCZX5qPTFZ#uvTgNjU&VmOP(}a=(>`_}t{Ezx-;kW9pvK_-Vh+=cQ|9
z8-D#EusEdc?Dcf?1P|Hp4(=-m%1i`3AgASU)g^&RWC;JeW#TOpAwT^d`XJAQ4?W(4
z5pXWl_-si0(CXx5-sD83M>xK}VuN_4s8QfZysBIVvZo|+QNywQ2F87xEB-W<8TqW7
zifmWiY#l?BXdLCI6abX1YwGlz0}0r~2A7iswis)bT_GLMP;R>&vyU_sik1wNA4kC!
zQJF-M8uw+I2E0vb{Nfo!w_`wo$NB7>MktkKZ3U?ETo<L&TfyG{Oo^&Sgdo{rbh8XW
z<z=a)Qfa6e4Ju7$C-0L-*ZjPVkCjc<KmsOmGdy=Q1c{9NyvQ96;{cq8YiW#p`G+F&
z&zTbih8o~Le-dk&uZ#j?)7xtFf#vYAt>h#m3DYu)RpjHx6O;Qz<(c^mbd`&kg{(Q)
z(VN<{nBm?Z+UA{p_H)rKe|qV@Kis#I;n_YaZQey>_Lmp1T39iZ`xOe;D+w|m<o0N@
zCle4IL`|GLTl(5?v~bZya7>~boM-RMdiyOgb&+w{#7(|S=DrWH!)E#H`IWH0DROLa
z=VVEGjoCSwffZYndc({vFH=CbWZZq`g6+oc;DSOWJq{LM_+ahc|F@Enr5ZYYm9DCD
zWSh&{S8Q}|W#x|j6s93~01^wmLt1|c@7GQKHSeTBIzQ&(Zyvlfthk&?ro|(bgpQeD
zSlx@Y9PHNd{lVX9R0Kdc5FFukr$(RlBdw(R)J5;gkD<q0@USaT!hbL|?5!`?gP#&B
zXExr={E8-XvFa_WVcWDMV%B-c?k-~`0$Ym0K7s(*QFX)n-Tg#Er=`x_FMxZz0JL6x
zpp66>bi^aj#o*#HzO>zxB8594W{f0&0=ABi|Lq97M@9%-&o<F8gbtlTJe|G~=t}7?
z$XX<IJT40sTf5g1`O&QydFVOi@&)hAe!at?;3f|_#{;orH$I@C^;7y5cMx7<J)TI2
zyS=w;30fAVAESQ@Xl@MQH8m3Deh1(wEXeKB38mEbHhg`Z?=9kefC{-@U;f~Kec~iw
zM}Qc`SHc8R>9+r|Z$WdUR!0Q%&$gXf$3&EXHi}ODkHmu(f!aql2XA_jRFP6_<lFvE
zh3LnVF!<j6@lB*R0YSH!bkDXX9R<oTn0EUE7Im_Ws9hwuE|fVRPV4MYvtEEAr=I&n
zr3m;)LOWyjQnEP{9i#B__E9wM+x7-g5R>97xoe%KH}z%*I8T2T0oM>boO6<wG#PN4
zu|`&0N#>tyEbTYy@HaZtTV{v!j?fPK7XK^%=c8ASd*Dl*0wfnCG;>N~2<u94MgI5f
zn(s&8<q}PyAJ#1n!vp%3izA<6o*?IH_-~-h4My3-J3}&+&(R*#WGc}n!w3^>4sUT8
zz{ZP%KLYKOCqi_{&VBOtdp~SlEro|pYSAD>MC3lZT3Nai9!J)}yF7?><0yMaMy$I}
zj<OR-Vj8WkP#$;K@qEHlBlcRXe}&@|VpDkhV4|x)zD&W9iZEI?Xoftd3^5ZMw78XN
zw$gIkv=Cj}&bp2u<k0bTd3oHCaR5dmqUudO9j<#HNm6`ltL;o|6JN64-}Kn;O0Fxq
zI!QZ4l<9t<O~;Ig=-$#YJOitPpy?M_nt(U#N308Y79<DZ0|3VGBg5Y?eH4w8wSRk4
zfhjy>#pu;ayZtb7O{NC1mPtakJdK<vUfUg)3@EQW)9Ze2q=5CC{a6kH2y=K5pzRIm
z7@_|Xe{s+pS`K~ibz0`BVw$fkt~M{1S5ZL06g+WCN0fv+82>I(9}C>LR98+I7489B
z^v8zP@4O?{B++#-_7nbHQu!gtNBn9A@<&TK|5XIwU1hY$x+Gr0VMm?yl1OoO5}h2F
zI^+i(?<Nr0PzM3x$;;O*-kwAvq)**rx!=HkL9`Pb>~3hn)KpSo;tGFIeR@1E1@-iF
zsI@pk;-z;QO#wa2gHvd&k6OUS<izB<zk`LBRM-2pmt~x1b<iXa)E?{us&QKXFSTL6
z)m>e7JrIFErG$S%z^|vz12h3>if=C6l7L+X{P|0MPA?S*i#)+E9ZK*ckHf=bPhrI}
z6lsUbci#wh?~%0|l;F7YXHC*UCo2sPw$Ob8b(#$~1oH#|kTCZ&Qd!fc4a?W|F&H>a
zsL+CrWwr;XfdGb<hMEDTPc$I(c&HPevzY-b1(x|Q1x5mFmI#ewUPcBdv*pl*n^EQd
zEk!IdlPqck?`-NC`C7B%Im9=SX}8>87J#QI(`h3F!_4N)9HzY#BS#tpe(gVsSC3GC
zppNCodidbW_GGlzYj4zzNeAyeK1Ao^JUz48Jen(|hL|;CM9mjm!MmvWv1jMqMVL=g
zuB@lG;rXVHh(}qR*Z|pWo0;A?g!ZT#l?=YSKpU`F2do&c?HckVbY68StOb9i^Tug6
z7?`<E&i>L0n?;mesHnHkW1599vT*+|)dKum6aD!!)|bGjs3?MlFH4m%f5PGmW$$R9
z3N};7%xZqkx6`$#DL{!R<ec@XlHMmf7jOM%QRI4%n}iM7@yg!8aOP3|InbdC3-de5
z$yM_j%!dAn-LdiJYBT8Q>|$rnJ>^*LCV5`f*Df)A_a0_5-yr6zcrN?XZt1QcxluCO
zfq}bXIq%kL?zS{w0~|Oxh7CLr^xN*Q^|<5oHrjBfG)d!GnEQVuU1dPiZx=;D0VxqF
zVRT5B(kUpClTbjqLAn_=X%J+<=<ZOuJEf7%(bCO;5hM1F|NET}KlVJ&x%ZxX?>Vr&
z4MEo(w_e9W#A{zd@AE>(Uxiw?dm@e}$?`;X^-s|_17m*ez7p@YHVTk7lp-)MAh#d2
z3Of~Kbnl?gaUYi-v4h=psO{p$*`qWF{Sh`Z^>=wu;E!vn7w=cs-|la}?i;|50>`%Q
zZQU$T{rT}@KJve|=#I;d2b%B^xWer`{f8w?qm|NuT+N$oO*DI5C8U@+Wc_1Oy&DTh
zG2?A=A_B`+ulZ5N(iQcA@4-E9&=TQ%^-}m&46P(nej~kvxk)T_@Mz#PL1&JF7X)`U
z<jA=rHX+i%N<0s;bXQ^bu52E7_aP_7jTP3RW0z@g7q>R~h*gDuc!IXe@VqXuLkV?8
zS+Ty{+`&XweionEP}DfyN@D_cmAya!_WhonRP}Q2>6+R$?l2nq7p71h-;}l3FfgbJ
z0jA_X?#uq1t&Kv7%PoIuP`ieWp{3Z)D_NW97dF2q>&9xT@lF1}b0x0J!E?Q~b3USy
zh{Xottv;>83ezNk1FFUS`zHct%YzDO4Y5-nZ|wT`^e|RjI^6&_N(l^{QaWg_*M1cr
z0!DdT-P0v}O)eQP`~@VhEaonmu~iQ43JR6U@8OMqHGafb6c4((y0}PZT=O*?X(W2-
zX8G<p&3ZW4*|WQ6?DPg0+~>wd&$_Yj()PB8!>N5f$f(Bi0k_!M>s~(4d`6zDP2T_h
zh~w`b?*eDH37jRajh;D8D*Qf+{L3*UlV>)(ArJQkG~*xHiN~1dh*|5HBUz8Y_+Rv#
zZ{#vYFc{3vKYDw&%bBk?5%3Bmh1a?9*4A-tat$$@s$?9Kx8CK2??+3!c^I#|71Skx
zT-}c+7vH3xR~JGCWq6JaE_ao_&vv`~B}t1<TpZ6(Jv|Q!6Gjm2b(`Oi&0J;bJV@Jk
z`Wm?WoX<UqQ%CELJ@jxfV`}B?!LQ3Q?PeK!5gGT7A#22bRBPRIx)D^YffoX6_s{j?
zNH6W(pPw1~;Er6&|K{F26U+gZP@7+mmWyTb%(2Z>i+v$P;YA<dY`z1NCH})oj*3qW
z4ZaOCIb>1s11`2dO-Og<#rOXRAWkMFc!X4w4SLsz-WWC9(&V9!lE|>M(F0v~(Q-i>
zFMl<|S~ChyJyTBQ`28*!OU2I-ObOU0i3?-lUXh#cjO_j_%=FX+&t0lhiD4J3_#j<J
zkOh;z(X)vpKnHbw*>7NrGnz;rAo8C%2A4$RxkEbvuv{k*nOc{M+C@Gyj^4(-^S;R!
z>-g<=_A^&JV<V=0<G5{!TWgG8VR`Q&xNRVTuU083r4W-y&l}RNraQNu36aXi9Q1`k
z_LHemkhj1tLXrKVhh!%HzgxK$b><N8_EL(b>=y7Z=;gLLcvZVe&UVh0t*bhoL)8Kg
znt{h2vx`fqH$gf1no4G&A5(8a4aP~ISwWwHH;-dG-vYg+5})^!ux5>84n24zJ7>TB
zzT!|dVs)A0D0cG)Ny$`dK>9E2<bvROX#cqHvaZPIQEjE(QIR_OJh7S~J;66-;=AjA
z0_q{qx<FHL(OQM4O9^Y{4W1=P3?&X2DfCy4&osE$FU*Jb?jlh+*=G{^(?-h8x*78s
zC^<b}FH*p$S?{CHZqJwJ<~i@wbknXo>pSXHXkP{5`Jq<U!f$9oOB~);>)kMgF5^<1
z*~?-ej2Zr28aR2RdSpXT%7Q81_+>4;Zl&ti8WX;2Ie7Ni%H3%L-#_Vo(tdf2Hk>1p
z*bU`Xp)PUt<<FvXz*j`}1VwI&-?yCoS*!4~M^Q-7ZMGgU9#bFswym9M)qrDzq#N(K
zbltutNGabw6w;PHCw*T>FI=USo*%XBBwTFKv+w9FB@-CS<FC5e*JX-YTts*-T}p37
zn2gbhNAE8+ff(RjlY}<2UB`YK%e(+_ugmU}*7mCpFc(_Ro8}KuVg^B8YMVRzsb*&)
zw4lBns^GEqAA)S3+9j%YS)o36Q1L_ZyX)CC_=)=QV_K9&0}GrQM?ms^fbyiE-4A%9
ztHzi5uq{c7uXT4u1Y;&99^SXgVg2UnwYBrZo)_S-g$^D`AHhC<Mw8f3o7S8Dk^8AQ
z$$x8l{Z<kqbs>P3&;LFY5si57l!)?MUUAcddYS>EMqg?8zY4S+#L2=C#}OVYm57So
z+QSz8ZvX2Z%06Y6gOJWp>@N0T6%0d>g8EincbVlojr+6TcVs`sI$WihF8@I?X1RtO
zpNKsks<LM?f!%%zMU(Fiw08{5OT7AUc!ZB%-!G}T`0Z@wHyqq;xx4My$~D3CT-`Zs
zCs-1n1r7wew|1|1SW_NFQlrk9wi<s*rR)rRc;B-njX>wTygq1ar-H?hpot*kM#e@e
z`As|Mt1=~-I*fzkyu`U@)iTklhc9X;_&~|a>N@dkRza4VUG9H{Krj0O>_hDDU<e7X
zKotxSfWy1gnO8U5)!hKT8#9XWHPCDJy-;`H-=A1qI^o|$(um{&ud=F0<L-1&>bq}b
zoDGQZSb;*VMaZs6qSXGO1#G1B;AhnBoxN^f2~ShYohOQ|R=2qPk=^^NZ^9MuMaUyN
z*((I<qOpcBZHP?T<rY{Aam~2oNNx)jxo`ITGQ!y!FimS=bPE;oDd+{g?@`Wr=oAw%
z5E<IA>>YePHdYD0)h?GCv;LmxLSvpD*tw8&Yv0OpF=EQVBNjDDGPJ10?JJ&F7<Y8y
z66H?<KGmd%P`bYmJ5+}#bSwmvTfQv<hL|qj|LbM+8IF{!D#*v(m~JnGcTJpPF$Ct{
zo5wR|hz;a+{Ma7=4%uIL5AZ)U+_o;iQ!*}NeMKqDoh57)6l=09uXyUtX%=&0w&F9a
zV*g}XHCvelue;bSxfm1P^feNKW!Bduucg|bUD((gusoVp(SBTw7VkFnc|FQhh1^K&
zl|swt{lhORnwxq+tFFNQiR<=DX2t@r=*|q%9qz+Vnd0c#7CYP-{*jqNzzNrzfC_mq
zXzteWNa7KXJz7$Csj?!hfeAamiPrEb;c0B^&LIz_$_dMpm{WNz@x|w-@?Rm>8ox6?
z(qfrBss1=XF{U2Yqf{TNPgT`=_DIPn(Y(2{4EsPZH!pQPp?nEr7QFTYZL@s$<$i=I
z${M!){x89#w%)nriqQggfg+7VD)ndRh4JI1tg*@TFR;fnC;|U}SG2FSI&=tdGmpfG
zNJ#~PACez&`)hOqWLj!mPGlgOLg<jv&xPV5RFza#vZSrJ8aQLNdk{YM)?j#Y;q8>^
zI5Aw;I1N&oNtV~(=WTucs5E9-5Bk>5`y-9+>CB7l{B_G&yYH4S8wt$kEZ~BreST`D
zticCWwhB~ro&plz3iDaD>Xd*q{=3;5p<DFD2Rt_7<IqJq{n5n0$kWNkk-Nv|Q$hAK
z=mVJcK;2Ru{+xYBg93SD;v@Xwk{4_6_P!YJ&uCyQk$E8cY0#L_Q`-0K&DC45MxNzP
zx=8`Ohmuk1`-L~q)l?Q(`3>?S=03inu~J^PYhb@g9+6f{cj|k$T^1B-v4a-_H8Od;
zJO}C~54joEv_4rY7kjFDTdct{C<}Zyf@<X%%I9O`&Fn?d3Ce<44wXnrQ=hqc#Qk^%
z*)(h_NN3XJm49KVOR+Wq>yD=JZNR$*8PFD*TW;gr14I+WhLdUd<Qw%27Y|iR7(Z_Y
znAzZ8fNDWq_-|$QkTRdK*^DpG7OO`)?`D?-y!u|gqwB0O>$k=>>AaqX`Iq2-kO+6N
zZyuF1+eNz#&`K&v#uMEQV}EKjL{=Wx2+7*e`l(OpexJnlMf)cBmilJQ*-J(xOtkz<
z9HB<66=Hm4aXBpH7P#RA1D~t?G_{a_tz>;$-gcK=XE-*(W-5gxd*|C;u(IOPv$VVa
z8_)Ju*N)qEc6Kalg?9MQRbk-^>~ufvyYIjrGWiF<^7OgzMUAOOYR}yW+VYRTQ|bS1
z)J8Y^VIR@j8$=U09b~IwveY)1v_)g1u70|n(J{<|fvT9JQyTIAn_ba9+*H!}MTH5c
z<{mk`;yWqVO!^#`iKsASZ0P)tbHd(-P*Rq2jH>tqh6BH;<ukv;CtqK<3~4!7C0gf0
zM!z2e0bR4Wl@1VxFYP*DqcwVg72e<r7pX%`G!O3Q9$49M)}_1lul+{Vg6GwCaVD!N
zD*&}{+$MWtW*K`gO$*8~|8hBYe~RaND=+eeBH+#-=&hgexAn|kINvb^%3kJuPr-lF
ztYa!aGJRK8WK$l|H3Gd@14fn@SQ^_(34^?gl`M%#B#MQTU=dzjw)++sX};UMm5%*5
zpDn;2x8{NJRdtz3VNi1TM0@M=44oU-&V&qP=%XB?JaXq`U3iuj4a^=cw36^EdNx&j
z;Jn%2VOQv>mn{Yi3s-w(+i8a=1y!H<ZpE_(?&x<YBuNxN|4Ilm@JW*6?c|YwrQZp<
zcao%k4J7X_{i`y99w5{{z{K1`8tBo8-0v3uNkwffAuuILbzeRZD$?@eBR40FY+0k#
zZ-Uy+6Y8I9YAbx`v|$prg2IIJEJYC*5~q!<m54Cl2P3QG{%aL)34~*tkJZbys=XJ;
zL(T!FW^08mJfN8C2)9=DJup+ZeLZI(Z#LD`_J%0Wh0&9?Ronwso-RQw!|>Se{y2RB
zyuLaGTA@g)SecBdEc9JH2zMBS6^doHf9s4wnapWlV`$Kzuv<@gg*Uf>=nYS<|DY%9
ztjqunSeybueB@}K>b&B;G;6VfKt8Wp%UI)Ia%nKzDMCOmNtku+CqkIoW^f@bj5|B2
z)Ig8{M#Kfi__E{*mTw7fAY2kxZ3N3+4+LC%7xh|$zd!khYv}nB%SY7I?P;&nyx)}w
zPk@3nPmtj?F!7~%R4+9El}atKjw;z|(lBf(n^S*4^v6woUFSG$Z)CBy6-AFG5TZs+
ztkWM-h^s%XsX5hj1DRgO4xOu!3q2kb)Q;j=5L6;E`<ytN3?Lr~@5n$jL!~BIc^C{?
z%gndeMzpvrdj9=>?Aex7@O)(5^NyIFwfu-i{&4ANwl)8wNX!v7RafgT`ejI|XN^c3
z@LcD+bE^zr##`Zi$S$+QQlBP4F>=`pj<-5jpDE1e&&+fG9(=)d{0O)nOGK|TV<x{m
zYiV&i>9uaU;>4i*xG7m2vhtC$0$v_r`?JvXV78~;Umc#ej^@{GQubBf_ayvxy9wG5
zYc2}|Eu%^>6g>P5al?xNjcY(E`$njWEdwvE#gQy!cOCvQc3Qz?g`g(1I@;?de*uW*
z&YZ?e9hbJt6q^^$VY~RRX7ax;d!`c(x9oC`DlNkSDOKZD@#%?&Fu!0Y7KtrQKL#gA
ziD%v&-E#>p&x0fRyX7g^mk$<3JGoq&e!L*VeKV(}h!l6JJ50-ZA$I60p%?C%0}pll
z7fAhc7UVj96lx?F#h-*VWl+OuKf#6XVzae%Ro}g72k}i$`!nL>qp_09Gw?;z*8YK!
z9bXkVzU#BMe3>MXBuR>P2x~FFW*xs;Qm1?Dhr}L9@kFbmCgP#abq^C?hkp7MsK5(F
z$T9iAj~43NYwE6^MATV}cQ4c|oT0bO?m|+35~yVQ{$gIH@^X+4sbF5X4ReVKF@04I
z&l6%05(1XNn5lP{Ex*pabd&yb6qhMwms8~?cgtbt&HV>1^;y}ZUR7x}Z5B14yRVc&
zn))!T%<1{u|9bf5p3mFw+fhnqwk1EuuwwUF1TVs;ZDs!3!rSnBNnOS510hj@Qk}(E
zs95ihJ~_GF;NoJ>!ZHW(f3xuhuKT8RixxCQgCBlV&ol<NHL)Rhg#I-Ev5U@q52v)q
z6KJTdu@g5ZCy!preJY&jePhv%q%!<o_(cMDOaI5)FP`n@g7J0Zsm1UW?rP*1)k2{-
zH14=d>V{0*b@DE`C7Aa<cR+Pn`sKoxT!%FBE^D?aJ`!&FUqwmWdwpK)Wa3{?j--pA
zHM@g=5(^FqQ2a-1$hLrl6pw0FFaFk5rfHqXLWWU&V8%diJZmmp{V|IXXUWfy^dI#b
z>Yitpi@n>cN3@IMPY*%pQ5=<Vq>UHfX$FVZ8=#ONe`E9>-4vU&RQLfSU(-N|%Ws0(
zmTcba$@wPFv^ru}(eIJN5%;@;*ZRfBl%k$s%;XT*P9*AHRNJechL=<voVwkOMk;(7
z``#niXP{#GD_=XiHtKJ2YMDUZd!dpQj7x*c#~0r4s&U%FZ$q=^Yd;An3;DTg;D%Fg
zH7~Q=L|Mqa`lKXe#8#&Qb+M(<8Tx}!1s=`i8<Gv*+2u(Z`Qt?S`nKwu?w3}%ma)$C
z?Qe~}B;ehwiUp>-eEt8H8F0K$UV&Qg!Y%XOEEZG{IoV{?^Zn^t;q&U?7V~)B%PS?2
z+sX0R3Y+LFOAVS!>13j-a`_{|^9|v;EN8jHnws|7hE60WQgusqy@4pZ)%7ml-F1nN
zl}O+587<y&rs(DbAqU>RZfsh!=VGGJ5P7$T(MNg6jp6l>We4uDr1cwmF8b%6PhXX{
z`F>um$3w6z%uw2io~>shd0Xo%fRm8=1rTxM6NL8*rS<O>W4&N*&K-|oNu#DsZD($R
zf^0bIAY>a>-bv#)h?k8PEPR;td;+0D-F@}^cmMXe#p7+(t;On{1F6{<K@M(Z!I9vB
zBD}K{ZAl&}FRNHv;!MDq%g~1~^Swk&o#YqI0aY}H1$sn@Pl~y<eZNP%<ciJKcHq3*
zTli8dq$u~11))AZ!c;0>NiPFgzALI?t7~|jy6z4aeC}p4D}*Yak{qdY8SgX8WUGsq
z=yRYpNy+MdwB!EKT5kgK0rW@?^(1#?2pJ8^Kg5u4xqpB1%TNr@J$<cp>eAX_j9T3D
z43lo}?_PwCp8Ym@+)oO2#n^yoNnMZ>A0WZ-`X+t+bP>GNI&AToMnHUCDiJ-`t!zL)
zdF&QUrR%6HNg>!n2DzSHtS|6A6<lc#(dG00Zx_E$#juHHMyf3eq{8&9vpbBW3qN4~
zUxDo$eo>~TTTw*6zg`>edmsq?CvD9Cys2wv<uc?RgY>MI_*6=2BxqZQh1U;FI#==S
zD!iWY$Fw9@EetvDM&+iBJfj&TpB#72X<eN%6b2AV?BjUe&**j*VC>TI+}zEs*ibxr
zzp!z=MTxpJT$mRg;QyT;dbHeDq%4<~@XgJgD-ABiymPTR++27(@g-(Ti-TPd8_l3;
zk7dcvYwbYH%nWEb?6DS^(1i0_gK?G)*Zn^~6@eSqb-mD!Nv`R_{&nrS>B3~#{L3}I
zYC7dI_GTH*dQ6opznucF3kf#|hRL6fQq-;ZhPp?zCElJ76>R9_U1T$}n##z<U--0b
z4>mKZrGHHpyt@MLY}tbbnC?6aeceMaReg<b%4C;43XT3m8lOd?)Nl(vFLDbkodA(F
zIXNc3&><JS;BPS4vfi~YZ3@Jg)HmS-^bbIp<ue0Cx0;Zrx@*j>2~i3gQ3SJI&%BmC
zQDPi44MS+Z-qVRU{Ug@)I-$|<3jfhB4C)<_Rpl|2sE5nb>AU6E0bKM3_n$_U3SaDp
zz)X~v_FOo3s2JPh3cXJq&r=~bEi2_|{4v@2vMaYIS}=3DjZGRnhWqd$d#q;VXj%t<
zI4zQos}OWQvu-a~)P8&!YtA^>XBY6Oxqze$@$!6R_3F6ZxPPn7U1=S)wxHFWT`pqc
z+N`OmOzIZV_2bFU)OL49y?aPvuZtfW;VRFy%MLFGQO8Ly6`_}4_a}a&*@b^19&1JR
zXdRy@rfd4%i8|nNUPiYKa2Z7cd%L31gRTJs_9Z>uiZ|T)q5DC_PCQ?`8tSMRP1zBW
zr0GqDx=n74io1&FI%Y#ezLU6I>Q$Z28w7yGO4(qc1{dV5AQUsA0bZ*KH&bu+JCilE
z2EXl{I^06j5b%Q8+oSzds<44N-rKFvcGzMG{&Dyy;%_0GNMjh2agx>tmVNls44n?k
zp_6`2tHmpa*=~|cspWJEfx>DFb239S?&!WVW}K)Yr(T|jY8IaK<wtRrqTl(O|2Z+I
zF3?$4lThGL3EVuML)h@iBt(VvE5br5uJiM8G~i!jES*px8;2`iz4g12KGpVt72Sx+
z&lEU3wV}yN^M?~2+%UxfqqY7?7aau<m<scy4rytRB(g6mcybxF*ZaHqIIcAm_*O_}
z<$CgLb>__8e_K$TynEMN<SSn5Xyv-$aK0<HkdP&C@zOKZP&&RF5gGoM@4mQw{Dv@_
zDC!Z{q{u-DqfxiU5?KhI)9t0cz;z|ngqD?!mty61jCU<ii=ADN^g&uh2HlLisUJy=
zBQ^#b#XR?w*&d7h%P_BJFgAT?td+6YsIodKE7QJwN#SMo?0O9NTJg0?wCGPME9luN
za^=XJi*s&LYwIZRbzj^1Rf4Aqxm3%^#f;dppXee}Pl?0JoA4^3pdKIIvPfoUhV$Zk
zfhj_qO}~j*9&IXh122V({@#5RA->6;zlO}mmv8_6oE8wQ46rXAm?!ay#7#tX=a+i4
z3ba-)-98^Bqd{r5Y2Cq+51oq@q=9G|tb^$spLcCDTA~@<>r#^g3-mA+x4zLi8vrLy
zZ4VV{gX@!8W$}Ng_5`FZg;+-6?N&PkITEWDa#e+Q7UK2MgFWJT%u+P5@u9r-L_kh6
zzQpHb2i9i|#L%*&w{{E3A6JiF$IO`3H!eBhwLYf$$0ID*j-BcEQMMPDlvJeSc~XG=
z^_^ee`}*Iaf`f6D&j|yswZ&w1oFh(UWq{d+*;Q)iN*|q)K~4H*AZvwwyi`$^e-Z;<
z4`1}(+yz2>>r40X=d}as^b6l<?iTF9Mh&_*z5&py(vvT6_WGc!=ti&MWuuLH2ikQ-
z^lQ{O+Z=3_`B;K7N_^W2&Ck4ifR@exmU{=kE1TzO^o!Xa$0k32B$?EGrv&vMG#oZf
zyZr02+zCxH{DuGi8pd4~dM5SeyyChguMooi^a(uh6|C3RnKQ6nx4$WA=12QkP<Xg9
zZcUl+^V3kyDvFoCe;ge0G&v{X8?3AaB@!8ZH~e(7<Ia1fDlA_(EW-woHgI5A#%|w>
zwl2LS%%WP|G;A(rhIrXNTGt=h!E^PT@HT{%No8UUwR>sY+=mX~tQ}CHTp2-nXJ(c!
zN?Ls0d&{0h8Y-=@N>$@+jb4$PXzMf_ipMznSt6~&#}*_n$|!d)(cTvixutfrWhBk!
zi>kg!J34&Tq%X1IMmS+Ie*BJuB{}MX#VWQMVj`90TaWVkx*5-i*bcpO#GyELjd!tV
zZ(c!?A?C-z^xz7){=T_c?(px6)}jowz~xlCX8?c8d6$rI4~%I*jKeRb?OGG3=O0gd
zZy1-XR1`I>cjtv9&ugzHEEzJY9d3d7KAMG^ZRl)MM6K;w_#T1bRFe7gl~nYe5ek~n
z`8$=B7fm)jXgiZ}T2*<WZ%4Kd<q`MzZug5Be2LvR!<NCPC2^8sQ6X1OqC-%tDhXmg
z&M<0sC1!~U?rV_E!GKWYat&s+80ZfqHJh28+CLhKecHK6<i4LQ&p6duR-W8KO@8$6
z*;1&x&^(Iy#$%(I9w2adom=@qsC9R%$58?A{M?21t#1xYD5385Y6X>dx3<}SG8pa=
zl6_ig=eK{A`SMG%dtdq8n210X*6*BvhsCug5y1QN_A7`%P{a|1a%_U(;C1klIsc{{
zSuEksk1jP8Pjz=i+cbFz@t@4you4T4jD4L$x;I-ySu!O<hGznSQl8LgI0i%VhP6JZ
z=ZAadzT99b_SqZ>p;7s0PfQiYsr%^Jr0InOWU-o=teK`_pM{YEaNTCH0maPak+#M+
z)&;t*^M1}zw3)EHxhkxq=RwOpCk$R5N{M9J8Ef~Uo=>P$rf1a2`A%lGHgYQ!C#j(;
zqDngWjy|L-5q!6jZPMmXJpWj9^a`FD8HxRz`1qa%4u+`gaBWj?Yte=|k|gJnzuJZL
zUlwqq%r?Be=mO+21{E%0_xGq<1MkT<3w-gX#6><ex0Y*0Uh8H!u1ms4=}-w!ana6$
zrw`tXdLfcYq7+<3d%4cK{(oapq#w7(FLMA%38wvyV_5QW)|gPfaT2Xfj6s@`i~cnp
z-bdB)wp-snmEhg;1In>!dh4I=cL5dzhchuPi2hb?EI!e(*AIz3yNcGbqv0Qs`2z_P
z0kK<)V1Z0BZKJHqU67=@=hhp*ep4L}t08HFNqv}abFp&GCV<$1!BOM7YDZIM<0fU)
z>$DV5gmKy<72StXymB7J+<(I#f9<A0_v_pqXI^XpZJprg(_5a&cTE<eDcSC#2te`c
zPvkF8I)dDvtytXHt@hn-{7prqsPVO<yL&wWf1ZGSWNxy_$4ChAaLBhXD!Ipt-?o}`
znemLNyvqQE2s<(LPN+D)cDr)Kaq>|LjJ<t+Je9jBOx)z$DEdBH;t5R(osJVmCzIuF
zL8qre856ddzH|jq-jaUBFEOI8Ax=~KkZ-dqBTvWrbaxmz;hu+2iGg{d-}@0;Omn_g
z145uS2cIm*Zn}lemibQ`KsmVkOyHo91Q)62QmCO2bB@>Hc3C=N9lZZuw|hX!*ZHRE
zAa665>Zj;^X<JXQ{}M|3MU%lNTJ$0X?*A`IV<t)undg>-f6iCI8*J;$Mf_|Bm!}7@
zE6}f!L4jm#dUvm8Ag)9N6pEWsw4BGqyogE~Ha>{|yUlz&<8&-ec=4@0R!c(PR9Xl}
z$QQw)eLuZ9|Mwm7hZ~$@HYti%iNTUGa)|y}T3qP&LC1M1Jweu96kJ6r-Bst$B`lv!
zs${+0OqWe{VPSQ%{mNO`ETm4lRD13}^!87{@Hrxv)XLy|^FcMPprp89k|bPJAXb}b
zZz}Z>kl#t?0x@r$emO75;-maEqF+a_QvCeIb`><SmgnyC#~|jnOR-Sw=8hLKk14jt
zYmg*X1vVS|kCr|GP$LTUygo0vub_An1fuoUkC!G@g-mW~FQWzq<qt3N4R6#h`M&{B
zAQ)dAlGh7)9@XwE@2gO40`t5NeT6O$A3r7zZT5525}%#@Mnlux^=P5?ap%?nD2rnc
zhd-aYI2X@ZT@qIJwY{}qS9)T7SQEgiu7ljFRdeKJ*I31CQuzmU68hA)_(gx^Yx{ox
zT)GM^{V09wpPPUl9_^E5r&mH7h==F*Xz{dE*XXbtNZR-PC{$FOnk3C(ZdveAGs=?o
zmHNdC_~PZ2uQ6xc0!U2TeS%*bbgg(jo~k2!U+jZkc*OGtw6cnW_qV&BXSDx4Gp@&U
z-)~u)5I0r=px7lgHvR0^T}~E5wpsRcNlD56lapJk0ynfUlRScN<~oL(kI*A$%{4~M
znni{nCH<{g)rcQz5kx|7-c$DCuie@*&s04|eSF_`1jwPNLCDQ77kn6q&Uo3i>HJkt
zFOcsuJ;=%MP+{`7@V#?dp!D-f<~46Xqvg%J?F{)t+%rJudTS1S-Z_JdwtXzZcvXLF
zryldKov$2oZ=;j9LaI%FE7whC4Q<Omaznm(vXGzkSNpWcr{ax!13FUoyPFFF;KRsq
zq3|VygUA%zp)bA{oKT2{EuvPki?0~70Y6kiAEFKQ{T-&E{XmaiX9Jtfg;7cC43iCL
z+TxX3-y8M>8u`f$B_5Zf8T-3>j$!Pv2G1;bMJ#JlR3@eNw!~7~e4<ogo5pNq1AWo<
zn;>g657mAt)xNSEWUCO#c5^`z2N^`nXQFPe-rka!&_|-^LXp#{r~?%@9mSrw{~+VB
zia6?2BQr>WZ#L{iuWzgDcz2KSR8}r6?Arb?)WM?NgVVE#7XC+!bLF*h8N~mvQ2Gz<
ztk1>QhKuUi5o8rmU6P&T?(di3d^p(W=BU%@lNulC!`sc0HYmlrzgidoFwAC9D2Y#P
zHpWGTpW+cg7boic_3Dy=`SP!uf0Xn@ECv_3C0iTm`P_t&;kjiU&}wj(YP{C6E;)7d
z9_zPn)J&(J9ZVui-@33AR65v`*pM6a5UUVdR$suKIDN*j2t=;Pe-VEMS-vjPC(4%;
z+eqQAwW;gH^6LFbG=`w*QUob_Nf$6eHYwZh_uK&prm#G>1PB<`cKR1Ad64{bBuw<)
z((JbV%+#S=jQz9ngUk=->zaM~_A2TPnno<Q&r#%FG`-wozF0EvNe2|8wbHcp?TOg$
z;6pEx_DOc9E9ss{f-7WvRG#G1bclo1i01N&>f0h4N>nSP{a%V-=o>yW;ny<fIuJ>l
z$CofC5}gx?$pu`@JtE`LSyYAbSbY@nwPHQEQ=v5jbz*sgJu>x=FGvbak<2+N;Lb^v
z_O9;q7&etOJ;lUBT)RkU5}6s5neUfN4qha-Qebe~Q@Y7Nj_<8%?S@03D;_VX->#8`
z)PuJ}(LM0%wi-9GC@?Gqo_{QX8*)-h<kx*{zrJ^c_Ju5DHQc^kwn4Kg>i-?sN$tuV
zi@4)@AOq(@psvafamkZdlV!=GH$F!gpL_!7tN*4PUoGZ)st=F}%zx5R+$g|KQF?jE
zHC36wJV<@|=p`U3nGi5?5Y_^9k;#`mX@BRPbo%pT?gHa!wu-TsC(i=(cLx8y$tSHF
z)0T~*J>5i)0%PY?|9i5-ede0G^{GMcu4XIB&PrZftKE?&;M?>$!fLnM%(Jy>Y(t8c
zyLU~+S2Bf+?17^9g~IoSu;n?xBT`c6DhORGNJ}qwNOvsg<G!KqaHSV2-&lJ*%A#;M
zN8-4vB_;7BQB~n-W^^>$ZYnk7T1Ed#*Z^^LSKOKCTeXy3>hqnLf#B9XZQ#hr{Pm|=
zk_(j%b~{^e=|UkykV^E5r~jbNz<}^Gr1B8&j%x#N*^c<{g30$Rcf>a;yP0AQenm&j
z?XLis?_2xMZTy=#r-IP=p+5MSC!Mbr82wJpY0JJVNGnBzt%juL%!}TaUk|(S2ALny
zT)ExiElJ*K_DUfN3#TYbizxmh^`1g10BRMEJ!F4ELVHM%&}z&o(`3H8E&h(DsTI-t
zkH0TdVOAi>=+7I{R*O#QSQSM}W379_!)wdSJS`;G5HVtfl)3x$cpc|Bm-#}IY_R}K
zM=p8b&ifbLdx_IAC1UY~<)t@+d|1CF(nRYgNL{y>bbrzte9V{;X*SgH(g(5*AYFtU
zt*l|Ql2?D-DMz(yc%%j8(q^u)r>pI5rN)lvmw`Ce10?bJQQ)K)c>7v0!HGV~41JF{
zA4nZuZKrFAJ6viHwc_8U26!Bc%orD<SpD5tlujSKB*u#=t){R9u?h!&G>Ugm2g2T)
zo5fSMMDgwZ9YD+9Xf|jj`Q;WbJ~e<uhfx7Z7TP{-lZAgM4BF!tUQmvCN(UYp`4?dK
zW#tWc+9}e)oa;-yJ&$3TvQQkB*>+N+ECQsQbe;vpAFe#nCMzg}lp@YG7)nqVzqeI4
zdhq3LqqP9yHhriiEquM>R|lXC8uZNm@K5lblCGE1(2vH4jt?0=P2)aa)~H67%Mwqs
zFr#oUUfQ-8J;Bw!mm<e{`VTxqhxKjl5xYaay*JUW;V$unG6QDjP9tO1cmAHP5p=BV
zZ-%-N9XJ4PO{$Y7_IQ65eo8_$;4h+2Zg2Hi|4D{#cc0*OBw`vBa0~#ECC=!*#mYl%
zzwKw%W-E_#rM~YGtxoVAOMT_uJAHaxv_DA6@7l=eed_nD2kEGz16uk~sMMrf1bbR~
z|7l{N3$4Jl@vHV^dgX3LPA*M+p!~K+W9`ZVz&aQ`EwSUYEjV;Fd)%g-MIHc>n1UZ0
zp^b8L+8aG{SUE`Xs2+e0r)IyCis!xefaWrVS-aKN5qHH%m<M}1b3Ks^_iHMCOC_o;
zr1@IKh$QU`c8R%M%Sb}%n2>!Uuk?vP#?#B}DQ?-r{QZTxZgV>vU*xB4pi@7895N3_
zXs@tbd8X2|y=mzN`J=A%e8@QA^S12ks9MP&_t!FU#k}{{fA7epPU6>CEuOKqoM{WM
z>GzE^!BIO)kk04-VD4zqp@Lqizi-L!5IyLq^7Oy26?dGJ1vIKDGd*X-zIDozf<UD`
zzWWq(WrSxIo=sFal8qYvVTVl@ti#UVY@C_~a+&kI!j+KmFusuGTG)iY9x%J-u%?B`
zW{UjQ=((W2bT)S@bqyefC`(DlaJ>|YdVvTnHe?g~E6V?#6o&Vf*fH2K+PVg9Y-i-L
zO%Qiz@VXUXyr;%gz?1n+DOvL;ZMxJPjq7QXmL30_du#n;5cn3*u*)IT%|yrG_jR4r
z;c|NfxsgDL8Wn##K^5V4tDA(jR&<&lR0A@wvp+nS=T<yn@E!*6Bf=xWKJJ}p8jXVR
z0R4*jSMSp0mD!^w!q1-f+J%?Vk{{yk<MSyxHfGrJ<E|ySh7I)5xk>_@sm9rEe6_6!
z%CyUO58uUqnd^2ih~u`5gAP5>y7-e#56m++-wJ{zCX+m&Dce&D5<_7Bk_@tES<%~O
z@8&IYaSwPYH^J6lpf;=e0zhd{p`Qpui4^uT9Yd22aQgD^|LpshH@k5XREhTQ&Bo$I
zPmA#glzU+Jz`+A6hPYagIpd)9Xsy=g1}N`xIIZ29yNo@`f&xV~V;7``K0#<Cs);k-
z1pmK(6({55jen4-d$z^d#}o=s1Jw916B>k7f~#;>InZ7rJV17aBQ@Z9b34yXWgLLf
z&+<~!8IcznVz22Xy}PwJ;gv;K?s{-;R%qMbuS4Iy4z=p6i!72cko@geB9%eY$Zd`d
zEDyJ`<;mq7p~Hr8zpe@7I0yQ1@9D_Yv_sb!=MMGC<cB5^bRRkTn|SwUqmvO%WPEE^
z?MQ*y?tB8uOspEyK`I8~P%hE?(6$uZghkQ&yUKAQR%+Bkx~c_6dZBgmABxH|nwk&C
zYt1xDX|HeTw>h}eO*5jtt8Ttem|4XgSHn8>%G||up7Noa@yy{ebP=N`YWfIB7$xUU
z#e5HIThGGIE-BQscc@QV=%S|BBZTT>1oLMtS-@xgZSlT1bmCFmU^x1Ya0~H3-zJg^
zo4SuI=v}hb3_VVeD3d1-5p_?t$Iv-0@I@w0GaAWca!05UF5i1`RevV@WIl}`pUjR4
zt*y5vl6JaXIf+kQi)cs2hocLM?&I_)=n8&_41m_g&%IZ^VV*`CH_~F1IUvz}m{Ck2
zNi0&*hYb?G<8iM}di^k5RghCxu3up*8(&+vOt%e-xBwY7H0BBV5q-;;X!N96?qY2Q
z+>|tEK=hS1`MJ)lyVw0PrjiYs_!YmVp+<*SQGc)^(mWfIrXEQH)spnOe;4h4-jUt)
zG21=0L&P0&sxrMjoI1=o^?pZ(EadTA*ovACzL?0Cbk7n0UPWv6r#Dn&Yx=|QVa|5U
z=f73W6f{=G@5bT0hLASP)I0&2-%bVlqp#{-+a@Eg3iadLt~d<SJ@I5u!)TGe$QAF>
zW2sY(ZjV0*J;J1WVbIrJ<5AEDZss(%(@#)0{?ES*(#(^)MA&5(&r(N7c*Qt+^y)~{
z6B|n~f)TX|rt>4-6frzzbHz!ZM|=bMb7NG6V`(?0)eXcJ+R4U{iI@%y3c4Oa^iI1H
zZE+@RYW>KPRkWw9_eT&+jcSGCtY+!b2|UMCASngo=io}F(1ngYwizjw=Cqw$jQk53
z3v7$K;zd>le<R4Hey4%!gn>QLsj24OGfl9gb!z=<*`I9Nnn@f}nQDTXcV55NGtrFr
zAogf#7g<PQNBFVmmpz#BI=DRd;yZmFKy&YEMRPsVeW`Iz0G;0d-=<80W?a|J`bF-N
zC8gf=EI~fkF2C!3__wh$jj_+?4I&g7MOkqmxmO|zCY9XjAEOqlnfCI_{cgHGgRZPQ
z8$Z`g&QlIc=1z)z(CkdWWNs{@&UZM#@QPA`iw{?TG$lyS8`V?j=d5p9PP<Rj0K-Hd
zqQDIQ46mlkJC~sL##d#gFNjwn*HPc0mx1)+&a>;E`oNj#0s{9Aw}V^{9~q90w_9)f
z@nj%S+<%pp!cRf?w-ie!J+I`S{0th}FanB8>u6Q1#0D}VAT!-j!Q?NW?md=&{^qSU
z;k@xkJWf|&m;~tTe)WfSsUx7k{2je*B;ig>;kpvPSR}o+#Rp=88WJTp>m4c)?GG%~
zZm%gPDN!{gt1S?{H<gyquqzwC^_m$m$?#URLSJaxUe+W1F)u{s%ZxkGd!fy%_8kZA
z;vsc*{)Z<~4)0L;?Zx`_-uOqwvCxl~7#OPhS?Qp)8Lx@Vq0=qU+@IiG>LC0$=T8f1
zQGlSn#;QnIn`Q#t3Z=V9c4&JZ*04KT8?`CpQ1snrdBQ=2=>pA!*f`7Xz8gl<Up{E(
zS;5;9?wK_TG3pJs6yF0(^Guf}TKXbK%Ni0Klbn5eIjhu0LVcDud(5-th@B?40@Wo+
zJwtn00~-BfSlJYLdQ9D-`<f^EmVCU*lk?G8Pc9%Av~F$Cw^$}Bki4%qs8P9rXVEXN
z=uz!ot@x~?!bA6};(k!0qw27YD+J@t^qpDz{SQi3@wQ&7=9MFtK}mw4RPGvO7GZZ%
zi@ttwzt^lpM$YRS`<LrKcgKLweC)UeaYYXchof4nctQJb`-&qm0<<e@`(r2^n_GQb
z7OhQ=P8rHWwO2$T_RzAN_jlTe!PBv(=}#8pQ7r^$K;L(I-+G2La{GNl&@fEa=0_zb
zkyS;jj?BW-(XSD6&2uy^oE^aRVfyx^l`sAE9_@jb{}g)eNz>2BEx0(cf1eod@Q)d2
zB56AJ>*(Kw&ykE+IxEkSIf}VAGBdM_k&&q1k}jBfr<YotOml}F`d=B^x+e~eHGZN<
zsLF2$n|WwzHtQT#)cT}sm*L><#`>;1^qqY2AH2W1yh&I4Gd&#)exa~>%NTNInm7TE
z_$55+y>aSm*VtwS(YQ_)x7UjP8~!;ud~o9=RfR%1<YUpfQ*un+cg|`;66gyKF{R%g
zf1aNP*d?flt0u<R{~YOFc$R0S-#bSe7v2bnh9z&isUBJRH?`^SQK?eq+SMZ|tLdW&
zRH^^SjUM9Eg|&6UdUcSL^F|*AD?9rsc*W#U+s+yiSz)g3ng0$4Z-SS>U*q1!6Wt(%
zJ0hb{RBg_9K5JTSg5!9pa?vX%H<q2Tm>%hHIQX23D3tsyST@W2_2o*#4?MIBZ*tPY
zBLV(<9^}5#?MyW3!*cPk>6qNvhOEsQjyqhLm;2PqWP{u-qmONV{?F#=n|xDf+{gGW
zJ~5}VEF$moR4D1k$Aw!8+b^>x<zk`oqT^K>d75)t;2Es4g^pN`Q{m}^SY8}JzE@3D
z-%kDBYa3HmToxd0RO9Y1{h&7W6|NZisZ-~7@w>!*BXrsyyrzhwhwAqthNj$v&1i{I
zJK;bczswu4?ca#$J35B@nRekq{bsI%l-?_;^J(l(wqr5k-tR3}1sUkKdVN($?o&>P
zFsxjCU^QBvfV^P)bl!i4S{3_gz`d=`vafdPI3ge>fkGjp#LIWYW~a5WMU(W2rQ2xV
zK}#2&n*iN@+OvxFPh>w(YI^(~|E3-ODUQr^cLx|?srAy<LITyMe&-YU`n%p?RCp1t
z9lq1*6HYNq9DvEp^07BJ`tXf5<;k|Bh4x2*7V<^64q0q5mcA6z$mECbHt5}xBh$+<
z*OFzY6QY6{!$h$)3W$3TpDl|Yxor%k;Col|3x70yH*Zu+P~<h~#`Yzw=mMhjyo)TF
zuu8J;rni6w1uQcV;v;5FyEinL;igSKx{^W?gw|H|ez$Eo6!VyY(+<^L_n`>3mt!;J
zG&!w=4{lQA-}g}W3Q3*nH{4Wt8?*PP8N#zz;mVz{+udn+BsBPYwoqj&-8jRlT&;P>
z7vCvM*#F5{_3sx;aTvr=4!%z=VkZD_eY%YtCHf^rXvR^HYGF7%|MwT6IM(NsO5cQm
z&J6cgY|e^FdspDje|E3<Z`FlYH++p>jFJ1cPwSQUD~S$Vt?chCt@RLuuQXo+&<pQK
z^#;U(M~ai%twS3e2$WsEATPJMQSRw_P{cSR%e-ymaf8C17w|(v6~?{4MHXe3XhhMb
zT5uw9QoCDx1b$9zv=rmaY;|a&pUUJ;%Tt9zwKqRBRkfxxd4HkAumuF&>;mB6e~|Vf
zxMMpG%M%fTqc*hC1*Yj}$&yt8{e*jm!cE-}kcEB)>-0N#J2x?)u09Ht+@rm)YjJph
zx=<|AZg}8!4gR5XI|sw0lvjDQwxWNmz9M_#TMp!7FI0^8QhwansFSbRcGf66b2ihP
zF_5JV(VVvDmre=xalzgsS-ZC|^8)VBQO;2OJp+yOiVz*^<JLd&`Znm1-<sy%k@IL<
zW-i(5u5up<)=Rfr$VdxYuT;#5LS~xgFzrLA;gQjm(HCF4Fb1$7G$5_N90*O`3<PP@
zDf@dX4@D_VDo#KbEGPvv%se88WA#nD3QQOBKp|m1*B{CZ+n$oS?q3yWO_A5!s=Pn3
zaKEL!_!YQ%Zs^5kYyCX=c%~$jHPG$0@Qgk=)%|u-K7RS0ygc>v@8_Py4-bd%!tnkO
zZzF=|;42L^nG?w~x22ahU-8yvV7A=A{v-cgakW|JvLPA8%z0c8rAx4Si1iSKL`x)w
zd0XCOPPRt=69a6c?L&^t>E8JotG}t7{p{sr4Cu`i#=UxnsH5b*#=B%>vEyWhqyBOU
zxIs^4rtcXdEZ;9DdvNd!s9xB5_inzmu~!OIZg`VgK4-!dA->`&VcSlv*VkTZi3dTo
zLSTU9b8JiLo-WxXK)#6qgU>I?$MgpHJ*h`OY`?c#oh1%#L|80+uJhdg<%&gbLZw$|
zUghaG{s9i1sBW=}<JoeW2zl;5BPWuF?IK}?%X<JhZ4mi&t0Q(2&T%Vj4Sk7|;}=tp
zS+Fu}wJv`6=hMgT0|>l?+QQ&7kB(nLNFTh3$lNil@q9X!BPdXO>rUbaKH^9ngP*D+
z{)YHOw7#GGmz4gOxC>Ex5*}y*-mfEq)PRg6cY#QhJzh6nZ)+xhcNo^~QD2U)+bu`x
z^mPISYJ<0_4dkU;dGgTlZo$+a%h0JG&xphwF=AMwFc;-})Pw6^&6M$(ZG+t6g8>FT
z<E~e%<H%U2ZJ2e1PX<72;poanB@9O9XRl%_L-gvYF4WndSH#r&jmwKoXgcL_>|fOZ
zj}Lx!4%w1w_4M_jP;(9%ZIJY|W%S>P-i9Rd&#jG*8y$5Fs>MZztyo`r_<UHF<PQc>
zn)nFs&<E=~;rTA`C5#|Ml0HAA4KrK7Z9%@UbMXD0;W70Kx7$%99K2cRu*e|vjZ~NH
zA&`juQ3wT2!Bk$b0;EiJ$sIrHOe}ZN>lk-&{k@H9oOhk@gaZXl5~3H5tBZ9o-h&9t
zj*6~`!hoUGr!X%?QuCcky)TQ0v<gs-pb*P7<wwpS<W!RI+wjP39q+7ua<}~zdNFCz
zR%yo^uB`Ly638$Mlse896WU@XWM|Y*Zi+qF$CCVNTyP|QfRyor)3NI(gvnB6SPQRB
zFADm5rdIBD5a@s;svQ&Klk0d={Ck~Nj?!ZOYNf&*(`UP!C-6sba1#sK#B*(^{qAr;
zLN#q?2k$zs;?&_;vgyCRJ%ZiyV{OnR*Gja0>Q{@*j7m3wFC(rU+en3*?yX-#$^8pj
zv#GzRF;eYrCy^&4;9D!<+iC1B<$yBp4Yi-M?V|U618MKqQE{0fkD@^9*`F$T|2z5a
zmA322!((N5cI9ni;Uvf+K*=%VQ<d>+Fj&OwnL&c1q;?^@OtC7<=F@dXBvkwG1zlHb
z_tc=aEw=2ME6lt?3gH&UmQ`Mwl}BqQVzfbQ9VeTDN@=1)j3!gmSDW7+d#!SFt)*~N
zvQGFuVO^1MPgvi-f~@I!-nOr!ytz0<94(8IQ2!yIKT9^x-GztI=}>EMoR%tGl*-3c
ziz{uCn{)F7Db6>$2K@rf9!>g+WsD`=@28(N;M%U+_>EfyTl;=0<SEw@_;7!oUOQRL
zD9J4<(p2jB>Rf14$~vQXOhR{W>lJE)a%FpGY2hv>+=t*W?;VfcL~Ydl&VFJ((TyY8
z*K8&QZM0Co;;W|g$FRcFrYLFUzi(Q@&TI&2HJAKsNKx2<Q709w)Dd%C_zp)=vep=I
z(Wk%Iajh*OzUj(pHZ&`kQ`Vq^!CQ-blH}#B^2_1HwMIDA`VAFT-@4L$mwJ=Jjjo}#
z>Q&!mOrzL+xX<`Z$hq6F9R+c&+vfQ=09m?DyM?%t+WHyVQ7q;1SaaCH_6b_94(B{y
z*~y%6^x&^ZPaoXIM0l2`a2FI|P9o~bVAcos+8<2&uz_7H1?w@}*QYVL)*C!>rRIQ`
zUL@{e*ZL*?)xyC*_OQF$&zKK&=~rQ63@2ta5JDNrU{qO|8sUP&`}{W5@0M`inK*?@
z>Sx*38rViUyRmX^;1YkCM^KFE^}jX*i6efB6z(m?50Q)nFO^8;;zLaVk$i82`cMKk
znZY*>+IDmKwo}Nxt9m<(B$ss*l4pewTM+o+!agHfbJ%cd3GFXTuoH9O`*(f5!dEjX
zXh-NsCvsPmygu1^x8?3hrrHMLhUrWMO<{mcybdN9pfM8zXIJE>PsFIrP8sOc%pV!d
zL=O+}({G`@TNTY+bHo=_^$XRAI2?-0Y60SePxo*&_2FLF7Qh+;&FfnHFBjT`24&jh
z&li|sgpGfLXy3A0=upa6BC({%nRw2di$;6g>Z?@rrs7Yl1jp;nkehYCOji-vFpU~M
zm>p9;-fs<i5@Fs2!>O2})Ec*}qxvRlbO__0hL@XFRE^HSQHKx%zHh~9J&XS(5>Jh7
z-nBuva?-y5+lpAZz<hRVO)lKf2o>54BjSU91PrAS&H&)HnKKsaX@R5Qr1UmuEiaD%
zH)!}ZN0GD5LRVyTIlzriGCJUBQ9<JQslY;y0#e0|o`ZhpojXl+lOCC&T4>Wqni5Iv
zH0>MWijh`)n-xQAk~2qZv6y@<M0Wi%ITpM}!8>DpV<Op$u&qytxD7|2E<rKsA`&2+
zs+>Y#aL<v|l*5OQK?HP!il(){8I9y{s;{ol1mP@vG-vzj3T!g1agyHtYk_RU@*yX1
zaNIV(tZ(1#I{JQ09BIO%*UJn0NX}YA$W}_?d}WvzHAF!EO(dK}!e>IkT2z;Mg(z{`
z&6fWi>)>q66U|L!^F97w&e`l#A<ok5nC!ZNG+)5*mp{D*T=$#ePe~p<Tdsd&>JH5o
zI2Zmxq!<cC>`)hZ>P884F%LNE7&?`3<*1Hd91!UMg!PGvk3N#k|I<zyx?oqmV}A@_
zd_`ErjORreF+=bR#p_Kxp_BwlRs<V`x=hfAsVxJ|Qoo0-w~zc96}`_!cMK-iQ6ob~
zf%~Ja1ngU^XkIW$$n$EXk6u^aN;wGBkkSH+;8SAf{w3ZXi)-ZRUSbL^Gc#h*pjj|z
zm44lzkCDZCPPc%V+i$?J3&pfq;=Y)P7}{4+`NNi};Zi%RWecqMmAQLZEY@09OJ~qK
z^rxkq378A53-#N;zscbz9e@!CFl<2Fzz2-Q^H`&9A?{B=BWF}q!sHy&rU|pp`uyQ*
zU@`UHE**f#hdR;by{qGZ{j2S57vEb$cya2ha?iVzEua5{&K?^Nad+Sfh>AQ4Hcitc
z9HJUf$dpVkBofYo0ACYs<cWuK9w_9pmeHr)tm^4VU8L#m76!CAf4lQ_n`ebW;}j02
ztObreB42MOW6Ao~PK~taL3cbRcZD0<CQbv!i`Jzezt^Pzqp@(*aFgYl7;Wog_AT0n
zUyM8pu{z@;eicd~VF&jbm=$@PiFfJ<AX{$g3?N_|d31SdzWdz}qVJkw<~)8yV1BwK
zC!tuD;ZRkD)2t!kZ(gmjTUr&$&q%f>gvHMD8Y0leDS@*Nqm2}Ap}{!&JNr&oTEPOS
z_oduo;Y5D*^}bYr%yVCyLBz7Il+}D(@6+RQ{rTS6((BNqc^ugbQv)8179#CCvla<G
zd97KuTg%Oob;F&77wf2HsxO_FQho%Q!#q=5&p5W89JR#F1bWzf3H0tqcF4X{EL;+u
z4{l)93!zW7%?pX6dG9lj&%`sRpCNgiHq|{iW$>qV#Ek939UFk1YOt@wfH=NHy|IA{
z)J(U-_63&S6%f?|IJ{6**PAh*_mCuReg|r*tN1$ijWwNnK4LHJGP_Mw{;-MkG<LJ)
z{b^HNCEfW~-_G|5Yu_(b3<`at`DOZ_G7HeACUbS%;7OIQw?~25$dlq4#qZ0-{zueT
zhDF_d(PAJV0wPMoNQ1;s(hMRcIh1sVfOO|DFQIfvOG$S~cS$244MTT#4ouwP|J?iB
zFZ1;`XFq4hS$prbZajoe^Y6Psa=>rl@PPdXv+rKxurTJlotetf;7g0|5Ub#x7p8R_
z(R5x{q{B7Ym&wpR5VZf6KxSd|G|`B<g#!X344iz=GBG#F`r5)aBX-)-uWRTpky7*%
z_=G_weO=lF5h(JcH-sY{>@eWg+y1!Q!;~+=^<&|aQdF?`_!rQb!h%Axh42gUFKu@k
zJkJ_UWY*Q9h;xDc8skt%#utxm?-7A%q*R`(F2IG~60f0@Z|E^b@ALx=nj6@U#)f`w
z;7kV>WuAr$$9O<bPfhU&AW{9@j-RN%=mr1v4q!@^jOM%4*)gcNp-<%vKFoAenSbf;
zo#}Mg$)zm@-uqYdM1zQM&MdJ%HmK;Zb|P?`5C+0x70OH~FZMU8Le3oRbSG0c;&TXF
zvpnolp2d%YD=<L0-&bKVNn<vPVYW?4NtV|`nk9l!+3kH>Jx&1Y`N!B)Za>x2E^6sV
z*+`|#@s8>Thbr#`$VH@HR>~QA;JYL4`7ufkQRswOmRCoegI7raG#FG%+KxW6U5hmK
z$J6`^c?gL+7?65Hwi`uBw$0vr4R1WA1hP={bA3OmS2g+)OI(RG%{lE4IB@H-IjFCy
zd+qdU3jc33H9qczdT7+n;YZqGY}Sgaz}Iwv+seO&0Oq{io9lW;?Joo3vxSoBDpm94
zWSNM$l>L4acs0Fl+Bjl-7gV{@lOX7=(}ovd`~H!1dkm&@b2>~T49gSkSAVGRIyqO`
zTbMR%f68+whJmYULj?NTS>CCUJW3dEEh~o<f2xk6#wT+pBM*O75gK8gML*~DNEe-I
zB=AAn_c!XhZ1Ol#fZ<(SPvKv!l`;DL+sX}zeQL~Vsl?;?@+h*LahACs8|ZEPV+ZPI
zqVH$RrLxT&{+M2G1z}`5znwr3B8|tx4Nq`+AEN?UfU9RXR|%Wy2|}OFM!~QA-mUNV
z$jl4?%2zMK>t&R~xm1+wazY$(zz46IRLM{{w46f&T*tq~^uQ@zy~kLrSEp`ThO+P_
zdAY9`w^_9`-|sCW_`%+DcPTA7mv<oW?WFPE%<BS>xs2cnly_3(dt`)}d5H?~qe;;Q
zPk(Rr<1IG0r}z}OJ2WsSr3Qw!`9#MO;VkDh9|y!>Q;^;3%(OR`wRVZf>`g9f$p|wz
zYSJB!4eRwoY0w+}P*UJfibaTBt4)u1W#1P}x%k0r);RP1*;T2T$HV4_a18XmJYuz-
zO8ds(cIf4-qI2Sr@H4CkDWPqi$E?N?z28U+Eb3p)kQ~2_%j5}Xejl2D((V$nadERd
zL~Zge`k&|4{xIM)9w1?*N1`Lw=lGq4mhv~$(O5UTV@RR&c@>LmF(O?oXSyRo_CNY(
z4DLx@*LfMslri}{A~L_-5q|<H(QM^k1wqRRVf(Zeeh~YdvyRPQ8EgIMbETq`mIuL{
zzuuV6>Q!R3DAs|-AL<GGwL@G8^=P8i$CWXkju$B+afPYRoZeE?>1T5@c{8Vf0)iGs
zG!kLI<g}e1U%gX{%NmD^6Z-5ePhP*J@$Y+d8js#_ciIMaJoQ*KcZQm!t80=0bZXv?
zs#wgptG<({_A0c%$aal}>inQ-O@3#7z0MeUXfEzu#Zor%KeKXE>bCrD;q_N!%6v-4
z_a)&6n+%ih^NlQ!svJ0weVgkcuS{Btul{28@yM56JDv>wK)Vnlm(60gdp@|tB(-;m
z8IbNX=`LRG!qrbO=;sr07CSagI~X4v<@=bu*`iK0T$Q@GesIc{<jsp(pW&NcQ6cGp
zhc(FPI~W!65?%jJdR!)EgZI%mYpTEN0}B6;nt)GXgF9V+i>=O<28}G*=%`#8woLFe
z_7-LaxTcvQCe{D0_dR`6LwnWxH(WUC-oYy+BR_)t3tepfK|%jHb{aUVNc~#A;i75T
z&7*aSLd;f5BS+)B{~s3Tryacd*OobkS>7oFIc9G6P0L<Zd5SS{hF^TELR9_nT=(CO
z2_eU$*0!?rmammtj*t9@4obxPENb{JwznvcPhM45-kHxNRc9tbo^}1+%&*?%ujasl
zH}0J<IQ&9mq=)*UHt9O%-O2`5`EFY%{3^CSG#u*A)Vf6kE<O0O^Y&q0O=V;G`)P20
zJYx1|t2CvObG}3;BaoJ1?8HSE<eJcBuhCCO(;zkQC>5N{R+Btm98>4#kSr!JfK}pW
zl7K%U9oWqEj}@@V+dFAzArdL#AuGZ|5y8y@bEf~uiyfPc<V0`Oeo^;hI=s)xuWr{g
z#v;XeCw66-JpDc-Wq`+#OtIi!`9|U^&1T*-xBHv~oY;kmi)Z&z=|LYeoYFK6bBg%v
zF%Fk=j75sL9UC$oP_DkX#<v{Ze+(yhY_aii3M`3}ER0#=ye=l=mu@vX{-5tfg`9X9
z7$qV;$APhygopUozuF_tYFRBCLb&YYl6rbdt23jjOF^N!_`2ke=d^X@B)Aj-1R5Uq
zaF)sP0~u;5ZSZ`LVF|k>Ly7CEfS2Ub(`h8j;jBwKaXvGr(RY>f#b}PC!VK?>f&0HO
zD^rbJhK<VL1_5YDhmY=P4*!Z8l0G=w?6033_INZ_NqefnBeE8y8M$)1l*@Df{cf&T
z(F+B3s^)b1o+EZ!OV1M*$)61#7a7NB7i}0{Vl&r7Lth3PT;{&a8v+<dN)PmLgMqCl
zC7J&QL@}i)reOI~XN;oL{LA@}W2_{B`8~jpZ}T18l9ymc6{D9m?%y~Z#iU<e;C_Oy
zThjSEUmYL}{&g{9**qb?Q-hJqho)QbzQQU~%C_zz%?POpFRMsUYaN~Lp*u?QZVuzw
zQ+WD)td(oF*#584fI43TD}F)MHhS6<M3{zu&%b=ihdzi{D+HlLgw`W12MG<0vz5zz
zwk<xlkV+1&by)Y1Z9Inz@U(I0-gSEHKe3MHlvUx^H$VSIfDuoscBA-Ru_3WlzR}@{
za25W!x!)eB=V7X}WjooV#A4}~gTd5oK&=#&_HQQTmU61hM%Q6L<jeM(u!EY2)|A(`
zo4;a@Bt@SY80`tA>sR|8rv4cH^=CpNBhGNhG0|4qFh-$tXG+~W(i~J6#U@yehlYZX
zvU9I~$@M2g&%ZRn7ubjDucy&-&0Jd)8e@<nF)ja<Ir4>itZOf>X$)(jcXP2xCWb^t
zWw1TFU5wE)GMbKpWINw|O#(H}Cot#>e8U&>P-xXOp7e!mn76Nze>ibpJwSXAX6jyv
zc{!0Qzn!=@y5-EyH(=h}Xr$@EIIolhChHD9>b(4K=t&=7Hb6E#vHwjs!94dbKG@iP
zBbd4BdH~>EdQ}J6!gI$hZZp>}L1DV>5=&x|O`iBitRLbxQ_)vFeS9dGht-=UBE7UY
znjkfz_QhP-`zf;O_E-DQ@sFab$1F^L!3a_~W}?5e<G}=`gNBCz2aon|0VS9q@kQwM
zon*|YwM6L#C^e@o0Wl(u@}}teM{?nuI?CEY2Y7k6(8ao;6pemAqKvvhftTu?DjqmU
zgd?Us%Wa@nHPp5%+Wx<5UIOCkZPL?qREIVvYWhdN6GDFDyq~ugt$h(Eoe#jh&fzd6
zRA?cc6E!KS4)p9h#mgVV#S*p&s!g2+#cNoX4VZlNF$`1Lbz3tCYq_Y#F;NU0xYZ?~
zK<|ND>-G7L1G@iB@NCA6bK*MM6ydCt5O$Vqus$cLd2XM4A{YIy;a-ONm4nxqLq_s~
zqeCIN{eOR%y^Z>znN`tH6+b=}F%pU!9IGQLqohcMgvHp(r-$Q$BpXmTHv7TdsqllQ
z=Qg7?=Pe0Q`Gu7Va^L)!0Ey^9$zs7-vZd=xl8Dl)K&`tUD%_hb>EAA4kHl@#Q&t<}
zbOu<Mr9ben$=&~oxw%UC&EG{jw4jb%xbOx-`dN^x!8o0Pg_h6(1eNhAG{FyyKXVxI
z%E2xwQV98ITva0O&%sijeT-XpvDq9W%;ppL5B$AOytVS}Pj9IOktD4{H3uF>rj}^v
zt~`bs&;}8-U8P6#u9}8K-+d?)`d53uHUAFJU6gMFT@7Ad<bsr@EEU;4oa4Cl(*Je{
z-S`5dRvHu!U3U_KFUfV<JyuRnhMbc&!UNx^s;T|nie*JFK3&4hImj6s&W4PcJt(%O
z_q3fch>s&ppWyeeQTt9j@ih|O<gT??|B!B}Xxs{_r!nvryY5MJ)7jg&*bMMv(lr<*
zr+~l}olU6qcR+_Q;0h0W>l$^26(YEg&tHK0rXXkwM~L}oN9f#76X0P<q16teg3s+s
z8K*rH?iIr5&i{&r9<&0*udO1kI*%yqto~fABv)d#m<tdonWXV@t!CHjaKKkAjBMKr
zZGV)2m&>$IXv{%hBgeXis1>t20*~LLV|1|A8S*xsY~rA{Z?aeA3yV;GuYrHPYf!!6
zz>}>0e=&P(?37z;dySc_3p|khy~?6o^(EW+zIe^Jo^SaiZ#~6UuNyUqMw9WS{T+Ym
z8Ftze9$g(`)~ez95|zlJQM)JJl}Q<mIMkQbZD||!ltl15XTcZw*TGYntpK5Vd#aLa
z;I(O++2d3{izD)QA>sPkHmn?b5#5)@tnVZC3~12q2(T?8_qn3W2bk%V@)zwF?2)44
zvYp964aNc$I;qXpf^)rfTq6FbN&O}Z+jqZr)>=OH9!gzd5NY{;imBvA@!Hx2wKzag
zB0iDtn<@pK`(`vOPa?^nAJyMfoML@VQn4j>PscFf2M7!6W97NGU=?UH&ixVR47=QH
z{@65uubDDt=Xd@HXZ@Sl#g)J6GW}m>Yc(9h4?~4UUr0{K=t`1j41N?&SlT`HTJkUr
z<*K(#@xo?%4BI~+)!iZ3c?-TBJONQJU&{d<lSdC5alHF9B!-Ps;;#;#v}n|GQR|2|
zD4Umsy@Bg4<W4t8x((Md3ta2>b|-+A1SI8J<*_V{9;`6dc}wOT>xLsgVE66Auc&$%
z(-;YlMG)CNXQj5LJ)T0ewP>;h7}MNEY8nDS`f9Tn0|=M3yAt@FC$~>#g@QGucGl+5
zUuX%aiwhI#^Yqb#TNkE#`2Yq8R`kCO9hkcAce`}LzL}!|x7MX_dmYw`IIH6ou1Bft
zI{qky#zT#Us^s|Wj!d^ExsSe&;K}rIF~s(A#YBWr^XhXt;twd+iuM;ND@S8;N=Ng_
zq;;0^`$xV>w2d0R48|BY;rgGOJc)Cv5|f~YkZ|3UoHp({@5Y%IPa6R;{Uf8S^Nv!v
zBS^TbCCV|;oVb(GTIY6JMA6c1e|Bh+&lGoTc3@D^XX=+h#oV<#P8{qqv+EFNiNE!R
zq|(NbT4YRU4vG5~Ln_E|xsdrgxFm)dECPONX+7TkY=uJM$Zl}Uel|n|m5=EiPyXgX
z$%v8jx@Y}9rxd_zatOTSd3+c-Dnv_;=69UHUwKo5|IpG9cDoN+NE7_F;Z=S`Hte-b
z`@(Q~`f%OLD4zk5JEPZkIUe6_k<&V3J~ez%Qpyp?({X;4-8W4px%*U2IyuKD^x0QK
z*p~>eTV4k1HW0*1+F+II^(n)(&awmN_1SA%t}7C%BsZ*{KpdJK<kobJk8b$4Pkk#V
zgF=)B;hcY7mJ%a!?@w`!&tlxDlgw_LxgJd$zliW|9wqL7V$9NY<+OwicSm@xskzah
z)q7s|b(lV@(YIG1Cv&FSi$mXnPV!!9hWDg68^}>+b<XTC%m&2nlVp1$jFI`GdLdH1
zhYz}xJUgfG6@>pronKGrS+aOPVD_uvqZY5bLB1BBa502f7h9OR+}>i6B-#VG#E793
zmPl^85YuXZ{p_R4P*keUXR9xBAH++m!(6Hx#wHZy5JC;}JnD)47mw)%Qi1b~<?*IK
z$c^d9${M%!IHyL_o0%TVcUozsu9Kz7`}v|Z`?@#U^VeIT^zLqFl#8+VVIoG+iw515
zUK|CTmvHm`Ft`pGDK7e9hy}k(%0?C3e8qXcoadD}`U4E~Mu&8O43C>NfA>B#Q_}w!
zx34L-ooy*@TaXV~^@2-E6O77a4u>lzlzX@3Czb0!R+RB`Jn}H~>G-7So}_4(!LztC
zMJisdnMn4(Ngh)v6^59AQ{ni-4Z{o!E`d&nBnpP<Kf9cYtZ;RQ+$PCA7_9JL1rG30
zZw#T9)8W8X7?nDUg|d$gXMVr)x2lzaEKNYPk|4c<tJy2j?{`>4qBlfbS+2wC{MM;M
z_aJA|*6j}3teHqT#!9{2dxu{umw%MWmx<yNqT@dIOJMpS@_K^2k^S5D;xo~w-^TWc
zPifQSBHWKg;Q3jtZ{F35J-pd8tQ&OKwL4Dboc5`8L{u?qX*neN#WIrCn`0KujQF3)
zbp%AbqZN`qbE#zpMjf6pUvJ6%sW5S=U78oz#fKPEgkO_QT=-#OBe`?zQ<21@)@0KT
zJQer(AdkI{(HK01*t65yRL&Pf`uTJwP^7u!qrgLSjyQf9c_%G9y-Ftjy81q*qda>i
zfgyh0|4~o(Vy?*jqSh~xVEfym0H^>f@>+Y%ASU$WuyI?_v-3ULpGDJ7_dy-o^*I^x
zglcUcScosz&_hU926O{)EB#)B&5GB{)EB<H6Str<%A*$Dp53!cdk5&6<q4crkbEwi
zv=lIR&AA_aonv5YJ@+OG{}G26M~K@IzBt>m<U6?rUJVr;pNPte=pU!5AxB07Zx2Xh
zGFV$aGUN>f`AP7!6kWrNu#nkN)<gqWd3#c1WgLWFd?j*sHjr~skjrz-V~UA8>w{>g
z!QJ3Oj|z8=rJHu2Cg67rz3r1F?SNU9N`quz2Ps5%JHocdywKf16Qfjs8EGgv14KEi
zg9noLIV%fI-VIG`)(3GsJvc7g_Yzho94G}+N#t}$Qp!E5rQVW2T-jjm5a|Ps?D{+l
zJrc2&c_1F3I_vHKXmYmQE-L>g)|SkhDH-+NH*Q7VIi7}A^!(qITMdNlG?F?jYE<w|
zRJihy9^VK8UofWT5NJ~C1Q%!~tA5gdmp0IE{B+X3bjF<2jl??8XKdx~7+(0NTP8Ft
z_KXTZYRPq-$Ws%nvg0z*d9O-O^i5zKg4@a1<BljrFr~Tc{U?I*?SocCY`HhtO$z*{
zhLrq5okYNJ$XW2Y-wommmg>P2dz?WJ#olYs^=RcEzJoa*LkMvL_h9c=TnO0_+in<%
ztUjT4V&(+CSP}umG@th}vG=W<jJWxQ3S(|5OO1bD0yL0+6OSe4)(`uL*KHEcZVJb~
zaeLG(VtDs8PdVXkgU{(&nC2BRW?*o>oyQb2B>`qoT0IhoZD5-I(K$?&oEZa5gwbCn
z{yq}_FL!hiV03}n_+@sHTY>QizF*1mFtY7#?C;2*S@sT+Wb7w;SU4m>!&_v%*8nCW
zZ(6HT4UaysV^I2kqRuJ#;O|w&5eZHZzcJIZMXHHS0B=~7dqz1x*WV%HJ%v*SeMSvQ
zZk$9-TPd0A`u_0BEb2GyCcI4$^q35Fl4jCwwnBFF%&G(Jb(`8DK@u%y-qETUA|lIj
zAFXj_K7Q@VTqCpF@AtRptalp2JP$p%O|DNo2b&^>L8(1GW1}IpdPzc7z8j*+SC-Pl
z)>Z>M&g2`_?Ugqvo_~;;4*%cWFEVxNXuCH<OxMq$5(=|<T$xP<FmyFOMbBVinnpS}
z!-D>_uEK_Q!&aVWU!Bb9)K(?nppH3HowAZBKZBkYL#^128r4duCf20%khBt+NJC_Q
zYEEzWPf;$qVzAho49=N<jGOi^xs;@96CTE+^0imu)8_Z&kUH}uxv40i*aW_kr$GFa
zICqw0OrAb3DvVFRQpYHZRi3`2{oOv#lzX`1716v`7=*B^K{%!c!?S;aDNJ$F%n?uY
zkPDVq0~bU73s>E&e2P1018a@;3ZrP8flU$jlRnFVx*coS;xrr5=oab_h<Oe_dXq-x
zF09a--ZedvaVInK&CD*uax#IUVncB)skOaU>bxJuF0slJNq2Ac%6urv`roZv{2WM+
z<>IHVdrx8Gk7N6VtF=l4ZXox#Mxi3en~KBH0i=M`2PB(J108YxJNKIOR<Kd@!AwK)
z>sW6X-)Li{#5wa!f$#3fUIgFFtA^(uDWT0<Kz{5+b7KF)(4XjahzxG#tf0Vah}k#Y
zBxU%bUw&I+uJz{LaDLsj0M~pai4ZFbb&Ii^3h5#LTs-jUsoPA?oK?^TT35up#T3;m
zT*`SARz7@l35z<NUun#PLr6&<Tl0eMk^Nm`2qcBmYfcT*&TeNs+*ZSL58NYM4%)XT
z5?auGjE+l3;;(4*V1LJPW&Zicm@*e1mgw)BtG~oTuk=)`XStXBpzs@DNchOZUg7qO
zncywf!|>fQS8;n%E61T>`s#@I4y+KTDI02is@)vU0k`M(!SpQPTm$wt^XqR??|pU8
zc?H&vBL4PUR>vK5A?D6}PNC~HBa7b;7YP;)Ci6X04Cs{4UvD4qSqe`^fVDD$%1BD>
zP$|qsu2A%Ioln+-x0Td55>$hY!}rObJvj_6DNLLX$=;Mlbd(rRodF1cN25o?P#3&a
zE~}k@*U@oxOx&Vnmui9sEKK6j^L@jM&qSx87A=dDLM>dWEGzOU_(j8*X7vlydU~ZB
z&Wx*IwB31tn`!q)p$`Ir;Z+lr`9#m}x&}0=i-GoFVVKmgEFmXg=sdiB50ONO;~`wW
zA-|#MQ^wo*Uq+G=>j88gDpZTq54BD%MjY5XO~P-s<FrJBo&H;E=Pw{ins9kQ_0Y`J
zXqkB}W6A}`z8Uuwo!tXbsXh0f&rT4z$zARJhtJ-mkz$mud00MVmBs*%8C-G6SDg=^
z89RbvH{V9!_YW}h0a;oMk>~|c5--K@eN>i<xoRxa<3G#`zv$_?La9tNHMt$$vW5k+
z%F6JMH`=1I4tWBZDQ~bPbJ2`nBPr3<P55RO7S2SX@3@0Hxw(garQEITAMb<Q_ch(G
zAUDh2H*G7)L>I^96(a5>cQe9;rKP3i>LIsW)gJuu6cZ^mA<KgWFG|eHAfhO3a^Gbx
zqtWx)U@_Z`{l|99oNG>YzTBf5V`(Rzbz?=7mE{xFU&zD9+76%06P;7r?!+ZJOYVNl
zY6(wbIQn~Q1O5deTFSp$b|<)}6Wo!!r_uFaE=4PQs?0ayj{c^LgqGs|xy^##?jUIp
z9+XQ#5pQ)R6lV!-yIfDH-mjs@m2stfupGOu2SxOd^W^u4m9h%1<}SA`C7~32e-tup
zSHn?E0`!(Z<yhyvhD9J}b}boe!m&hYVj{1?&E5Nv_%oSiiy>c}IA1oIE1p@$ID>s!
zyLFYUeN@?H5@ccX;4a`3b+{XqmGNfx7wMf`&O*F@=_%@iuINX6GNbZnCw_L+#yHyH
zCTCwfQtQ&b3$7e3Md2)ijkl4-jZ%d1?43D^tgSgJkPHF{6XEkGtqnx#1jl=!pr&m9
zr6!m|rSGKk2`ISpvhlz;`Yjfzuy%S!Qbqe|UmshFq~)Y9t}lx^{g`#&8{K?z=I=OE
z%=&U#Icr3p<c0a2Z`1Z%h~@7ot(n9VB~+CB<ryjB9GZ6-7RU-#UGo_Y{ZW)Yof{rG
zBlSA%jz3-PSKQs`s`tm)OKILX82b8Ny<{(>s!^669SsveDY+g09P2Yd>@b=k`tdZV
z(QVQ)O4Y6CBl0Ujhu7ouF=yx(_ib+9u3T>p+&%x%P#x!q6V63<x^+I7x*a*FxQ756
z$(qO4^TiKJNXyDzuYP68-YKwv-PO!FPFxAa=^t0Ytz{8v)739jH)bMQm_!d|msKL3
zMWTBL(_^5baZ2;HDawkuXj5oCv<~q?iM9+6$F+;b%)_2rN_>Iw1%^^V#avS~DN`eb
zlq%Uql$IT(qEnj&M=q`yHQLp4adZjWHhftWJ}xI6?#1iF)Qiv`Ib@kO8rZAY9YL~{
zm5|eZ9RP^wWpGf_YBWJdDS)H6o#MJlabpi5guN2=lXj>sz<_P+3#!nfS$;dY*>@v_
zT`{a#VL!W@S6H~|+!T<OdBM|ae1ADMZLF@{eyp=hpj}p233b|Qhxr@qn;_0Ua~}g%
z(|ge5=w?*@m8xlKdb$C8O90g$r$1q&-Y(ZXr^;e)mv>M<=u(|QC5T8uA*0YygWuWy
zdrSQn`yj2<34IE_e}z5r@po$3wT=5iVm|YTz<F~{eVs^soMkVlyN+XW+A{TpQA3p%
z;!({pHc3==%`&z6uLcL@R1(Yc(7lBU;O1Tc`NBRWsOU=$3V){Q?syGeT&i&#Z?}Nb
z7{&R9d{YoMriA8lG$SqCvz@%=47*^Q8G#-9oeG>@kP9(WG1kJD{)8FduYz%V8ch%}
zhTN!qHSTug_K@SS8=Ad?0Pfp!+kb0px6yIW4E^)EesI_Z`lJj1L$ggRL3ivO0sI91
z4M|s0bJ6u9YLvt)L`yIy4owJui52pv@nq^rV{oTM*H0&IGQ>SqyOabPHDa3M#npS)
zp+()0w{SQGTnXhBP`NM;GMAQLc{$a8LDJj&^_`9FGvxwW<;=bD0ABB=#cjuhSy_vC
zWd2^Pwc|e(Wm)5v1cBF;4N6yFV<ZQXXKbP64v+_56YeO=JXy8viyDk9ToigU&yB*{
zFwPruLENBd6-MR2zO30Hc$LY`_3`S^!AA9HQSX@VQE99x|GRxC0UdX`u`e%S6#p@Y
zQ4vB7HWM|$VN`0PtXrwn!(VWN`L#xSt`u0L6FfLF0t0IBH=kZjyYiG@jJMX74Ktz?
z<k$`h8!H!5Dfh&X!W-Wu*0AiRKukeXOj}AElas28vaeQxK*Zx(#t>y#gM>2$<iu5*
z<kQ73mZ&d%V5k@k>Zij<W1_h-6#&K8C((zdr$NV2A0bHgx|&>?r$i#v?z_%iI~OXD
z$N3<Ht6BQ3)M#H5XHb{LhnIxgj~kfF=`G*#e$VCWlpV1R3%(M}4&cK}{mjGuqRJ9(
zuj8mnls~B?3F6!@df`+UGi^~2`Fmta^2sE<?vSSDC<Q@z&6qbFQS7RhU-RU%(Ri31
z+S)zx78c@P)}i+5>7noLXs!w3X0K}YaHXata*yaGH;M=4`qv2|C)ozZzguCgj^vVa
zu-}E6f4{r$A~yu6PuP8orWR!Y-3XFt5#<Mc3)*5e;qtl}-_Z>4YMU9WhYBC@Y+UeP
zze|ySp7BMs54I~R=+=}R@(FTh#BVl-^c)^`qG?rf@JjO_r)tPzix;nG=b-nR4>qd5
z`9`E%)nlw6IrCg%&2lzsFcUluDB(Is%+)Tdcjy$lEimYQHO$~mTRJ#)`#TtucXZP#
z7{I&eQsW3c=e?V^PU74(o=hjR<-r_6%8+#L){(biM`)ImO_YhNToaT<ttd9PJ@)h|
zQaV8ln0a*5EGT|sACvRurkN_>OcG=8K#fcv*;Gk|SbZ|`xvFi&IHU$|u`MM|f;L9T
zJM?+Wp9U5>pt>aao~BGbDqFSf*0lghQkcr2_X(n>JsofxfZKyJfxU4^5sQsl{huin
zl*|zgI0B!86H7$nGDXOQX;EcMdw9U5kj~q;xR?OR7LqldR>(&^=|l{>+3T`m5D>Pn
zAzMbZrxp~~teRAqJd6B2O_(;x<LJw{<a<f>;t%$Q1me7IIw+mV1Odj2L|5E)o~`)$
zMV3aXgrNE^m)cUE#sIL_a3TYpxoL5`y9`uc1<!60Oj<;~Y5|I=SxLyVNLUy#c%~o7
zDzw{RGsolp*T*UKIxFVvgrFsaD8_pMbBz8T%--D**ucmhlll9gtQ!8u!)YSl&m@j-
z0Tps3m5K)mTZ*F+YEZ~t@fBI?4Nv2SAT#D;IsL+GL~W}F7F6b@u=`R?`!w4GUjKq$
zOP{jYCkA#WigjzWS=?&C?&>T{0@!}b9;q~yxoi`m_6Ph5{>6n^i`)jrT3HhVA9P{`
zMYb0V3*}szvIsi34ZGW8M3&Djw4jMaZ&rug4~z*;2DB<9SY#7yac8n-M!PGq1rYwN
zcA^I??K3r{M#VA7Bb&C`+LRIu(I5QiYP%ZKDEcu`FDv&9Aef4bmQGS7It$u$iTZ&!
zX+a&{8=(Ai{2A2mdfCmS`O;iBN|TY(7K>l+-&`)n19azwxnDe8Ga27VKf#GX%bJwy
zu?+FK5ZTVJ1lD#sB@S#T#QtzFXWIIsCuwN!aotJ0cMhldYXnKV92jJGVL-BR&5|l!
zG0nyWqnOpQw4hgV&|jeq5=CHP90RoG>dVWpnan9~@ZK*W!+xy=N27A$kX$|TrN6gz
z<d|gS1EZ%#H(ihnnApf8HSG5%brYg0SR!2<*eV-<t}Dofa%Rd-?kX9&6#VXnh-oMX
z`WHECeC_wwloSgTv?Jf2xew1XuxXSIrO4JtMX{r^dPvYC=p#GalgGKGt0Ym}35$}t
zGsjvE^uJbBdIk1zwt~KgyBK*^#(dsixBN!f1yfUIu`B=&%~029HPwatPslS{5q>io
z_bx|QbgX&YH3<3%ddU-zN4JCuBi`SSE2==L#drT@@SvE;(ay~h^?3bIcKvOV=Gfhf
zs#oC)-3LEJ;y-P8E1gb~q{_e}mr)yITurI%cL7<i$e#sbGK(}H{o+gO@BMw2N=}YC
zr9H{Hoojk&)eawtM)-WhrQ846RQWVI933gJZz_!0nAO#y;=Z@QZ4=JpG?KO$wIsI3
z0_vLln04i7I&aaI5P_F;!_RQ?5Uak8)N~X5{1}E+1Dx67I|!4TJ#Qsu2N$_xY%EQM
z94_pf!=%h&OjOJVP+@O?VH6u#+7V{}S{=p>iFv59H~VMsZT%*^I)~#XS@yN+sQf7v
ze>i;{^>a5}B;3~eYNvuul`tvyKbbLLWowj*FWftCxx>DL@8Dknegv_QkOEcDZi-ts
zv)aEOAdRGIm~>p>lpFs~j@(@<5_iT=SC39QipK1BiY$=D{xPc2I4Z$c=ITaMJb7M3
z`zIu6Y*xH*xMxle>@hQ_%<8_azAUN0BxY%F?U*}V8-tk=Zgf12gu*m8B$7Vo2#Nv%
z{-#F{2{UF}B^st{Pd6}+Qc1}5*^l@L-u;OO1mL{K$AmpnafgmoC<KW;Z8f6wd2dAe
zn@#&|h^!{y&w0H^|AP9^0y~H<XDiu1es&xtOgA-GA>K+@4$5&`;w_)fhQ~URL2aJM
zG&t+0RZdAJBxOvp3ptp<C5;(ju~7`c%S>Aco}60!zgvk8iL6U<qHkYjJqMAa=Wk|<
z6`|ZHc^k4m2?<$#<QX^*ZG?E_Z63VixW#<Fb-J^Vi0eN*<fv>L@i{vF(~3|20`WeU
z7+M`G(5Y&7P0|a{Bv^Ho^uDPfn;=%I`w<bBae?mzwHRM)nStpR(>y7RmdkwicWvwW
zMN8~TPpvcGIyCfy-@8UE1kO$)q_2`)FC^wHYb@wYLZ5VMW#rKF-?FR;{3IeUqUKa*
zEKNoZeRQ{KUqay=i(}i}wfGiLJ3-re{yp3Gy-Vt5Nu)uC5VID7Gv6VG-+@^JoT34Z
zWn00iFV>i`O5kU2S6sg^)e+zG(~3)m6sa6B%oB30JcDZRj+ltM2}@ZlI`!ILI_Bal
zl@Vu&IglRz+Nmsg{OCqdoIT_Wc<|@;L_LHDLla}%S2>GJ%Dsk7G`C!2P~t-*TSbqL
zr6JfvU#|mGF?J}n>ekk9wE=fE3x#wT51ypL-RPg6NZk7-Of8jOt`rOR9ju)T*TX{`
zr8-ZbKO@%&j$3{nyS`0JF?tP_ld;!+KIp#=*B1{Sg~4Rn`zy;@j`)f@cB$0w##lud
zuN=_w2OO3~*3GZef#yGYbNyrC@7tQ9b1N4rVb#w`c^E*3i+^vuvl;_uD(6GbV$Q&7
zSw%7h5~!9*X16ta{xDENmWDUNbAL+yN4fUxgy#Hrmi9xGTW5_2!>^!JCvHHk$`9f4
znflZ@U2hf`rJGbhFZZF;rF09PWkK0z6Al@;merOc`$}F0kjzrLnONkse&}PX1jq1L
z5Mk!=q!(02i+T6?%;-R41ZwhJN8zT07+(6vlQ=q}E_rxEL9aMVNKlMZp|Aq%bzd&@
zB~J-1%J+LYCo+u~Jv(bE>jyi$$;;TY1c(M_-obF*^KCptTzUyB*^Q22;9WviauH|3
z%<vD?{iMHRUcQZl!2XGO@j<97dh2=f+K@ipt_d?WhtHzYEgG`)HJtgwVpm=lY5&g-
z<{PY6&VZK{-%7(T?s{)N(1OXl>5-qtjcLvAoH7WYjj{(%@<HxPrNvwEb*AZ^FxBkc
zh4%k~efA3*?F=)+>i(Y0sZ@GEEi2@VeZ3*lO2%6TRjra~GQJw|`W9^AG?4==vlNAw
zbC3Ae`L=L&3<RIQ;wrqd71UbcL51a;B1k5^NjEwY<@UC*+kyEKaqIWp{^im-RH*3C
zK!2jk)eb8&b4HQEHO1mZ=bM~r36U-0Tuejj=|^r7Oh{m_Z}dfWc|7a8V?Ro$TbEr3
zy?i&)5k6bx_kF+L^COPT-`)AX=hG{OAgS~BGwvdFGZO`uw$prP&f9*XkQakj@rD^?
z*16z+^#UD7Llj@BtlFLklo8-TS}0m&feYRfmv{YNMl4@`;I>-7kFbykC!wgD?ST@M
z24y&gQ)l5t=;dA)qB(V60k2HpuocUT7`GpZQnn}S<l?MU$eL@HzoBD4keRh48MkLr
zyF{2fID}zJ<w1S(`?+^ZbY;2oTb{2kG@?os%zm|fr=L0I(ZOchvSOPXxw6o1U-`ye
z8VRURY{V$QNll>7w8@A=F{p#iW#c0RYGZVoNFXSE-sl}%#>z_iF1kjf7&unTnwT~5
znLTTWua;BFo$8(Er>1Y|ArqkUNDZRoeo%{{MkbPssO#@|Wbv0i31_Ayk!oRbbnsb6
zSYO8-<drpK0Lc2>e-cu2d!)^@@@T9XNaM4P#B+PNJ_JA6FDDd-%7U0c8a;%A?tTK5
zF|10uK7=<zF(rK7L0^3*`kZ5>&LDQr@%42bKBPLwBD1f;(%Ih0h=9)K%ZWV|s}Q_+
z+*Bp0XE8L=V8}@O^j{&I4GC>J0?e;4YWgJp!~GEq<33qw=JlI`OixZ_XZFXCky_}T
z_fJJIZ)!L*g;I=7o83AeG3RbU+#8Lj)TmQsUjw}l1o6eA%rM^0H40q;hTM$LJoFuV
zl~$@9)gJ~_U{XBrACl2Cp&fYM;#o^HZ=bHGJp)9dyKHal8w7f8#|AoYwJkX85Tz?D
z(elu-y=l2>n(yt10L9WHd`W_bJPB^2-V$2}8tfX8sv74cxBu4}Kk7Iq(?M`Plx!ZU
zkCUdUdXYCw0No2dEWA83-Mn*L^ie;u1<)%DDAP>tAI+NY>e6-)H9Z|dJTrKC+p0m>
zIgy|oicdL;OlB_)>3O&muI?{bBv34$9aALAG_D~HU-Q{Xw&{LotTg$@TWZ-k3;K-T
z(-Ne~VhUL5D(62Lm*6p!kC<pKggHsphxSjqUh3>uieL_1@H(m4XTPG%e4X&jnHY~q
z8=`6vFOafvw#LFU`3mKq9R7b*VeZz=X+6U6A_J~TA{EnY`!@IT?_iV1jK!{%h`w6x
zKH<`x46)}u+TAwx3I^P$@^|EpU(O#M3yM0cx7rZRcZR|{UxmvnrcQoWo_xY&6X5wt
z)mQwx+&E>|M{t*Ck{HBh`EC<<Lq&Py+kLwkY0cg8gAXK}3lkB8P!&q|#u2}$5BTB!
z+pqX8ev~a)R<9*kZh!AjJ@wdvwrAL4x<-Oc`Ei1W5?<=~j5UTxB;;Cu^)7!1_hl%M
z*5IXomlaecITI?C9C`*w-tfNP=Zb5I?1!p;M}t~p4LV#>i$RPEH@Rd<liCCWy^pdN
z{K3m%nb$C!iU0TC5`cUglR7vK|6pAi+@x&gOIA-wzURNAEWgl<%>Ih|O=>vb6+V$_
zb!AnZ$CEfZRaoq9;r2tsVqx)Z5Kda`EXwj*lLM2=Kkk5H-li3q%Y__2XoCnPvSIIn
zY0UW|M$A#k^QLN54SKfv_2zZep7X&Krc@>xZOVKA2cSb666cN(<Xd;T@T)VQVUc_z
z)Q5WD)=BA(p!h47e-}4-K`~45N$d}Aqtj*cv3z~U#$5Cot3<^3W;{?Hx4Js{bxN~I
zMAq-s>Q=-A1s9NS&Q-{kn~l3-i6ey=SZzIX`2Ozawp1-GSme|BH@h6p?0^`fUDLGp
z0k8-b{v8K%%kKBz7iR_StA>UdLRt0DtU#Yn#Xp577aemz;E|Kg-5t?AH{O0fDE43u
z_=y!*mS9vwxGwWp1~dk}|6_A6P8<p(_2Wh%YbtFgxl!hp)f+47?9k)>jsiaAF9?l_
zG(KzKI9?0?b>blTPa4%Rf&<%|d0BfrONpbp`-z~eRt8SF{~={<{h4wHj&nMq1nNh=
z#Q1FbmS74dHXzGv)mXSB|N3p<v!baWW$UN$mf=K9!t&i0tVgyihR<1~U~YgHvFkft
zv^k9(^l~5Zk83^|8#T;0DBSOSVCE4nZZ29Cl)Va44rxF1AD(gM)Pk8TjzpRxN~?3-
zBGG=xC#>&=&ESi9kOYZwRgHfuY@WLZp4W%LHxiif)}pWnz^pLy)=<y4*B(i6AGq=Z
zOHc8}Ny@+sqTznI#r_vC;-D0v4hgIF1Qcl9G~VT>-`}p|C;nR2WvxrWGZsZ%&VpjE
zrQWvh?tba3BqG8*h6|4^G1NR$Jeq~YiHe&mJ~%gD??c9Ch7VK84oNVt`&GQJw68CK
zcFlBt`IT7{bl6E_UnbJf@Y3XI$X8Bw+hA&~5W4)b0&UDnR!ozH?R^j`@T(6W(_<_G
zDy8H%1Ec;dS`8=KQpNt9bdBy`WpvZtF%Vy+1$yK?Eg?*7NPJ^kfW2fah~Iu=-oQ|G
z>%`}C98eRF+WNh=^gI%+<8du&inuVdL)iA`;^l()C5o+-0F;!CEaxlL*B*E4qW((5
z1b-jk%?L-dJYT6MRrYdmgyf4<5P+8x#8xY!?jxVU$}zbtn$Vv|ons0S8+99q6}fZJ
zm<w!`k{@Jdf`tD4v7&fqP&v1L?6y06-KU-)oRdk>@lJ=&h!6umb&OEYp6^@^!}%2k
zX!^(Apd3o<4BMZ?%q0?vpZV7sJb+Gt=&wPiXUcX%%1n!&FWbg8i7o#oe}4V%T&=8T
zWOF!mfwd#w%RVRUKz=%rzR)wPLQPkO#XFjxLK?XvRSt~T(#z!C5zv(tHd?3jT!2#f
z+}YlADRONmydy{7es&wVnT`5_+84|=L-28<g4}co-VErnHmw+_hD>NFYbAajPGduF
zlH3%?MFyU2VJdxYvPNCT8>mI+8(ZSTGlliW4-m>sj2J6I=l=8IcuBSl3gX0KQEX6<
zjT$8CZ8>$%FOS!PrN7QPPdFqedRoNj@=}Cl%qEOF=TgeD*qRRaSr4jRYv9nP<z1GA
zQ{JJXU9&j`QL1n|{q6fNK#q&3zjn&G>z2vN&{({)$$zBp^lcwB@4^Lu#(c45w*~e~
zr?PCUZ06^E9x6k93P&gLBF!LZY>d4Zd4bTN75M2k_cKZ4f3an043$3Wjkdf>&Q|#Z
zdaQET@_Fd2O(V)ImVcv?(pk+hD`2ZS-)|x^)lS=>A`y5{7&!LxLQ%}$cy>}Vr!K;5
zz8c-EO+{kapb-n{Us$?SJhCe@T0U4Cc516NhuH9n513q8R5%U=2pm?;Cb?Z2ABW7J
zFnxNBaYMmoGXzdGNlp%GbK#FQgyynlS2U+FCXbpI?ixQ4@kx9qJIjJX7OG|EEhw@E
z!Qq1AyeG!oy-rRUc%_E_$2H{CcPE8x726ElI-;80q`_cby(etvr)*C_*xd)))sHD&
zQyH19gza%HbX}0=EB#8lrGAsAgE!rXL)x;a7Wb0sP~yw$C3%Ugfanr3yqY+V3a@77
z62ZG&YN^wfw`v^|bk*hij>CmJ_qUx49@#8W4kLm2BYnn8^2wQ==I#wAN$(rX5#|Vd
z8n1g!b}P2!gK^eoOW43YtF`t!$CMeP|71EOqsJGRp=s+4hs?A_2$UShp7sL61FH6u
zUEp6ai%};qfnl~=o+i1Vjmh-nGY(z)fBWZ32D+j)`O`At$A7OWM;@sgEWZn}%s6NM
zkk;q^dOg3STq%jonk!zHCf;7#?S<RyyTcmIkI-^ps7Qv-7MsY|tT*p-Twva-9W>||
zC~<`E`!@aiHfo3dz}S<lw(sr2&-<1*g!`cDEq$*j(E;4-n>HQTPzT5l7nMARxNh-w
z)?~Tx@FBgnmB^e3MERnp#giDwy_8LH;6q3prE9yNyZBuB@`as^GjGSSwX!i|Ss^w0
z7zGPfBZcQ~v^GDs%H1MbR+6>cnikA^54EotZGTd(lBW`SikQIF-`@*tzpyRx4l<b|
zn}@i+fdqZ^8O=)2NJ&?MZpO9z>*_yJYoj3HF!tm2kI><ZKC2u)x48hJ<i~~GE7X@n
zEh?|8%J+Pp8)#6R3!2<zt+@y|7cUb_V<N-%4#>ppPw?{BAKbfUQLB%~34Rd2*YOA@
z)q;)=vGq?JO&b>bMS0vlw~^7>`1dtSYq_G;sGg-*<&;-M*IQfF?KpS7ZnUN3fHB@>
zZc4?iXb~>I$T@4(>Huh7F+Y~V^1}3B_I*;HKiTNW8&xulutTuC%e83H&{l%H;uG0N
zlFwuu9H3k!{tf;%2m8ZIzIrdKKf#nkRLd8Li@l^e&ljv~IBiKPVdllv6U3Y6cl_@@
zf%jN13J#)_wJQkAX^O{~R*Fx_uM!6LR5d^(@smx){SE@fjMwC_FXA2g9_N>{;{Vn6
z{Yic+NfvpZ>Kut~RXVy~r$*zmXDJ?B&_xRP!i6c8XPMdsKZlej<#W_A`CvSK@pLV@
zyr53oj`gphL-pjVzI0vVq6|Y`4g@ua`{LmZUH`EP4sFxr7q3pY(4e#4=Y8l)T_ech
z;a0>7wDSjy2m9d=?M_4By&p9*!M06QFk45eQIn@c&r)w2fp!-2ef1Q7NK>nLGs>Kx
zpT8d1I~2lh30d(B;Wza>#n)<OwqN_0>pYh5_cl-KLVo%WDaqBK_<fwRZZrR&lB#nm
z$z=BK7C4lQ%|x_!WNLw*1(c@l*-`}6{RQp)lQSC!*6r<E!q?k9R<tW%fzfxRIHuQB
zk>Bw9I?m2YgK&f}51HDceu>n7INS{+C3fzRg)zMaX*=4)-!?0A;jd6tljRrQ(rZnV
zqrh3V6uZKzu5p{{9Ga0Gd)Y^~5fV<FKj#1M8HHVhR>()Nn4+TA*l`odo~p(RQq-y2
z;aM8;QeV%ceIjpjS~9%P*m@t;s{v@|3BOuXi4YaB-QZ6$mKjggPW)R+lRTeTf5$ve
zOHmEhY*NR_Zie|ZuYT~QlWDAU$%}E(3%q`I<vP}XNdxiUByQ2PrGBKtI&0vf_@2-I
zY8TiC-4;!*3G44@#fsy-n@N&$A7aP*<M)fwUSmp-w<uag=Xj9{Emtc?4TKXE+mn%b
zImiz=pLpSNVn5VVT_b_ewIehG7gAY_>ZM9*aPqmD$onqeyZyEmCvNz(+`{I2AJA3H
zEZbi|J7*MFLzN%@O`YIZoXQ}wOQ?ak)Fu9rZ)|0G_jh-lY{dldUhY7c>RX`4@em&0
zIX11-D8Z!gIdj+@J>0#$T+2aa%x?+#`|53q&}VMc88dnRZDFqviXoM8>lOC1<*fKs
z1TJ)PzkjGyg=gF&*F9r-W^M;JW2<RqRN_n|<#9P{npWhX*Jhk3Ff8l=z;<x*{RX|Y
zTq*6a_OKiP3MWc9z2+D(_qBL2EyX@tsIM^gYCgX|WB{Ok(+DYmOX+%08!Fz3B!cgw
zEbjgaM@dC5K;%2T9^3g~T=ge2IZGs(?k<0Vg&Q?p4Y_(D?g{ZpNS~eXH`sNQ8lvBK
zWdH4#djb}AenTTvU3&2Xlg$O~7M)l!Tzb5>o<NHvFH&p2Er#iPS^AKNe_6qw3Uzzi
zQgv5z&c;7F_zlwJWBrjZ?#(FW4rZF>3jHxCGVdb#-ls<GA9Aq+Mpm<8QqYJah$;P<
zb{79T>%f4_YE5>u3>9LbKjLL3qqmjr!A(H?=P`R|-o5^Ib0`cFZO@MR58CO7GRH}p
zT$9D@V}tIa28t@HQnSOFmRyd`TX%m47vG_z<INwX`a`=5L`k7{F&Fqh_wV{@^WVW?
zRMCFzLs`1(K85=#dwR`<<w@Ylv0A{~6Zuqs*U>d$XdBR|^@#ul7r7^qlab4{UL?Bb
zw@nl@HA!TqUha$uCd@a|Vf01csF<%XB+lLjKy9xNV{cfzIYlKUgOz|YJ9>udKu@bP
zCV<!N;&IADQg{P^jxgmelpW-{fp|V7#DtkY`IXF;YNfW}7$-EdDaTbg&LUF;9>X3@
zP->>BA?Ek5!%yXKjb3x^Uuy7~q{4~_(4UD8Jc}{Zz~0#S?@Xel*{b(Hyq&Wl<zH${
z^afb|iwgj;<N%@nndYjUeYZoxms1(TbPIgdx18n2!;@!>vze&!LqO8_N*G)49vL~i
z<S2h+iJwGx_4oF+%Zqr}3lZWyFA&8q!NCk*JPFLZ)N7h0bz2mr74sZhd}wriTcF#z
zC^RUk47r%PIc9~?hO^q^<-U(g@E|M}$rsb@W6fe?=txXVx!YbKFDP()!M-_LXM6My
zHhQpgwQ1o*6E@L6s1(Cd;aK6Q(XZa{tk(6PXM3?6^F~$tV$erXVyuXaw;2D(8n`W-
zuom3{DBNklptH);TzX0=+kiVigP}re5nE6!>j__OI~hnGwf#f?Mf|cc!!`6=!Dsv6
zMDF70g8|B#5Zae??NZPCL&r-f_<z68ZuTtUe=cVHHhJ*tfz@M+RSwIqm*O9KC#T+~
zPaAIjweaUk`-Drhb#9&?&0;gB3qc^<o~!K`<Z<OZ##9Xx$ZX+9bk&K;UY#DL<7ExL
zw=P>HzQkA;()^h03kb8@V(ROlj4aq3;2(*3YOnaT^xW&MXtwSCBlG~-0BYMO#a|*H
zdq{eZ7qO^XU~o;Jtu@8@#Bb5LWxVxa?10A6cLrX2RxcV)l!KuIyL&RSGBwQ~)*A50
z%rb35Hmo6kX^fJt9E28DvpUUa7WtfI^0Q0<Kt6HgQQ8s~?$-aQBWZ6k?8fHn6Ur<W
zeWL=kWLh|;86{9gq+|dp0mp3!#(GV~iE4ib=o1Bc7ZCPAwe0P^hGC*Gw@BzvG}<|6
ztSIWEK-{kRzF+jBLK<uBg5E-{2t88%GHCaSRO&^=Rj!r<UPf5a065%#7!GZqKBWWC
z2W&sW1f=8JRYhQ4T`tAhbqISDQ=Ee)MQ^lJsT79G^JRT(91|>Vg2nCodX$U!=-Vby
ze9t6)JDlW!Ff|6L(e}&TSrMA>mChs=|3%4!nRq)n4YmDr5t@3Ksf_!9>kYDj9xLfN
z7kS6+A=NG>u}<8naYvs4E!3EGX4`M})YL)A;1-=zW94=GOuVLZ`%+2ci#xGmkhMiq
z54K#&PrJ;7Q#26y?~nDCQ3QIF5pz2{)8WhP2O)g;k?KBFowTLtymo91vrMXJ&iC&;
zaf8m^WzzAg7MH#<gJ`d_)mHn5=g99oTS(eXk6V(<O8;h-LZ2()khH}HTp__kuR%<&
z*j6?RDn*W7x{ZN=O_ATaoX*Y)mZwUW4-iu6pEz1LPRKt?4~w#0it|n+Y3qukR_3>p
z{ZF$aP>;MH%-86}FLeQr2QndD8ha=s&GGJA<#SpGvD>6t-v9@Ot)chQuMJp>sx8~Z
zfW*Z&oJ&@vQ#`9;#W&(?&XF{Z2Q-s-^5U{kZ98XepCNhQ38_pmK!XS-V`2i>LU(ii
zyW<NNTJ(MbhZ^)g@QQ-*@sQ?fG4qSO&e^k7?Uuys`gwk3a_-^0yMqKHRPNDd3B;=*
z_eYKRJ!BUacn=0!tllQ{nZ4lp^{w;I5YyP>!`sE{$&ZlaZijnEnK2*a@|@304t*}r
z!Lz$NR&rxw?2U*Nwn(&0OzVNL<5AX+QHQ2ge3Y|<UfDww8C=MO(=@kvyB0`23omY3
z*zA#6PZ=Cw%*lDf@{_i>l^2>!+HM~?Jb5WUZ$3|yp3thJ02R*hGbS3BDV35~$&R+6
zaBdf>Gw&t!EL?$hRa~;#iQ|62ChAMRyNy|a6)iZi0cD2z3J(8Id*As8SNDZGA$Ua+
z5d;w=AxaWP5E5lZ?<Gh=^yqy;bTdSW5<NOmqW8||goJ3(iBU!yW%N3RVeawX-}_hG
z`|W%=d#|(BUe9{g+H3FQ`YmNJqnd~~fsDcPI3}FxVJa+9nAJhQ3-2`u6gwq0{2q*s
zy~BQ)=<PQk4doNRAxLY>8y(nC@2L|G<+9%RV9M?{rS`JfFOUyc)kbaE1xy9V$f}a5
zSh(Zi4KpD^W3`hU%VDD7>vt0orgIhLCB7)(*oeq?Sq0^uXBJRoxt!&y(gcl3i=^+B
zhkw9!+4QTC8G^11R~Iqy=v$gcCWFs>Tc|DDuDmJ$!2P_$i+NS+9?^CvX`klj^zCD*
z9r7z3oZc*r6u`D%e*$eS<OjuItHj7$G4-C^jW~`-rfXYJ+>Q6-%JOJbKxSNYr>{)w
z$b$<aE~;tAS^(2p^Y^kI@O6jK?dq~}R<;>l<ME<O_#b<ds^>!~?>EA|#6}7wP@*K)
zMnmc?tVbH2({$ZGx~2Az8|G@^d{o65{&T$16QXr=4J@7HM<vERY}7&>@!_gD$*<&Q
z^~AF4cEK>QLGWk!^(sUbQ6FFSBjM%e#>`YaWHaa2OK*~P(}(|bCH_8vVgBl3P8R+B
zAECuHZe9NhV~=S(__CmMVJf+&)ExO6{meaSpG;a+S!34N<GEV4|Hx!q;ov{ej??eQ
zJvQidK_<5!&wdi28#f#`I<{<{`2nE$$kFgbECZP`_GGI|@o+#K*<Et-=fD<Ciyxm_
z`(~dEwz#L_vi(Fvw$3U<z0fOMaV1jTX97SD7#ioq*z?ybc%Y~j-2}a=PffxfD9mU)
zx+w?=UNXMX_$aqkmeS{=J8!LtctNa&^Wl1#A>A^8>1?J6QA#L5492tf;=WIC<q8O1
zpd~Ur2~dc&X3OgvKn9>ccN$L26BC{(oWA>PcyXAsrp0iHRHFHVl^}_$vPou+;qrbK
zC5Sho@o;{EGxiBr17d+6mLEv(bub;>yr<;b#l>!Z@NVw6PL0<D$?|d>Hd_|mb3tRs
zHe(-+$R1BT$ZclX-pS5rF>~#^eJMG_mH*<S9@28jAi~%9HF<zmYYlM3YFj7E?OKcZ
znUG<C^VoXUcww!=afZF!lYlrM2W-SyQ&a4{$2^4VI61nNXIdJ3Mfq%@BN$R9I_&av
z#kloX%;#)Lc;(Y)mnma{AljQAv06PT*ELI15@TlLV<@O8o;eMVxDrF|7g9<uB;RtL
zsA}cfO`bICX70<*Zfv+H5;V}&70Z3|ke-?4`*^G#EmK@}jbMz8k^B%+Rng_*VL78H
zsV!fi(5mW}Ii=M(bC)3eKm9(W{F**q+iL902nj>P-l-gL%C^0X%*%W+`F%s=3{~7Q
zT9#h#C`*RCfk*4O@kXQ)E;vnX5^8rehUg4fS8sIt)A8{>Tb`=#q`wo-BnMx6*B(*7
zbS7M#FeG#5mpK)HW=O(vbLtxUVo)QLt{ON@w$jc0-Xl)M+fnE-J6E4e9#6kRfI#iA
zVhU59&Qq~5u@b@hS0UIC*BhihWf6J$*1e_*W)JZkD;(yCue%0686H&nsg0}rJffbg
zI;ayuCrSCXn;~=A=PIsMqd}^a$ib6IdBG(eW4K*(D`S^0&Jd~X^r3J{WyJ~g_jye<
zN|p*wP!^N%r9~0=N)I5ATex5keLIAr9F$@Vo3P37B>?T><*t5sF?I{4{08p%H_^bd
zjp(kTWpKZ>@Ur14Ap+<Gb%*RoH=Y9o!t>OUp3_hCz+^-o#;V9HAES|+o8&h8U65sm
z(CB<wBs=s#9?e&~bAZ|pouulgQM-?6!arI*zhJ;J1g*WKtm<>Kc6PN9{1X-rIY0e#
zAairNtdX>l=W?o)(Th!m@ly5qqynBlzf)?wlgT|<W~*Y^joKLMSg)GU&a=+A2rfBp
zowy`XFh76itfC@$7kBd?5vJ<GOB_l$ATFKSI@Grr=50-)<|?Y*i*hwTFDxZewZ>Rb
zWnwDbhC|e5k5$WIVNtGU*ta6XKMgxgSROP<6dnf@bms5DPb<q{7Ok(DmBt?!ZQt&t
zcd*~6D{a<&YhaY9%~o#N7KN_$0?~phY$yZv)}wqg__oS}ki`QcM_1&0o_a9Ot{qQo
zluc=EB|+z=yjyNM>K`5F@+nJuYGu4?rANqM-Bk?VmZic&-h_#NTqh97?e?ZWLRyK?
zO^o+Yb`(koas_a5yP2<XNXU}E<@{tPFXQilwIx6Ec*ehWOiFHc3nwX#4{b6V!9g7a
zwMg|lqZ;HxbR~AhL~?L#1>C{F%0Bx!Ht6|FRomJJg>C$0dfrWDdM_u?SsE4@2XKcc
z^=6}V5r>bQV(7~B;}E@ljn6+RG{1+ToW><6K@}dmKThPV&Yf+S(5qao1J%$jhv7A2
zyW2mUDUi6zw7i0wW(GsdckR|;gjS3JS7Cs|;gTrDacj@L#urYHq&Q)dN>nCOknKf+
z3q)y8Lv5<jix%14)m@)0q`a!H664D<No-qV!?DahXb~B>d&y2-ZjD2WCK;>zFx_{!
zT;mPdIC}Z2mI4x_@lx%N*-dN?WYdBY*){X?R2YjDT#@gnP*Y6hyB}ZY6X&=R7X`%s
zMxIJ0&^XvtQ(E1}Opm>^TJ0@8gAj6NFF(g7U{BC@Do@Rn@NqgJP9dwrG(hWEQ(g9V
z@`vQ8!8{~5Qe`}`BCO~S2VA+#U@Yixnlsdt$q?%19uxpk8%sUvl!p3Txqqhp=O=iK
zSYAIlyM|%&;df|p7EF0`S=IS?VO5qdIOpx^>E|Y^Jy%eR55|O9230$I1tu~M&3`<|
zZC|tGaZpi?3h&QaDuuhnKMR6ey^4Z&7O4qzUI8&iJ!XU==)yA)W@-E@Cs9^%@r0m9
zH8iZX$N4wc>^)zl_A;o6UO$vEAlDp0%Emr<bVYo<s^c(y?Hv_1AY|&!`mHv4y>j=>
zU^~I{ZNjgx3mbGY`QoK$O9?rIb3wjW;i&>10e)5;g?bXSawJ9ipXF%kj3Dvgl$$h-
z%6*Q3qnWJiOmVrauC-pb&)--K$S$?~8T~n`*nIQljbAss#8_yVJ&;{Hd*Huhm+>Hf
zOmL~q+OjJ+!WSXhAfdP*)R;Th6Uf~H#<B&sDkX;#S~FV@-&WWVHJ5LMu6SdGd*w88
zwCJWbTJ_XrdE1Fi7GdDie2PE)Fo3P8_(!#(w!S*+3$}KgOL@YJBHm;uOqVBU{0`c<
ziSMIP&7?{kq?Ojm+?kq1Z0uLQy#-@NHl)C9^@nPISbZ^b=R|H%WgoLu3dq8v4lC3u
zZ_ptoPPJO71L%G!23r-|>?pQ2m7WCqeuSb(0l<7p*<sSm`TQc_<lFSBZ1~;j^3znx
zNH^hOeI=V>F*d0&h<+#5;$`-oK<%d;$B$3<Pz})cEVnl%v-5Lx6*_HK7_V*B-M$mH
zPnUCRH2Ey=ua!c2W^rnU-7$E$<Gk&Fh3{4d8KC{I?ZDj@YsJ0>h>3uA%B<RpV$XRK
z(;sq8ze0J)Ifuhl^o*=Zw{m5@C`s=$MZ=AAFIKQ|Hi(RKG=jB>mj&M?@$BqI`|Y1(
zOMJK5c1wVM$20pcTs6>(8?j?hnhhxPxmprjK$hJCiCU5nJ#o2>_efo~%4(k7Ie^M+
z3Q{|Iw)E6-pi=h@U#5keo<A8rxj@e<NdRtPjk;8OP#aK=vbDLU(3&OE{CE|=_(S<M
z>(ApG*cZOd`F0sULM_4>%r(9)Fg$8#u^%1rM|SWC7z}MCq>HZ<#9syJqJRde4o!X^
zP1^8}i%1Lg$f4tKE5A<UOH_Ju-0p3IoAmF-_Tl|jcM-F$r{g%8r|?2~&wZ^sD?~P5
z0$;pw@?|6F*M;JIVpgNYJF~cZ!p#i7g3~fa3LyGgY#a+4Do<m4s3R74O5r1Yg%<IJ
z)Wpvl3K8EaSwAft1$naLmC}AW8AWOGF`UHRvSUNHiDM~3h1EuI?t$KG`%|zPyA_RE
zQjjn&AIRNZs!h1+d}HDwD9h^2JwJ!O{=y==H>Rn1b9ciDfdk!%F<Y-Mob7eWcneP{
zChnBAm9%l+U4=-lXJo=c#*Rd=4zGU=ei8n9D7Yv!fK_yK7`}Q=jA2Lb4|UdM+W=JY
zDU-0{3CsEH=-ci@qU@ezZO+|wkJ*pbB6=kcfuC<bcJ1@}c*V+w<xw~9dXm4hp69?V
zlx~DMG|y#Xzj_JiqOp6f?KcGjebUd{9|sQ9Sam&To9C$n^Gp{{{drJ_jDmP46^N`u
z&G95`^aaryY?!9QjGn3#^^|St))lepeXeDq@!=mt-f=h$(Ds(|;^+;Obs&7^Eh2%T
zj!+JrLneT6uiUqjO4@SlmF3HB8c}nlgeb=G48NJ+-B8MnKg8ABh;1V@ME7raFZ>b%
zefmW8j(^T-GOI^pWUI=?^496xsqSNqMD(zZd>YkzQD@I#HLWL{a`u}W&KIGR`KNb|
zrJ6$LUBAMJ%cr&%kKJ#MuG$M+pw&*A7unC$FpfY)ts>_Gl2ZdQu2D3&@TpiK=UDW#
z)#Qbj1w1-b&+czohTVuXJ8fSGYu&PZm;l&`@r9`h_^wM@y=D~jOx$&vFg>3`B5O`{
zWP4V2QB*rS0EZsYH_?DVIUjxi4Cu#6qve1{buxMN<anDyM>Hso_OILfjUckc(4$Gp
z)RJ|Sj&Vi{H6{o6Tvv+1+NE4ti5RHjNrbM>EK~zUgtc^9x^!5}!$&SlToub7q&$wu
z2d<4?Us=$m+CTa&F7v`;dc$&0gx!E4?zfgD_dz$|wG6`xBut@iQhnAgfhzwt2}~!E
z`OuV%GqH`_Ya<?)Y1QVW0i=!~?mVh4-_e{kH*q)yo>8i`n)O6KxvED=DM-T3Oxs5$
zbbGv@ZRBBkdrz-AMu|-Y4|Tnrhx{@mf(bo}G`hwy{Zfj!L$a#_UzVbsMNmn-&~+v(
z&*-nk`uf-;zVeV`dFI&gIl(ZbIeeDys~}a&^VI2VoLMBwFZ~1I50E>9`0oIv;Yz?=
z&tXARFCj?joWW{qe7D8ds_tQn_Io4I0{iMe`;#h&?y-`<kCd(m@c?z~M?KR~4LN$W
zj8p19PonZ^F&WwKk$L8xktI>|T&)-C6R|Z7twva6U(wtbBXQnG8VSRwM`x<V<-A;u
z-}ig7eN1hpUst2OBd((pu7W^Rm<~Z$iQ5R)vTO9%xVqSn*MjWhGwTeEOw}}mXn}CX
zz(4tAY&jYuE*xLZGizpxGG1e~zdZ4ZZEgM5XU%+H;EAYOA3&5Uw&Z<ms8g<9;>S-W
z)Zj&D{J0e&I=54AU>>v9hqelo?$q_IvNdvm?Rm7ltqXmlIj=5V){`I@VUTLirimKD
zZjEeAuVy-|6~uh++!O(sjJ#l5xM(|F)c4-XA@C7<1!M)Hm)ug=sBzc9H|F~MS6*56
z{*iYT)}GMHFu>=Tv|JAwpVcWtBi%0e-z2obUe_gBdtDGiv&E{nw>PB$CY$gyU#NP4
zN|00>38xGcP%SRTRM2T+YsKj_ltRQg1)g#;gQg`Xzr`petz_C%Qig9ZfYYr}(Efrz
z(fZ7@(C(eUQi>}e?e49-qxjKshYa=+2P>=WlPAM=Ct>d4U+<_qOh8Zntt02;w173i
z;&v&{SwGon7uyGv^EBe*ex3%7c;1@B3(m4B+iOgFA_|T88sNG~L}Gx>W}^x8Gk{s|
zW>C8t1iZx&!`4U=V&b}q%01@p(WbZ<aL-x{A+=W~2kNJuv!O=Wz+s+?)%<BO4PGv8
ztPt?tY<t9Vlqa#f$O39tb^3A1@O#6sypGy#T8OR~UDjW|1y8s}1i3XmYx%Zb^l68_
zUgpXe7V<(Esn>+jKkCgTFh1H}S^jO7^E=LUrI!N&{t0jb9%`{oh!EeURae-{PuUu=
zS^7;^+cKY8(cP9WWrd3`(%bNub#1&RcM=9`iiT_nI>zi-dfh%N!|bSx`rB`rKF9~F
z=vU@uoX`1zKqlG?bwUK}`sDCus~JW%AhC<7UCp70kXffXM2N<eslYxwMv%tiNw;+U
zS~L<S2_KEq<k!l`2DaSgAjAH^zZ?w#N4TgNP1-2|GK&Nuok&X&bpXA1_ywf+4Sb`i
z16=BC{`$=N&1#y$c+iilvUdFXU!lk5id{`n+e#9(!BEokhOIq(G9R36;`f|N+jv5`
z;MU$N911^c!wjUNpgWX&jKp4U#<sP7<|f9$5FEQuP{}dP-bCOYJiG$Eyj5J0JJI#*
zx!|!O(>0Qzi8A4MdAE!n;eMLEWJgDIi-Zm$h34opuh!u;V~)5~BF#XAEBkmvu$R_}
zQJBrCFHRssC;c?jmfi3BWynvD3isbF=9|04I5_50VcTxIn1~I$;&@QbpPtgcE2Vrb
z+^eXyhIK~LrFLvxws6;YC2HeACB;+Ms(1}Arm4yIXXl+z4UYx&@#`-@pr`UPe2<M^
zZlM5Fp{=EE)!~dJ>y&EW;5GNDtx~$WbFqLEbyWSUN!zB#WnovW;Yf70I*4$1QzM-r
z%2wO@4ByZT9_2ylOq(B4pR!{nL&lUI*Q$=v%<SML`aC6B6VghEXv^+_wO>2%_Ib&B
z0O;+%U_VV~Aci=$ZMhFW8zn?gqzmtM7Vq856<l4)>Tx%>8jFCOMUR$h>=-~l+svv4
zo-JJ;Ke%w*8Rl&spag;Lh`I9n7}jPhQ_9%4($Ln*^wMEi?z>w{ES=E%&Q#uN(?wA<
zh)u@dB*Uu^h>^wHO1^}$GabRDTtI()B<}jdOhbh+&H3`ExX$Z5uT;&I{^+SH61!Pj
zWS*Z%{Csr<)NU$CzGV9<?{DvYG>4UiaH#QAV0`iDxU1gDv1&@1Z3!Pvor)oZfk6&f
zQ&e1R2c(UdQ!&)eh1*DdcI}h$XWmP6b;0>JADAt8jpndEa2&u@qie*rLK${Ipp|bx
zojR0r70S6FvP^KaZ57EKeZ_LR?>@bWwJ^tjYwoXHesJC{blx`2iz$dHe*)x^y2ACr
zLeTyEqm9j@7PWIoULzh0K|Wbi+&=0ZJ#WoQ30IHQHB<2HV7Q-T?xC6`Vd$BzAj0ly
zi~PvzD@C2iuu08VLp==x*eFQ%Yv7L;#!n1rrwM$uecd{YslV%-H;Q_;%n#`2WD^!a
z;)hO^VD>zXGW7u@W~AhCEWX_m(F_Y)fj0G~)*e!#Wi;(v*&u2}-?iUpiM`L~gJKT=
z#eM;|o~^pf<-`7=ol>NNF?HE&iPrI}93pdfNuatgc`t}>34OM1D=I0*kuvqV-(BUa
z=-$j%urmF#cfHTvKSQE%nlRK2fZcz36anl<y9aqwtqu&REMD7u#IE=8>9;R&-^udl
z+&)6-8%W*-M^6?NysY`AKBDmWB6M}s{H_tQKX0wyLazJsoF6*wh*s?v5xPa+6v>%c
zmwyicq$<;;AoOssLiNI=;l+mR*uDJPjec2v{TRX5uJ0c@*yY4sx1kKhJW!5udl1(4
zqsoqAojUcF93qn`o1gSK`Qu@c>_KXA4?9sW7nPfrQesG`yJm%hbI5|E=6me9V|Gb9
zd{4$8XHT&q%eD~3Gj$19c^|Grt{{AMne}FBkd^>toEom%a-K*$N%I~}r&iODzEs>z
zD-JZGLu2iDdb@<y+0TJ)t#|#}7xt;Qtb&;wqbJXR(%r3R^Q14UjC`M3SXXxi_J*$%
zurjy+Une%&NzF#&H3fnA2VX#!5+r>vH5)c*zIS@K>x{@}uK3gi2tefG9B@N+S&R4Q
zU2TNpeiem6D2ll8Z!%(ctq>57+$ixb3_iRH=7q|Fw7+~r+^ORu#A@S|)a5UQyN%?)
zgzezvj;6kN>%zfyyq4qOqN$5Yx~|EiRmZr=rO_Hv^p1nA9%+xQNxa=gSFNjC&^oP}
zL6ZDSE$sb5D%WGRiASh)i=Dk_-lC};CnG%&2&59TljcN=z#nd`Cuo}dF_Twly3=?>
z@f~q<3vmuRJd6%K*Nxwt)IAWTdnbGfG#B2_2*;;-CAG~v*&4cMn?5N&P!3vmtY7Wz
z(Q#RIh~L79c1s=E6NqL}bCKy6y@pCavxsgTd~dcb^P|F#dbi4%#JA3SPXpeB3KwdU
zls5?mH5%>zBKfwN16+N8q`<G}&&8*E5F%Y(4W5dCK)Pi$KTeL?Lg6yDRXVk8uPrm4
zvwi<gmV&b4Gd`tHjnPRgq^CUOoTVl^!kwhowW<<(1`EY=ZI(`miOnj;3BX?NQ~jCK
zUF!373zu1owzpCF<PK~Im~t_MLZ=@N{u*u&>lJG`_j_g84aP;~%7^fadSX22vl9g5
z4<PP#ilq$$ehB&d=wkg7K1r}QY4zK>Gb40v#9LDi`0R^<V#9)dif%tI!D7c+s_W3D
zIrdo24Wc1vn`Dn03J~9KP8-KS;V*KFEj^z#<y3OCEKK4pe$IGsSA6ftE9r^*meJcN
zVx4JU)A0B1@}B^E0)<PlgqJgI`u0YxO8<G_$tCyBdLz;QaM0{yPXiUndS_RQ2f#dh
zdz#+LRWDq+(`sX%V>yYFh@d(utL~2DE#N4&qDFj-oVLL7KvNC~I|=3r@Y)ZopB!L2
z!+Dz?GXu!|8~3L^xpk9u-XMD*JaK9no_w1a6Pt~RZOxbMe&E1!giMKSIL6^O*73xE
zNWhfGy@vjP^IpkB{o`|5I$49RwyXbT?5mm;X*SZ=+oB)w6}b#9ml;**&F}E?Xyt18
zpdflE_XLO%?aLp0*1nBmEgq+AO-v}*d1eWW1r~lWOw4GRF-VUyF76XnxhHtR{l==O
z43be;*MN+)oHO2wAKfQ92FJA#Mgn9SfQbuU?u@qOfC&d+MZ@Tc@cQ2`UZp9J5ADrw
zUXLB;OqWX$VjWK7Q_|;~`6yifBZ>d5l=rgnTgUF<P24bSt~7;=0`N^11OC?2@YJ>5
zFyUz79_A_Q+ua3E*w16`^jn>WiCZpyf~X2cJQhBTkj09+3{W^3TAX=$n<6?SetQyk
zLrb4(9}|yAQ}kWN0gudF>SHt19*`~Ir=r;w?Bxv>4w~A)H2J1n!3L~wD%?`EdmEw=
zP+vYn^2|_9l9h=s*D%J<e9L*GHA5)nyerHdU{%8P_h<0zIONS!*~5MV>193-R&_Ul
zZaUe*EFklce_CqJ+gKoY-7)^WIaM`iz%<x`*>{?J0B-t)vT{tmC#A$Cn_-2RanYN$
zmbvOOs0oNA`HEuEuJNkPnAZB@7sIgBY-gS+L=HB=Gh|&Lh~VJXOd+wVhPzQVa|HzI
zj}&DzmeDb4{*K;0b1{tt=eFL*q$(3$FU+FicCJ|-sbH0tH(DZxdT%z+Mk|94iPXN>
zx_AwTFkqtlK@^K4K@lu35{Il#l>K46zGq1LyiN>stze5E2ydXUtGM}<m+a`}gkrj>
z!`At))~{ZH6RqgRwTm>2jdJbhQ*(DX-nBMOi|3Rnoe^1ZbKi`PhR@s=Zv~QOesrvr
zC+Hm|wN*dbdUg0K4;*=}Kd5~C&!jAEY#}Cw{0n-#7&;bOMW{<UCkK6!3#0DRiSl=9
z%Y3-YXSyDg@53c4K1hqFk~ftW$@E4Ch6GH@t!-s2H-Eh&qy4>1O1so!Rqn%#5M;`7
z`az!@KE)T<dce6*TcuYTC(=v30NKnqw2z|UZ)y<>_1<CR<r8XG=VqVyS=?|fTeA=y
zBiny3S{@ccmu)tthdrf+oI?JU<7FmQ*CdVRV-MBOt+FGeQ>v7Pca8C?eu<-mWZznE
z7FSey&-R1S4Z51(vng!qI-g{tfyLJ&*2fA5MA+HH#jMlS1<<ln&^D>Bvs{Y<9VWc%
zL(RKTo38@WN1M2^|2s#veqL4C-;8C;+~Byqb)leUrvqC|7Z0?iKZii<0epoqNYL5%
zWOZXr0d2s>8jagQd2868CoBC^+py16AFmc4i`x?Fn}I{tUgExUnO!2nN{X8$L1m+Z
z)LDWf-^Jm}z;Df{%IDm1(P>|-&$19|<-ftFr}Xb-Cgzs22+z&|Yy)*Ie~T*1{iv=#
zJ&V%1t|_)1>YqsRT4ePaPSGK%TGSc*)cQ>{=9l#IX?wY~zm}NU^#)kiCBi*@WWeup
zTzDi9@AmGYCek6}#-!!}qWL@~PQ!FDj$tX#t|&A&`RB6MEv{4-J%fyGja(vT{kze7
z*5pB}YH6Qo)(81x#3q*RIl?+ZH2Ly_<!i+;@j62TlSIx`u+VLL!@IsGGAunK9wG70
z9oBAswRJFCYtZ>#z$Nhlsib&W!g&pMb5p%ZY<Hm8Hf-RlXmH}Tg$FcW?Q=d?ob=T9
z^36!43~o~ARoGH!`5)?(m1;GOPnA@OPKtP9i+rpR*c)eL2m!2hef1c)86$kUA){5(
z_r0X$>m!!I?=8_%@%b~TkN7&)0Ux%2%U}XfM-zfSxU_g8ysszw#V+rGhRk`Ard4P+
z?(>va(X|4d#Lp9&4HJGBM5*AJRHI#7lRKU!kdz<tr@n<4uk)7L!IqBfx2)d}M$`Ms
z`={c-g1Gtbg0N5&U`*WLV{CyuO&nyio@ld<Rg~dAj*x~>_v2G@x`*HYlhQg!h)pY6
ztw4zb>e79&EtOQQp)Yo=%U9(!!KH`fh7<}*COvys2zl&X9y}KYP=lv1z)HX5+On#l
zjc+p~M+jOII{4|*oO&om_topCf77jHQ)quX(%{t6qTXZ};fgh;Q{7PB2W3}*wZR#n
zpS54AG5fkj@(0DzY$te@?i0P;_DNaM*tR|P+4p<ba91>@lrnbaSM5bo&gasFyDwJ;
z=m!=&E1n|R_&tRw@uD+(w)rUIL=23@EWjI6PhvP>@H3sDQU}($x$M{uR-jW@h%d`Q
z*gVEZkdMK3a=jblda75I6a2T4c;`q2p#_b@gBF2Y!=z(IJjJ4Zzr(mPc`s>~<||(*
zQB<^x+hVo^sqf`~X&n&aq^UuK3!Wfz%Fzk2d+$y}pj`BND!(;<Ga~5PNa(e;de43(
zy@?J=KT9y|Xa=;H#QLYg@IzN4cEZ>sS!<$X@V3Q7V}qGv*EAWL0=kO(2N;#n|KOcf
zgT-SzpJMrnt;yF{`*iesm7K0w)Mhkrn{{|%o@M*EN*j%7BRjkH>5W-R^(ga*+8NA`
zQkuD1tp=@4uLDpd*glKZM|ANXcEV<rCk?&CXwX;3skNf`L0hFiuuT<0{rBsOH?7Xs
zBRzI+0|D2+05}b&2i9J%6MoN>Wil4%SAECBTMPW_Ro3u}6APx=P+o_-dJ_YEeJ-q$
zAK3<CYlII~W14cgVfg-Y9$PlRewJZ^wm^#BWhm)`mt(eGB8T0wcaunSqihAJ%Fu(s
z25J`g;m+`i{=*Y;Ag;bdCGTzQ*lR5x@)Ol(&1s^(Wh-&fhF&A?+qfG?c8JzSbTt^2
zoQg(KRbZSfPK|o0NNjU&W_dIkH-KKQ@QRII(U=Y50Cf8Ir-A!amn{q4HPJC=gAc7M
zF~5F6JaT9Y>)QY04Kr$4A2EEh<G$OX;Jc#^=(k;{VO|CK8rZ`Wi5LF!mNP`cS)jom
zJrs}rRTUd&@6a(7BFmb3=5<oZ?X$99OX>7w>HM1!#|V-YzX2uopDP0N6c`2sTKh$|
zR6MAwkZ64J<jCVte$8auqCPv+C>?d*;~&&jJV$R41EX5kSTEhX<0Ry!bd(2nB4;Av
z{=I+Sj$0IFeqkph==1q@xVw}MuJL$JaR40LeR#kACcdzNJGwlkyprq)DE~~(jzLB1
zMvLeVt@3x`6N3IX!1YHryVN*E^iyyDYC(}WDgTb!7%8OS{j1(H)*GFb@s=~;C}D6@
zZF<{-S{bO2|2t`Tgm>L~YDQzBURl=XYCUe1&_RJQj5D{BI9p>knC+pQ8{bcL2^nSJ
zC~XV(4iA^T!b>2sUcUN?Y{}^O<3wTGJ+h?@|AKmb_gP+Qr?HGeyeeMF@=mEObH!CL
za^bK(2dquc%&Aiw&zBN#HRTujm=m9<CXtri(k3l7z*?7Mwf`&#*kfMv7o5;RH~mF*
zg{k|OD(WhtMCATNP6q3GHfa3{@@sfzz&?`R%HhgPC#ROY?Z)f9wO(v}z`G-j0NnF(
z7!YlK8WWH>VZ9|fXJkhl?)5*k6s9udsw`-_@sl={RDg*Wv7wN1dY&p8z~jKap~|bf
ze&~MXL}_O#t&VpF!uUTsCf$|dPuIW22hDG#r8#o=_BB@fD_3xMw?fI^MZRpN-Igz;
zyUIXQ?7wsJI{*;30<=I$T<g*v&cDMJtbbjL@Bz5FziB#urlNLrz)F+vxo5g`YsDzp
zydyb$wMA#>)_+P&9+qfdPbmBe-g~xrLsURDLML9xt|i_pTniFsks>M1b}d-S^JKt5
z%45Xajai6vPFeca&41^$yiBXla*u$!k0ALWZqV;lZ`dJVxu*Ovk{T<%&|ZtC<Q<0d
zPChfT`8SCF^qiL^#K`t1`U8S7SlmiqbTe@4i<^|ve~ZE1*#LAA0GpFXpNtLEIA;BL
zp)h?=Ax>xX>{=sn4e&6ZV0$Slpy~Zz0d!x(am3Pc)<qXTPeN73Zc{g71KBk)d@YMs
zhrp4aHH%mE*@9m%OirQM7UOT(MtaG>FW+o8&AHhH%W<{yVRoSTgS;_G;&2SNs$lWd
zZuW=iv;JHyDSJcR#Kq#)fhcN=z53sDV<#pC`htAMX2x7vXRK-1=o$9r%*`7AojPF8
z`d^7mSU>!z_YOJOr}8be8miO!?j<H&oYRNlaV+cs1W`Maa11LXLziCrPZ041wnf4Z
z5s@JaHA&Xe?Xue`wF`7RB1Ua}-9uk^uWz~kPN>1j?7TZq8%x=N{AaTU%<=R^Vp)s5
z*>f?UEe!MeWcJQRSzD~5Gqr0Ke0tLZhdoorHBmS;bxK$#p26gc<^6E=XK*mx|KtSq
vCr$Mu|MemeNbi5cg80q;|I_~~I=FytrDNz!LzAj67p{_=x@?)WiU0ora!m`g

literal 0
HcmV?d00001

diff --git a/static/images/dbt-athena-long.png b/static/images/dbt-athena-long.png
new file mode 100644
index 0000000000000000000000000000000000000000..22cb5ccddbd8d87a54eb197bc830f42c5cd36cbe
GIT binary patch
literal 152087
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
MTr)2}?-uue0MFR=<^TWy

literal 0
HcmV?d00001


From 02c21a38527635e2db4f9c8790f1011ae6b49812 Mon Sep 17 00:00:00 2001
From: Mattia <5013654+mattiamatrix@users.noreply.github.com>
Date: Sat, 8 Apr 2023 17:04:27 +0100
Subject: [PATCH 19/75] docs: update readme (#204)

---
 README.md | 78 +++++++++++++++++++++----------------------------------
 1 file changed, 30 insertions(+), 48 deletions(-)

diff --git a/README.md b/README.md
index 6a314221..0635a8a5 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,12 @@
-[![pypi](https://badge.fury.io/py/dbt-athena-community.svg)](https://pypi.org/project/dbt-athena-community/)
-<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-[![All Contributors](https://img.shields.io/badge/all_contributors-4-orange.svg?style=flat-square)](#contributors-)
-<!-- ALL-CONTRIBUTORS-BADGE:END -->
-[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![Stats: pepy](https://pepy.tech/badge/dbt-athena-community/month)](https://pepy.tech/project/dbt-athena-community)
+<p align="center">
+    <img src="https://raw.githubusercontent.com/dbt-athena/dbt-athena/main/static/images/dbt-athena-long.png" />
+    <a href="https://pypi.org/project/dbt-athena-community/"><img src="https://badge.fury.io/py/dbt-athena-community.svg" /></a>
+    <a href="https://pycqa.github.io/isort/"><img src="https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336" /></a>
+    <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg" /></a>
+    <a href="https://pepy.tech/project/dbt-athena-community"><img src="https://pepy.tech/badge/dbt-athena-community/month" /></a>
+</p>
 
-# dbt-athena
+## Features
 
 * Supports dbt version `1.4.*`
 * Supports [Seeds][seeds]
@@ -34,6 +34,9 @@
 [snapshots]: https://docs.getdbt.com/docs/build/snapshots
 [persist-docs]: https://docs.getdbt.com/reference/resource-configs/persist_docs
 
+
+## Quick Start
+
 ### Installation
 
 * `pip install dbt-athena-community`
@@ -103,9 +106,10 @@ _Additional information_
 * `threads` is supported
 * `database` and `catalog` can be used interchangeably
 
-### Models
 
-#### Table Configuration
+## Models
+
+### Table Configuration
 
 * `external_location` (`default=none`)
   * If set, the full S3 path in which the table will be saved. (Does not work with Iceberg table).
@@ -134,7 +138,7 @@ _Additional information_
   * lf tags to associate with the table columns
   * format: `{"tag1": {"value1": ["column1": "column2"]}}`
 
-#### Table location
+### Table location
 
 The location in which a table is saved is determined by:
 
@@ -154,8 +158,7 @@ or setting up the value for groups of model in dbt_project.yml.
 
 > Note: when using a work group with a default output location configured, `s3_data_naming` and any configured buckets are ignored and the location configured in the work group is used.
 
-
-#### Incremental models
+### Incremental models
 
 Support for [incremental models](https://docs.getdbt.com/docs/build/incremental-models).
 
@@ -169,7 +172,7 @@ data (e.g. great for log or historical data).
 * `merge`: Conditionally updates, deletes, or inserts rows into an Iceberg table. Used in combination with `unique_key`.
 Only available when using Iceberg.
 
-#### On schema change
+### On schema change
 
 `on_schema_change` is an option to reflect changes of schema in incremental models.
 The following options are supported:
@@ -180,8 +183,7 @@ The following options are supported:
 
 In detail, please refer to [dbt docs](https://docs.getdbt.com/docs/build/incremental-models#what-if-the-columns-of-my-incremental-model-change).
 
-
-#### Iceberg
+### Iceberg
 
 The adapter supports table materialization for Iceberg.
 
@@ -216,7 +218,7 @@ It is possible to use iceberg in an incremental fashion, specifically 2 strategi
 * `merge`: must be used in combination with `unique_key` and it's only available with Engine version 3.
    It performs an upsert, new record are added, and record already existing are updated
 
-#### High available table materialization
+### High available table materialization
 The current implementation of the table materialization can lead to downtime, as target table is dropped and re-created.
 To have the less destructive behavior it's possible to use `table='table_hive_ha'` materialization.
 **table_hive_ha** leverage the table versions feature of glue catalog, creating a tmp table and swapping
@@ -231,7 +233,6 @@ This materialization is only available for `table_type=hive` and requires using
     s3_data_naming='table_unique'
 ) }}
 
-
 select
   'a' as user_id,
   'pi' as user_name,
@@ -245,7 +246,7 @@ select
 
 By default, the materialization keeps the last 4 table versions, you can change it that setting `versions_to_keep`.
 
-##### Known issues
+#### Known issues
 * When swapping from a table with partitions to a table without (and the other way around), there could be a little downtime.
   In case high performances are needed consider bucketing instead of partitions
 * By default, Glue "duplicate" the versions internally, so the last 2 versions of a table point to the same location
@@ -253,19 +254,19 @@ By default, the materialization keeps the last 4 table versions, you can change
 * The macro athena__end_of_time needs to be overwritten by the user if using Athena v3 since it requires a precision parameter for timestamps
 
 
-### Snapshots
+## Snapshots
 
 The adapter supports snapshot materialization. It supports both timestamp and check strategy. To create a snapshot create a snapshot file in the snapshots directory. If directory does not exist create one.
 
-#### Timestamp strategy
+### Timestamp strategy
 
 To use the timestamp strategy refer to the [dbt docs](https://docs.getdbt.com/docs/build/snapshots#timestamp-strategy-recommended)
 
-#### Check strategy
+### Check strategy
 
 To use the check strategy refer to the [dbt docs](https://docs.getdbt.com/docs/build/snapshots#check-strategy)
 
-#### Hard-deletes
+### Hard-deletes
 
 The materialization also supports invalidating hard deletes. Check the [docs](https://docs.getdbt.com/docs/build/snapshots#hard-deletes-opt-in) to understand usage.
 
@@ -301,7 +302,6 @@ model.sql
     materialized='table'
 ) }}
 
-
 SELECT
     ROW_NUMBER() OVER () AS id
     , *
@@ -322,8 +322,6 @@ timestamp strategy - model_snapshot_1
     )
 }}
 
-
-
 SELECT *
 
 from {{ ref('model') }}
@@ -407,11 +405,12 @@ def model(dbt, session):
 * Incremental models do not fully utilize spark capabilities. They depend on existing sql based logic.
 * Snapshots materializations are not supported.
 
-### Contributing
+
+## Contributing
 
 This connector works with Python from 3.7 to 3.11.
 
-#### Getting started
+### Getting started
 
 In order to start developing on this adapter clone the repo and run this make command (see [Makefile](Makefile)) :
 
@@ -426,20 +425,19 @@ It will :
 
 Next, adjust `.env` file by configuring the environment variables to match your Athena development environment.
 
-#### Running tests
+### Running tests
 
 We have 2 different types of testing:
 * **unit testing**: you can run this type of tests running `make unit_test`
 * **functional testing**: you must have an AWS account with Athena setup in order to launch this type of tests and have a `.env` file in place with the right values.
   You can run this type of tests running `make functional_test`
 
-
 All type of tests can be run using `make`:
 ```bash
 make test
 ```
 
-#### Pull Request
+### Pull Request
 
 * Create a commit with your changes and push them to a
   [fork](https://docs.github.com/en/get-started/quickstart/fork-a-repo).
@@ -449,29 +447,13 @@ make test
   [conventionalcommits](https://www.conventionalcommits.org).
 * Pull request body should describe _motivation_.
 
-## Credits
-The following acknowledges the Maintainers for this repository, those who have Contributed to this repository (via bug reports, code, design, ideas, project management, translation, testing, etc.), and any other References utilized.
-
-### Maintainers
-The following individuals are responsible for curating the list of issues, responding to pull requests, and ensuring regular releases happen.
-
-* [nicor88](https://github.com/nicor88)
-* [Jrmyy](https://github.com/Jrmyy)
-* [jessedobbelaere](https://github.com/jessedobbelaere)
-* [mattiamatrix](https://github.com/mattiamatrix)
-* [thenaturalist](https://github.com/thenaturalist)
-
-### Contributors
-Thank you to all the people who have already contributed to this repository via bug reports, code, design, ideas, project management, translation, testing, etc.
-
-* [Tomme](https://github.com/Tomme) - Wrote the initial version.
-* [Lemiffe](https://github.com/lemiffe) - Logo design.
 
 ## Resources
 * [Athena CREATE TABLE AS](https://docs.aws.amazon.com/athena/latest/ug/create-table-as.html)
 * [dbt-labs/dbt-core](https://github.com/dbt-labs/dbt-core)
 * [laughingman7743/PyAthena](https://github.com/laughingman7743/PyAthena)
 
+
 ## Contributors ✨
 
 Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

From 8c850a9bb1c0f9a528863b00969ab982f2b300c6 Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
 <46447321+allcontributors[bot]@users.noreply.github.com>
Date: Sat, 8 Apr 2023 18:04:23 +0100
Subject: [PATCH 20/75] docs: add Tomme as a contributor for maintenance (#214)

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>
---
 .all-contributorsrc | 10 ++++++++++
 README.md           |  1 +
 2 files changed, 11 insertions(+)

diff --git a/.all-contributorsrc b/.all-contributorsrc
index 1423ee17..4dae74d3 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -43,6 +43,16 @@
       "contributions": [
         "maintenance"
       ]
+    },
+    {
+      "login": "Tomme",
+      "name": "Tom",
+      "avatar_url": "https://avatars.githubusercontent.com/u/932895?v=4",
+      "profile": "https://github.com/Tomme",
+      "contributions": [
+        "maintenance",
+        "code"
+      ]
     }
   ],
   "contributorsPerLine": 7,
diff --git a/README.md b/README.md
index 0635a8a5..65e9c80f 100644
--- a/README.md
+++ b/README.md
@@ -468,6 +468,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
       <td align="center" valign="top" width="14.28%"><a href="https://jessedobbelae.re"><img src="https://avatars.githubusercontent.com/u/1352979?v=4?s=100" width="100px;" alt="Jesse Dobbelaere"/><br /><sub><b>Jesse Dobbelaere</b></sub></a><br /><a href="https://github.com/dbt-athena/dbt-athena/issues?q=author%3Ajessedobbelaere" title="Bug reports">🐛</a> <a href="#maintenance-jessedobbelaere" title="Maintenance">🚧</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/lemiffe"><img src="https://avatars.githubusercontent.com/u/7487772?v=4?s=100" width="100px;" alt="Lemiffe"/><br /><sub><b>Lemiffe</b></sub></a><br /><a href="#design-lemiffe" title="Design">🎨</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/Jrmyy"><img src="https://avatars.githubusercontent.com/u/9251353?v=4?s=100" width="100px;" alt="Jérémy Guiselin"/><br /><sub><b>Jérémy Guiselin</b></sub></a><br /><a href="#maintenance-Jrmyy" title="Maintenance">🚧</a></td>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/Tomme"><img src="https://avatars.githubusercontent.com/u/932895?v=4?s=100" width="100px;" alt="Tom"/><br /><sub><b>Tom</b></sub></a><br /><a href="#maintenance-Tomme" title="Maintenance">🚧</a> <a href="https://github.com/dbt-athena/dbt-athena/commits?author=Tomme" title="Code">💻</a></td>
     </tr>
   </tbody>
 </table>

From 0f50a014d8d0b27fcd83b86f51887c766eb1506f Mon Sep 17 00:00:00 2001
From: "allcontributors[bot]"
 <46447321+allcontributors[bot]@users.noreply.github.com>
Date: Sat, 8 Apr 2023 18:11:11 +0100
Subject: [PATCH 21/75] docs: add mattiamatrix as a contributor for maintenance
 (#216)

Co-authored-by: allcontributors[bot] <46447321+allcontributors[bot]@users.noreply.github.com>
---
 .all-contributorsrc | 9 +++++++++
 README.md           | 1 +
 2 files changed, 10 insertions(+)

diff --git a/.all-contributorsrc b/.all-contributorsrc
index 4dae74d3..64dbdba5 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -53,6 +53,15 @@
         "maintenance",
         "code"
       ]
+    },
+    {
+      "login": "mattiamatrix",
+      "name": "Mattia",
+      "avatar_url": "https://avatars.githubusercontent.com/u/5013654?v=4",
+      "profile": "https://github.com/mattiamatrix",
+      "contributions": [
+        "maintenance"
+      ]
     }
   ],
   "contributorsPerLine": 7,
diff --git a/README.md b/README.md
index 65e9c80f..c4740c17 100644
--- a/README.md
+++ b/README.md
@@ -469,6 +469,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/lemiffe"><img src="https://avatars.githubusercontent.com/u/7487772?v=4?s=100" width="100px;" alt="Lemiffe"/><br /><sub><b>Lemiffe</b></sub></a><br /><a href="#design-lemiffe" title="Design">🎨</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/Jrmyy"><img src="https://avatars.githubusercontent.com/u/9251353?v=4?s=100" width="100px;" alt="Jérémy Guiselin"/><br /><sub><b>Jérémy Guiselin</b></sub></a><br /><a href="#maintenance-Jrmyy" title="Maintenance">🚧</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/Tomme"><img src="https://avatars.githubusercontent.com/u/932895?v=4?s=100" width="100px;" alt="Tom"/><br /><sub><b>Tom</b></sub></a><br /><a href="#maintenance-Tomme" title="Maintenance">🚧</a> <a href="https://github.com/dbt-athena/dbt-athena/commits?author=Tomme" title="Code">💻</a></td>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/mattiamatrix"><img src="https://avatars.githubusercontent.com/u/5013654?v=4?s=100" width="100px;" alt="Mattia"/><br /><sub><b>Mattia</b></sub></a><br /><a href="#maintenance-mattiamatrix" title="Maintenance">🚧</a></td>
     </tr>
   </tbody>
 </table>

From e73ef901205b60c74c3b98c34c73d017489f4b91 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 10 Apr 2023 20:11:29 +0200
Subject: [PATCH 22/75] chore: Update pytest requirement from ~=7.2 to ~=7.3
 (#218)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 dev-requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev-requirements.txt b/dev-requirements.txt
index d5226c01..15a7a88e 100644
--- a/dev-requirements.txt
+++ b/dev-requirements.txt
@@ -7,6 +7,6 @@ isort~=5.11
 moto~=4.1.6
 pre-commit~=2.21
 pyparsing~=3.0.9
-pytest~=7.2
+pytest~=7.3
 pytest-cov~=4.0
 pyupgrade~=3.3

From 8f17ea98e1dd22930376d2dc3ed26d8d9606473b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 14 Apr 2023 09:27:26 +0200
Subject: [PATCH 23/75] chore: Update pyathena requirement from ~=2.23 to
 ~=2.24 (#217)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: nicor88 <6278547+nicor88@users.noreply.github.com>
Co-authored-by: Jeremy Guiselin <jeremy.guiselin@jobteaser.com>
---
 requirements.txt | 2 +-
 setup.py         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index e9791850..6e5c874f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
 boto3~=1.26
 dbt-core~=1.4.5
-pyathena~=2.23
+pyathena~=2.24
 tenacity~=8.2
diff --git a/setup.py b/setup.py
index 1a79baa8..0e2cf9b6 100644
--- a/setup.py
+++ b/setup.py
@@ -51,7 +51,7 @@ def _get_package_version():
         # In order to control dbt-core version and package version
         "boto3~=1.26",
         "dbt-core~=1.4.5",
-        "pyathena~=2.23",
+        "pyathena~=2.24",
         "tenacity~=8.2",
     ],
 )

From e461f0a52601f225dc6209044a4343d653a9d7a1 Mon Sep 17 00:00:00 2001
From: Jesse Dobbelaere <jesse@dobbelae.re>
Date: Fri, 14 Apr 2023 10:20:30 +0200
Subject: [PATCH 24/75] fix: broken drop view query (#221)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Jérémy Guiselin <9251353+Jrmyy@users.noreply.github.com>
---
 dbt/include/athena/macros/adapters/relation.sql | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/dbt/include/athena/macros/adapters/relation.sql b/dbt/include/athena/macros/adapters/relation.sql
index cc1e7bcb..5eb5559f 100644
--- a/dbt/include/athena/macros/adapters/relation.sql
+++ b/dbt/include/athena/macros/adapters/relation.sql
@@ -5,7 +5,11 @@
       {%- do adapter.clean_up_table(relation.schema, relation.table) -%}
     {%- endif %}
     {% call statement('drop_relation', auto_begin=False) -%}
-      drop {{ relation.type }} if exists {{ relation.render_hive() }}
+      {%- if relation.type == 'view' -%}
+        drop {{ relation.type }} if exists {{ relation.render() }}
+      {%- else -%}
+        drop {{ relation.type }} if exists {{ relation.render_hive() }}
+      {% endif %}
     {%- endcall %}
   {%- endif %}
 {% endmacro %}

From 386ec47cb11b32b0f51d4ceb86e9415e35450b03 Mon Sep 17 00:00:00 2001
From: Julian Steger <108534789+juliansteger-sc@users.noreply.github.com>
Date: Fri, 14 Apr 2023 10:46:18 +0200
Subject: [PATCH 25/75] fix: allow to set table location when output location
 is configured but not enforced (#223)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Jérémy Guiselin <9251353+Jrmyy@users.noreply.github.com>
---
 dbt/adapters/athena/impl.py                   | 14 +++++++++++---
 .../models/table/create_table_as.sql          |  6 ++++--
 tests/unit/test_adapter.py                    | 17 ++++++++++++-----
 tests/unit/utils.py                           | 19 ++++++++++++++++++-
 4 files changed, 45 insertions(+), 11 deletions(-)

diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index e42b6f16..c66a6f62 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -152,7 +152,7 @@ def add_lf_tags(
                         logger.debug(self.parse_lf_response(response, database, table, columns, {tag_key: tag_value}))
 
     @available
-    def get_work_group_output_location(self) -> Optional[str]:
+    def is_work_group_output_location_enforced(self) -> bool:
         conn = self.connections.get_thread_connection()
         creds = conn.credentials
         client = conn.handle
@@ -162,13 +162,21 @@ def get_work_group_output_location(self) -> Optional[str]:
 
         if creds.work_group:
             work_group = athena_client.get_work_group(WorkGroup=creds.work_group)
-            return (
+            output_location = (
                 work_group.get("WorkGroup", {})
                 .get("Configuration", {})
                 .get("ResultConfiguration", {})
-                .get("OutputLocation")
+                .get("OutputLocation", None)
             )
 
+            output_location_enforced = (
+                work_group.get("WorkGroup", {}).get("Configuration", {}).get("EnforceWorkGroupConfiguration", False)
+            )
+
+            return output_location is not None and output_location_enforced
+        else:
+            return False
+
     @available
     def s3_table_prefix(self, s3_data_dir: Optional[str]) -> str:
         """
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index 5205a14b..28f06f21 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -14,7 +14,7 @@
 
   {%- set location_property = 'external_location' -%}
   {%- set partition_property = 'partitioned_by' -%}
-  {%- set work_group_output_location = adapter.get_work_group_output_location() -%}
+  {%- set work_group_output_location_enforced = adapter.is_work_group_output_location_enforced() -%}
   {%- set location = adapter.s3_table_location(s3_data_dir, s3_data_naming, relation.schema, relation.identifier, external_location, temporary) -%}
 
   {%- if materialized == 'table_hive_ha' -%}
@@ -48,7 +48,9 @@
     with (
       table_type='{{ table_type }}',
       is_external={%- if table_type == 'iceberg' -%}false{%- else -%}true{%- endif %},
-      {{ location_property }}='{{ location }}',
+      {%- if not work_group_output_location_enforced -%}
+        {{ location_property }}='{{ location }}',
+      {%- endif %}
     {%- if partitioned_by is not none %}
       {{ partition_property }}=ARRAY{{ partitioned_by | join("', '") | replace('"', "'") | prepend("'") | append("'") }},
     {%- endif %}
diff --git a/tests/unit/test_adapter.py b/tests/unit/test_adapter.py
index d69bdc69..68c592ea 100644
--- a/tests/unit/test_adapter.py
+++ b/tests/unit/test_adapter.py
@@ -723,16 +723,23 @@ def test_upload_seed_to_s3_external_location(self, aws_credentials):
     @mock_athena
     def test_get_work_group_output_location(self, aws_credentials):
         self.adapter.acquire_connection("dummy")
-        self.mock_aws_service.create_work_group_with_output_location(ATHENA_WORKGROUP)
-        work_group_location = self.adapter.get_work_group_output_location()
-        assert work_group_location is not None
+        self.mock_aws_service.create_work_group_with_output_location_enforced(ATHENA_WORKGROUP)
+        work_group_location_enforced = self.adapter.is_work_group_output_location_enforced()
+        assert work_group_location_enforced
 
     @mock_athena
     def test_get_work_group_output_location_no_location(self, aws_credentials):
         self.adapter.acquire_connection("dummy")
         self.mock_aws_service.create_work_group_no_output_location(ATHENA_WORKGROUP)
-        work_group_location = self.adapter.get_work_group_output_location()
-        assert work_group_location is None
+        work_group_location_enforced = self.adapter.is_work_group_output_location_enforced()
+        assert not work_group_location_enforced
+
+    @mock_athena
+    def test_get_work_group_output_location_not_enforced(self, aws_credentials):
+        self.adapter.acquire_connection("dummy")
+        self.mock_aws_service.create_work_group_with_output_location_not_enforced(ATHENA_WORKGROUP)
+        work_group_location_enforced = self.adapter.is_work_group_output_location_enforced()
+        assert not work_group_location_enforced
 
     @mock_athena
     @mock_glue
diff --git a/tests/unit/utils.py b/tests/unit/utils.py
index 70fa3aac..9607b432 100644
--- a/tests/unit/utils.py
+++ b/tests/unit/utils.py
@@ -291,7 +291,7 @@ def create_table_without_table_type(self, table_name: str):
             },
         )
 
-    def create_work_group_with_output_location(self, work_group_name: str):
+    def create_work_group_with_output_location_enforced(self, work_group_name: str):
         athena = boto3.client("athena", region_name=AWS_REGION)
         athena.create_work_group(
             Name=work_group_name,
@@ -308,6 +308,23 @@ def create_work_group_with_output_location(self, work_group_name: str):
             },
         )
 
+    def create_work_group_with_output_location_not_enforced(self, work_group_name: str):
+        athena = boto3.client("athena", region_name=AWS_REGION)
+        athena.create_work_group(
+            Name=work_group_name,
+            Configuration={
+                "ResultConfiguration": {
+                    "OutputLocation": "s3://pre-configured-output-location/",
+                },
+                "EnforceWorkGroupConfiguration": False,
+                "PublishCloudWatchMetricsEnabled": True,
+                "EngineVersion": {
+                    "SelectedEngineVersion": "Athena engine version 2",
+                    "EffectiveEngineVersion": "Athena engine version 2",
+                },
+            },
+        )
+
     def create_work_group_no_output_location(self, work_group_name: str):
         athena = boto3.client("athena", region_name=AWS_REGION)
         athena.create_work_group(

From 067d66f7ac7019d33cb7045408812729776809cc Mon Sep 17 00:00:00 2001
From: CommonCrisis <44769652+CommonCrisis@users.noreply.github.com>
Date: Fri, 14 Apr 2023 14:52:11 +0200
Subject: [PATCH 26/75] fix: reading README.md (#225)

---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 0e2cf9b6..879fbaa5 100644
--- a/setup.py
+++ b/setup.py
@@ -6,7 +6,7 @@
 
 this_directory = os.path.abspath(os.path.dirname(__file__))
 
-with open(os.path.join(this_directory, "README.md")) as f:
+with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
     long_description = f.read()
 
 package_name = "dbt-athena-community"

From 1beb024cea23838ea5cb10a7339df8ed3c8f2184 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 21 Apr 2023 01:06:17 -0300
Subject: [PATCH 27/75] Added tests

---
 dbt/adapters/athena/python_submissions.py |  63 ++++----
 tests/conftest.py                         |  34 +----
 tests/unit/test_python_submissions.py     | 167 ++++++++++++++++++++--
 3 files changed, 193 insertions(+), 71 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index d1ba83dc..9433aff1 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -47,14 +47,11 @@ class AthenaPythonJobHelper(PythonJobHelper):
     """
 
     def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
-        self.identifier = parsed_model["alias"]
-        self.schema = parsed_model["schema"]
         self.parsed_model = parsed_model
         self.timeout = self.get_timeout()
         self.polling_interval = DEFAULT_POLLING_INTERVAL
-        self.region_name = credentials.region_name
-        self.profile_name = credentials.aws_profile_name
-        self.spark_work_group = credentials.spark_work_group
+        self.credentials = credentials
+        self.athena_client = self.athena_client()
 
     @property
     @lru_cache()
@@ -75,7 +72,17 @@ def session_id(self) -> str:
         return session_info.get("SessionId")
 
     @property
-    @lru_cache()
+    def identifier(self) -> str:
+        return self.parsed_model["alias"]
+
+    @property
+    def schema(self) -> str:
+        return self.parsed_model["schema"]
+
+    @property
+    def spark_work_group(self) -> str:
+        return self.credentials.spark_work_group
+
     def athena_client(self) -> Any:
         """
         Get the AWS Athena client.
@@ -87,7 +94,9 @@ def athena_client(self) -> Any:
             Any: The Athena client object.
 
         """
-        return boto3.session.Session(region_name=self.region_name, profile_name=self.profile_name).client("athena")
+        return boto3.session.Session(
+            region_name=self.credentials.region_name, profile_name=self.credentials.aws_profile_name
+        ).client("athena")
 
     def get_timeout(self) -> int:
         """
@@ -104,7 +113,10 @@ def get_timeout(self) -> int:
             ValueError: If the timeout value is not a positive integer.
 
         """
-        timeout = self.parsed_model["config"].get("timeout", DEFAULT_TIMEOUT)
+        if self.parsed_model.get("config") is not None:
+            timeout = self.parsed_model["config"].get("timeout", DEFAULT_TIMEOUT)
+        else:
+            timeout = DEFAULT_TIMEOUT
         if timeout <= 0:
             raise ValueError("Timeout must be a positive integer")
         return timeout
@@ -166,19 +178,22 @@ def submit(self, compiled_code: str) -> dict:
             DbtRuntimeError: If the execution ends in a state other than "COMPLETED".
 
         """
-        calculation_execution_id = self.athena_client.start_calculation_execution(
-            SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
-        )["CalculationExecutionId"]
-        logger.debug(f"Submitted calculation execution id {calculation_execution_id}")
-        execution_status = self._poll_until_execution_completion(calculation_execution_id)
-        logger.debug(f"Received execution status {execution_status}")
-        if execution_status == "COMPLETED":
-            result_s3_uri = self.athena_client.get_calculation_execution(
-                CalculationExecutionId=calculation_execution_id
-            )["Result"]["ResultS3Uri"]
-            return result_s3_uri
-        else:
-            raise DbtRuntimeError(f"python model run ended in state {execution_status}")
+        try:
+            calculation_execution_id = self.athena_client.start_calculation_execution(
+                SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
+            )["CalculationExecutionId"]
+            logger.debug(f"Submitted calculation execution id {calculation_execution_id}")
+            execution_status = self._poll_until_execution_completion(calculation_execution_id)
+            logger.debug(f"Received execution status {execution_status}")
+            if execution_status == "COMPLETED":
+                result_s3_uri = self.athena_client.get_calculation_execution(
+                    CalculationExecutionId=calculation_execution_id
+                )["Result"]["ResultS3Uri"]
+                return result_s3_uri
+            else:
+                raise DbtRuntimeError(f"python model run ended in state {execution_status}")
+        finally:
+            self._terminate_session()
 
     def _terminate_session(self) -> dict:
         """
@@ -198,7 +213,7 @@ def _terminate_session(self) -> dict:
             session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
         ):
             logger.debug(f"Terminating session: {self.session_id}")
-            self.athena_client.terminate_session(SessionId=self.session_id)
+            return self.athena_client.terminate_session(SessionId=self.session_id)
 
     def _poll_until_execution_completion(self, calculation_execution_id):
         """
@@ -261,7 +276,3 @@ def _poll_until_session_creation(self, session_id):
             polling_interval *= 2
             if polling_interval > self.timeout:
                 raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
-
-    def __del__(self) -> None:
-        """Teardown for the class."""
-        self._terminate_session()
diff --git a/tests/conftest.py b/tests/conftest.py
index 4dd49304..4aad8588 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -7,7 +7,6 @@
 
 import dbt
 from dbt.adapters.athena.connections import AthenaCredentials
-from dbt.adapters.athena.python_submissions import AthenaPythonJobHelper
 from dbt.events.base_types import EventLevel
 from dbt.events.eventmgr import NoFilter
 from dbt.events.functions import EVENT_MANAGER, _get_stdout_config
@@ -65,24 +64,9 @@ def _setup_custom_caplog(name: str, level: EventLevel):
 
 
 @pytest.fixture(scope="class")
-def start_session_response(request):
-    return request
-
-
-@pytest.mark.parametrize(
-    "start_session_response",
-    [
-        ({"SessionId": "test_session_id", "State": "CREATING"}),
-        ({"SessionId": "test_session_id", "State": "IDLE"}),
-        ({"SessionId": "test_session_id", "State": "TERMINATED"}),
-    ],
-    indirect=True,
-)
-@pytest.fixture(scope="class")
-def athena_client(start_session_response):
-    with patch.object(boto3.session.Session, "client", return_value=MagicMock()) as mock_client:
-        mock_client.start_session.return_value = start_session_response
-        yield mock_client
+def athena_client():
+    with patch.object(boto3.session.Session, "client", return_value=MagicMock()) as mock_athena_client:
+        return mock_athena_client
 
 
 @patch.object(dbt.adapters.athena.connections, "AthenaCredentials")
@@ -96,15 +80,3 @@ def athena_credentials():
         work_group=ATHENA_WORKGROUP,
         spark_work_group=SPARK_WORKGROUP,
     )
-
-
-# @pytest.mark.parametrize(
-#     "parsed_model", [({"alias": "test_model", "schema": DATABASE_NAME, "config": {"timeout": 10}})], indirect=True
-# )
-@pytest.fixture(scope="class")
-def athena_python_job_helper(athena_client, athena_credentials):
-    parsed_model = {"alias": "test_model", "schema": DATABASE_NAME, "config": {"timeout": 10}}
-    with patch.object(AthenaPythonJobHelper, "athena_client", return_value=athena_client):
-        assert athena_credentials.spark_work_group == "spark"
-        athena_job_helper = AthenaPythonJobHelper(parsed_model, athena_credentials)
-        yield athena_job_helper
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 38e01b8e..38d07b7e 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -1,27 +1,166 @@
+from datetime import datetime
 from unittest.mock import patch
 
 import pytest
+import pytz
 
+from dbt.adapters.athena.python_submissions import AthenaPythonJobHelper
 from dbt.exceptions import DbtRuntimeError
 
+from .constants import DATABASE_NAME
 
-@pytest.mark.usefixtures("athena_python_job_helper")
+
+@pytest.mark.usefixtures("athena_credentials", "athena_client")
 class TestPythonSubmission:
+    """
+    A class to test the AthenaPythonJobHelper
+    """
+
+    @pytest.fixture()
+    def athena_job_helper(self, athena_credentials, athena_client, monkeypatch):
+        parsed_model = {"alias": "test_model", "schema": DATABASE_NAME, "config": {"timeout": 10}}
+        mock_job_helper = AthenaPythonJobHelper(parsed_model, athena_credentials)
+        monkeypatch.setattr(mock_job_helper, "athena_client", athena_client)
+        return mock_job_helper
+
+    @pytest.mark.parametrize(
+        "session_status_response, expected_response",
+        [
+            pytest.param(
+                {"Status": {"SessionId": "test_session_id", "State": "CREATING"}},
+                DbtRuntimeError(
+                    """Session <MagicMock name='client.start_session().__getitem__()' id='140219810489792'>
+                    did not create within 10 seconds."""
+                ),
+                marks=pytest.mark.xfail,
+            ),
+            (
+                {"Status": {"SessionId": "test_session_id", "State": "IDLE"}},
+                {"SessionId": "test_session_id", "State": "IDLE"},
+            ),
+            pytest.param(
+                {"Status": {"SessionId": "test_session_id", "State": "TERMINATED"}},
+                DbtRuntimeError("Unable to create session: test_session_id. Got status: TERMINATED."),
+                marks=pytest.mark.xfail,
+            ),
+        ],
+    )
+    def test_start_session(self, session_status_response, expected_response, athena_job_helper, athena_client):
+        with (
+            patch.object(athena_job_helper, "_poll_until_execution_completion", return_value=session_status_response),
+            patch.object(athena_client, "get_session_status", return_value=session_status_response),
+            patch.object(athena_client, "start_session", return_value=session_status_response.get("Status")),
+        ):
+            response = athena_job_helper._start_session()
+            assert response == expected_response
+
+    @pytest.mark.parametrize(
+        "session_status_response, expected_response",
+        [
+            pytest.param(
+                {
+                    "NextToken": "test_token",
+                    "Sessions": [
+                        {
+                            "Description": "string",
+                            "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
+                            "NotebookVersion": "string",
+                            "SessionId": "string",
+                            "Status": {
+                                "EndDateTime": "number",
+                                "IdleSinceDateTime": "number",
+                                "LastModifiedDateTime": "number",
+                                "StartDateTime": "number",
+                                "State": "IDLE",
+                                "StateChangeReason": "string",
+                            },
+                        }
+                    ],
+                },
+                {
+                    "Description": "string",
+                    "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
+                    "NotebookVersion": "string",
+                    "SessionId": "string",
+                    "Status": {
+                        "EndDateTime": "number",
+                        "IdleSinceDateTime": "number",
+                        "LastModifiedDateTime": "number",
+                        "StartDateTime": "number",
+                        "State": "IDLE",
+                        "StateChangeReason": "string",
+                    },
+                },
+            ),
+            (
+                {
+                    "NextToken": "string",
+                    "Sessions": [],
+                },
+                None,
+            ),
+        ],
+    )
+    def test_list_sessions(self, session_status_response, expected_response, athena_job_helper, athena_client):
+        with (patch.object(athena_client, "list_sessions", return_value=session_status_response),):
+            response = athena_job_helper._list_sessions()
+            assert response == expected_response
+
+    @pytest.mark.parametrize(
+        "parsed_models, expected_timeout",
+        [
+            ({"alias": "test_model", "schema": DATABASE_NAME, "config": {"timeout": 10}}, 10),
+            pytest.param(
+                {"alias": "test_model", "schema": "test_database", "config": {"timeout": 0}}, 0, marks=pytest.mark.xfail
+            ),
+            ({"alias": "test_model", "schema": DATABASE_NAME}, 7200),
+        ],
+    )
+    def test_get_timeout(self, parsed_models, expected_timeout, athena_job_helper, monkeypatch):
+        monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
+        response = athena_job_helper.get_timeout()
+        assert response == expected_timeout
+
     @pytest.mark.parametrize(
-        "expected_response",
+        "session_status_response, expected_response",
         [
-            (None),
-            ("test_session_id"),
-            (DbtRuntimeError("Unable to create session: test_session_id. Got status: TERMINATED."),),
+            (
+                {
+                    "SessionId": "string",
+                    "Status": {
+                        "EndDateTime": "number",
+                        "IdleSinceDateTime": "number",
+                        "LastModifiedDateTime": "number",
+                        "StartDateTime": datetime(2023, 4, 21, 0, tzinfo=pytz.timezone("UTC")),
+                        "State": "IDLE",
+                        "StateChangeReason": "string",
+                    },
+                },
+                {"State": "TERMINATED"},
+            ),
+            (
+                {
+                    "SessionId": "string",
+                    "Status": {
+                        "EndDateTime": "number",
+                        "IdleSinceDateTime": "number",
+                        "LastModifiedDateTime": "number",
+                        "StartDateTime": datetime(2023, 4, 21, 0, tzinfo=pytz.timezone("UTC")),
+                        "State": "TERMINATED",
+                        "StateChangeReason": "string",
+                    },
+                },
+                None,
+            ),
         ],
     )
-    def test_start_session(self, expected_response, athena_python_job_helper):
-        athena_python_job_helper.timeout = 0
-        with patch.object(
-            athena_python_job_helper,
-            "_poll_until_session_creation",
-            return_value=expected_response,
+    def test_terminate_session(
+        self, session_status_response, expected_response, athena_job_helper, athena_client, monkeypatch
+    ):
+        monkeypatch.setattr(athena_job_helper, "timeout", 10)
+        with (
+            patch.object(athena_client, "get_session_status", return_value=session_status_response),
+            patch.object(athena_client, "terminate_session", return_value=expected_response),
         ):
-            assert athena_python_job_helper._start_session().get("SessionId") == expected_response
-            athena_python_job_helper._start_session.assert_called_once()
-            athena_python_job_helper._poll_until_session_creation.assert_called_once()
+            terminate_session_response = athena_job_helper._terminate_session()
+            assert terminate_session_response == expected_response

From 84c9d50711e0891ce96c0ef7d1525509a80d48bf Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 21 Apr 2023 13:18:09 -0300
Subject: [PATCH 28/75] Added more tests

---
 dbt/adapters/athena/python_submissions.py | 70 ++++++++++++++++-----
 tests/unit/test_python_submissions.py     | 77 ++++++++++++++++++++---
 2 files changed, 121 insertions(+), 26 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 9433aff1..4852c792 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -10,7 +10,8 @@
 from dbt.events import AdapterLogger
 from dbt.exceptions import DbtRuntimeError
 
-DEFAULT_POLLING_INTERVAL = 2
+DEFAULT_POLLING_INTERVAL = 5
+DEFAULT_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
 SUBMISSION_LANGUAGE = "python"
 DEFAULT_TIMEOUT = 60 * 60 * 2
 
@@ -48,14 +49,23 @@ class AthenaPythonJobHelper(PythonJobHelper):
 
     def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
         self.parsed_model = parsed_model
-        self.timeout = self.get_timeout()
-        self.polling_interval = DEFAULT_POLLING_INTERVAL
         self.credentials = credentials
         self.athena_client = self.athena_client()
 
+    @property
+    def identifier(self) -> str:
+        return self.parsed_model["alias"]
+
+    @property
+    def schema(self) -> str:
+        return self.parsed_model["schema"]
+
     @property
     @lru_cache()
     def session_id(self) -> str:
+        return self._set_session_id()
+
+    def _set_session_id(self) -> str:
         """
         Get the session ID.
 
@@ -71,14 +81,6 @@ def session_id(self) -> str:
             return self._start_session().get("SessionId")
         return session_info.get("SessionId")
 
-    @property
-    def identifier(self) -> str:
-        return self.parsed_model["alias"]
-
-    @property
-    def schema(self) -> str:
-        return self.parsed_model["schema"]
-
     @property
     def spark_work_group(self) -> str:
         return self.credentials.spark_work_group
@@ -98,7 +100,11 @@ def athena_client(self) -> Any:
             region_name=self.credentials.region_name, profile_name=self.credentials.aws_profile_name
         ).client("athena")
 
-    def get_timeout(self) -> int:
+    @property
+    def timeout(self) -> int:
+        return self._set_timeout()
+
+    def _set_timeout(self) -> int:
         """
         Get the timeout value.
 
@@ -115,12 +121,42 @@ def get_timeout(self) -> int:
         """
         if self.parsed_model.get("config") is not None:
             timeout = self.parsed_model["config"].get("timeout", DEFAULT_TIMEOUT)
+            if not isinstance(timeout, int):
+                raise TypeError("Timeout must be an integer")
+            if timeout <= 0:
+                raise ValueError("Timeout must be a positive integer")
+            logger.info(f"Setting timeout: {timeout}")
         else:
+            logger.info(f"Using default timeout: {DEFAULT_TIMEOUT}")
             timeout = DEFAULT_TIMEOUT
-        if timeout <= 0:
-            raise ValueError("Timeout must be a positive integer")
         return timeout
 
+    @property
+    def polling_interval(self):
+        return self._set_polling_interval()
+
+    def _set_polling_interval(self) -> int:
+        polling_interval = self.parsed_model.get("config", {}).get("polling_interval", DEFAULT_POLLING_INTERVAL)
+        if not isinstance(polling_interval, int) or polling_interval <= 0:
+            raise ValueError("polling_interval must be a positive integer")
+        logger.info(f"Setting polling_interval: {polling_interval}")
+        return polling_interval
+
+    @property
+    def engine_config(self):
+        return self._set_engine_config()
+
+    def _set_engine_config(self) -> dict:
+        engine_config = self.parsed_model.get("config", {}).get("engine_config", DEFAULT_ENGINE_CONFIG)
+        if not isinstance(engine_config, dict):
+            raise TypeError("engine configuration has to be of type dict")
+
+        expected_keys = {"CoordinatorDpuSize", "MaxConcurrentDpus", "DefaultExecutorDpuSize"}
+        if set(engine_config.keys()) != expected_keys:
+            raise KeyError(f"The keys of the dictionary entered do not match the expected format: {expected_keys}")
+
+        return engine_config
+
     def _list_sessions(self) -> dict:
         """
         List Athena sessions.
@@ -152,7 +188,7 @@ def _start_session(self) -> dict:
         """
         response = self.athena_client.start_session(
             WorkGroup=self.spark_work_group,
-            EngineConfiguration={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
+            EngineConfiguration=self.engine_config,
         )
         if response["State"] != "IDLE":
             self._poll_until_session_creation(response["SessionId"])
@@ -195,7 +231,7 @@ def submit(self, compiled_code: str) -> dict:
         finally:
             self._terminate_session()
 
-    def _terminate_session(self) -> dict:
+    def _terminate_session(self) -> None:
         """
         Terminate the current Athena session.
 
@@ -213,7 +249,7 @@ def _terminate_session(self) -> dict:
             session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
         ):
             logger.debug(f"Terminating session: {self.session_id}")
-            return self.athena_client.terminate_session(SessionId=self.session_id)
+            self.athena_client.terminate_session(SessionId=self.session_id)
 
     def _poll_until_execution_completion(self, calculation_execution_id):
         """
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 38d07b7e..3e713a35 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -47,7 +47,7 @@ def athena_job_helper(self, athena_credentials, athena_client, monkeypatch):
     )
     def test_start_session(self, session_status_response, expected_response, athena_job_helper, athena_client):
         with (
-            patch.object(athena_job_helper, "_poll_until_execution_completion", return_value=session_status_response),
+            patch.object(athena_job_helper, "_poll_until_session_creation", return_value=session_status_response),
             patch.object(athena_client, "get_session_status", return_value=session_status_response),
             patch.object(athena_client, "start_session", return_value=session_status_response.get("Status")),
         ):
@@ -116,17 +116,73 @@ def test_list_sessions(self, session_status_response, expected_response, athena_
             ({"alias": "test_model", "schema": DATABASE_NAME}, 7200),
         ],
     )
-    def test_get_timeout(self, parsed_models, expected_timeout, athena_job_helper, monkeypatch):
+    def test_set_timeout(self, parsed_models, expected_timeout, athena_job_helper, monkeypatch):
         monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
-        response = athena_job_helper.get_timeout()
+        response = athena_job_helper._set_timeout()
         assert response == expected_timeout
 
     @pytest.mark.parametrize(
-        "session_status_response, expected_response",
+        "parsed_models, expected_polling_interval",
+        [
+            ({"alias": "test_model", "schema": DATABASE_NAME, "config": {"polling_interval": 10}}, 10),
+            pytest.param(
+                {"alias": "test_model", "schema": "test_database", "config": {"timeout": 0}}, 0, marks=pytest.mark.xfail
+            ),
+            ({"alias": "test_model", "schema": DATABASE_NAME}, 5),
+        ],
+    )
+    def test_set_polling_interval(self, parsed_models, expected_polling_interval, athena_job_helper, monkeypatch):
+        monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
+        response = athena_job_helper._set_polling_interval()
+        assert response == expected_polling_interval
+
+    @pytest.mark.parametrize(
+        "parsed_models, expected_engine_config",
         [
             (
                 {
-                    "SessionId": "string",
+                    "alias": "test_model",
+                    "schema": DATABASE_NAME,
+                    "config": {
+                        "engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 44, "DefaultExecutorDpuSize": 1}
+                    },
+                },
+                {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 44, "DefaultExecutorDpuSize": 1},
+            ),
+            pytest.param(
+                {"alias": "test_model", "schema": "test_database", "config": {"engine_config": 0}},
+                0,
+                marks=pytest.mark.xfail,
+            ),
+            pytest.param(
+                {
+                    "alias": "test_wrong_model",
+                    "schema": "test_database",
+                    "config": {"engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2}},
+                },
+                (),
+                marks=pytest.mark.xfail,
+            ),
+            (
+                {"alias": "test_model", "schema": DATABASE_NAME},
+                {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
+            ),
+        ],
+    )
+    def test_set_engine_config(self, parsed_models, expected_engine_config, athena_job_helper, monkeypatch):
+        monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
+        if parsed_models.get("alias") == "test_wrong_model":
+            with pytest.raises(KeyError):
+                athena_job_helper._set_engine_config()
+        response = athena_job_helper._set_engine_config()
+        assert response == expected_engine_config
+
+    @pytest.mark.parametrize(
+        "session_status_response, test_session_id, expected_response",
+        [
+            (
+                {
+                    "SessionId": "test_session_id",
                     "Status": {
                         "EndDateTime": "number",
                         "IdleSinceDateTime": "number",
@@ -136,11 +192,12 @@ def test_get_timeout(self, parsed_models, expected_timeout, athena_job_helper, m
                         "StateChangeReason": "string",
                     },
                 },
-                {"State": "TERMINATED"},
+                "test_session_id",
+                None,
             ),
             (
                 {
-                    "SessionId": "string",
+                    "SessionId": "test_session_id_2",
                     "Status": {
                         "EndDateTime": "number",
                         "IdleSinceDateTime": "number",
@@ -150,17 +207,19 @@ def test_get_timeout(self, parsed_models, expected_timeout, athena_job_helper, m
                         "StateChangeReason": "string",
                     },
                 },
+                "test_session_id_2",
                 None,
             ),
         ],
     )
     def test_terminate_session(
-        self, session_status_response, expected_response, athena_job_helper, athena_client, monkeypatch
+        self, session_status_response, test_session_id, expected_response, athena_job_helper, athena_client, monkeypatch
     ):
-        monkeypatch.setattr(athena_job_helper, "timeout", 10)
         with (
             patch.object(athena_client, "get_session_status", return_value=session_status_response),
             patch.object(athena_client, "terminate_session", return_value=expected_response),
+            patch.object(athena_job_helper, "_set_session_id", return_value=test_session_id),
+            patch.object(athena_job_helper, "_set_timeout", return_value=10),
         ):
             terminate_session_response = athena_job_helper._terminate_session()
             assert terminate_session_response == expected_response

From 0693fa96341d68c864c9c47718754439cd7fe21b Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 21 Apr 2023 18:47:34 -0300
Subject: [PATCH 29/75] Fixed mypy errors

---
 dbt/adapters/athena/python_submissions.py | 14 +++++++-------
 tests/unit/test_python_submissions.py     | 11 ++++++++++-
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 4852c792..88490ff8 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -50,7 +50,7 @@ class AthenaPythonJobHelper(PythonJobHelper):
     def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
         self.parsed_model = parsed_model
         self.credentials = credentials
-        self.athena_client = self.athena_client()
+        self.athena_client = self.get_athena_client()
 
     @property
     def identifier(self) -> str:
@@ -77,15 +77,15 @@ def _set_session_id(self) -> str:
 
         """
         session_info = self._list_sessions()
-        if session_info is None:
-            return self._start_session().get("SessionId")
-        return session_info.get("SessionId")
+        if session_info.get("SessionId") is None:
+            return self._start_session()["SessionId"]
+        return session_info["SessionId"]
 
     @property
     def spark_work_group(self) -> str:
-        return self.credentials.spark_work_group
+        return self.credentials.spark_work_group or "spark"
 
-    def athena_client(self) -> Any:
+    def get_athena_client(self) -> Any:
         """
         Get the AWS Athena client.
 
@@ -171,7 +171,7 @@ def _list_sessions(self) -> dict:
         """
         response = self.athena_client.list_sessions(WorkGroup=self.spark_work_group, MaxResults=1, StateFilter="IDLE")
         if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
-            return None
+            return {}
         return response.get("Sessions")[0]
 
     def _start_session(self) -> dict:
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 3e713a35..861dd679 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -97,7 +97,7 @@ def test_start_session(self, session_status_response, expected_response, athena_
                     "NextToken": "string",
                     "Sessions": [],
                 },
-                None,
+                {},
             ),
         ],
     )
@@ -223,3 +223,12 @@ def test_terminate_session(
         ):
             terminate_session_response = athena_job_helper._terminate_session()
             assert terminate_session_response == expected_response
+
+    def test_poll_session_creation(self):
+        pass
+
+    def test_poll_execution(self):
+        pass
+
+    def test_submission(self):
+        pass
\ No newline at end of file

From eac05049e1247254410a2bafc796dded444c5539 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 21 Apr 2023 18:48:29 -0300
Subject: [PATCH 30/75] Formatting

---
 tests/unit/test_python_submissions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 861dd679..f6d3a258 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -231,4 +231,4 @@ def test_poll_execution(self):
         pass
 
     def test_submission(self):
-        pass
\ No newline at end of file
+        pass

From 589715e84c84c0ac7b7e86639da0e5e29171ff31 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 21 Apr 2023 19:09:00 -0300
Subject: [PATCH 31/75] Simplified patches

---
 tests/unit/test_python_submissions.py | 28 ++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index f6d3a258..d9b13081 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -1,5 +1,5 @@
 from datetime import datetime
-from unittest.mock import patch
+from unittest.mock import patch, Mock
 
 import pytest
 import pytz
@@ -46,10 +46,13 @@ def athena_job_helper(self, athena_credentials, athena_client, monkeypatch):
         ],
     )
     def test_start_session(self, session_status_response, expected_response, athena_job_helper, athena_client):
-        with (
-            patch.object(athena_job_helper, "_poll_until_session_creation", return_value=session_status_response),
-            patch.object(athena_client, "get_session_status", return_value=session_status_response),
-            patch.object(athena_client, "start_session", return_value=session_status_response.get("Status")),
+        with patch.multiple(
+            athena_job_helper,
+            _poll_until_session_creation=Mock(return_value=session_status_response),
+        ), patch.multiple(
+            athena_client,
+            get_session_status=Mock(return_value=session_status_response),
+            start_session=Mock(return_value=session_status_response.get("Status")),
         ):
             response = athena_job_helper._start_session()
             assert response == expected_response
@@ -102,7 +105,7 @@ def test_start_session(self, session_status_response, expected_response, athena_
         ],
     )
     def test_list_sessions(self, session_status_response, expected_response, athena_job_helper, athena_client):
-        with (patch.object(athena_client, "list_sessions", return_value=session_status_response),):
+        with patch.object(athena_client, "list_sessions", return_value=session_status_response):
             response = athena_job_helper._list_sessions()
             assert response == expected_response
 
@@ -215,11 +218,14 @@ def test_set_engine_config(self, parsed_models, expected_engine_config, athena_j
     def test_terminate_session(
         self, session_status_response, test_session_id, expected_response, athena_job_helper, athena_client, monkeypatch
     ):
-        with (
-            patch.object(athena_client, "get_session_status", return_value=session_status_response),
-            patch.object(athena_client, "terminate_session", return_value=expected_response),
-            patch.object(athena_job_helper, "_set_session_id", return_value=test_session_id),
-            patch.object(athena_job_helper, "_set_timeout", return_value=10),
+        with patch.multiple(
+            athena_client,
+            get_session_status=Mock(return_value=session_status_response),
+            terminate_session=Mock(return_value=expected_response),
+        ), patch.multiple(
+            athena_job_helper,
+            _set_session_id=Mock(return_value=test_session_id),
+            _set_timeout=Mock(return_value=10),
         ):
             terminate_session_response = athena_job_helper._terminate_session()
             assert terminate_session_response == expected_response

From 4c43d49f4b4218e4cc4050db0cda07606ad8000f Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 21 Apr 2023 19:10:17 -0300
Subject: [PATCH 32/75] Fixed imports

---
 tests/unit/test_python_submissions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index d9b13081..702aa348 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -1,5 +1,5 @@
 from datetime import datetime
-from unittest.mock import patch, Mock
+from unittest.mock import Mock, patch
 
 import pytest
 import pytz

From de12fd25357008b81af06db1317aad44c378e3b5 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Sun, 23 Apr 2023 00:10:21 -0300
Subject: [PATCH 33/75] Added docs to tests and added kwargs

---
 .../macros/adapters/python_submissions.sql    |  34 +++++-
 .../models/table/create_table_as.sql          |  17 ++-
 tests/unit/test_python_submissions.py         | 105 ++++++++++++++++--
 3 files changed, 145 insertions(+), 11 deletions(-)

diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index c9c02d24..6283e536 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -1,14 +1,42 @@
-{%- macro athena__py_save_table_as(compiled_code, target_relation, format, location, mode="overwrite") -%}
+{%- macro athena__py_save_table_as(compiled_code, target_relation , **kwargs) -%}
+
+    {% set location = kwargs.get("location") %} 
+    {% set format = kwargs.get("format", "parquet") %}
+    {% set mode = kwargs.get("mode", "overwrite") %}
+    {% set write_compression = kwargs.get("write_compression", "snappy") %}
+    {% set partitioned_by = kwargs.get("partitioned_by") %}
+    {% set bucketed_by = kwargs.get("bucketed_by") %}
+    {% set sorted_by = kwargs.get("sorted_by") %}
+    {% set merge_schema = kwargs.get("merge_schema", true) %}
+    {% set bucket_count = kwargs.get("bucket_count") %}
+    {% set field_delimiter = kwargs.get("field_delimiter") %}
+    {% set table_type = kwargs.get("table_type") %}
+    {% set extra_table_properties = kwargs.get("extra_table_properties") %}
+
 {{ compiled_code }}
 def materialize(spark_session, df, target_relation):
     import pandas
     try:
-        if isinstance(df, pandas.core.frame.DataFrame):
+        if isinstance(df, pyspark.sql.dataframe.DataFrame):
+            pass 
+        elif isinstance(df, pandas.core.frame.DataFrame):
             df = spark_session.createDataFrame(df)
+        else:
+            msg = f"{type(df)} is not a supported type for dbt Python materialization"
+            raise Exception(msg)
         df.write \
         .format("{{ format }}") \
-        .option("path", "{{ location }}") \
         .mode("{{ mode }}") \
+        .partitionBy("{{ partitioned_by }}") \
+        .bucketBy("{{ bucketed_by }}") \
+        .sortBy(" {{ sorted_by }}") \
+        .option("path", "{{ location }}") \
+        .option("compression", "{{ write_compression }}") \
+        .option("mergeSchema", "{{ merge_schema }}") \
+        .option("numBuckets", "{{ bucket_count }}") \
+        .option("delimiter", "{{ field_delimiter }}") \
+        .option("tableType", "{{ table_type }}") \
+        .option("extra", "{{ extra_table_properties }}") \
         .saveAsTable(
             name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
         )
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index 969db5e7..91b0b538 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -77,7 +77,22 @@
     as
       {{ compiled_code }}
   {%- elif language == 'python' -%}
-    {{ athena__py_save_table_as(compiled_code=compiled_code, target_relation=relation, format=format, location=location, mode="overwrite") }}
+    {{ 
+      athena__py_save_table_as(
+        compiled_code,
+        target_relation,
+        location=location,
+        format=format,
+        mode="overwrite",
+        partitioned_by=partitioned_by,
+        bucketed_by=bucketed_by,
+        write_compression=write_compression,
+        bucket_count=bucket_count,
+        field_delimiter=field_delimiter,
+        table_type=table_type,
+        extra_table_properties=extra_table_properties
+        ) 
+    }}
   {%- else -%}
     {% do exceptions.raise_compiler_error("athena__create_table_as macro doesn't support the provided language, it got %s" % language) %}
   {%- endif -%}
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 702aa348..406ad05b 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -45,7 +45,20 @@ def athena_job_helper(self, athena_credentials, athena_client, monkeypatch):
             ),
         ],
     )
-    def test_start_session(self, session_status_response, expected_response, athena_job_helper, athena_client):
+    def test_start_session(self, session_status_response, expected_response, athena_job_helper, athena_client) -> None:
+        """
+        Test the _start_session method of the AthenaJobHelper class.
+
+        Args:
+            session_status_response (dict): A dictionary containing the response from the Athena session
+            creation status.
+            expected_response (Union[dict, DbtRuntimeError]): The expected response from the _start_session method.
+            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
+            athena_client (botocore.client.BaseClient): An instance of the botocore Athena client.
+
+        Returns:
+            None
+        """
         with patch.multiple(
             athena_job_helper,
             _poll_until_session_creation=Mock(return_value=session_status_response),
@@ -104,7 +117,22 @@ def test_start_session(self, session_status_response, expected_response, athena_
             ),
         ],
     )
-    def test_list_sessions(self, session_status_response, expected_response, athena_job_helper, athena_client):
+    def test_list_sessions(self, session_status_response, expected_response, athena_job_helper, athena_client) -> None:
+        """
+        Test the _list_sessions method of the AthenaJobHelper class.
+
+        Args:
+            session_status_response (dict): The response object to be returned by the mock Athena client.
+            expected_response (dict): The expected output of the _list_sessions method.
+            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
+            athena_client (Mock): A mock instance of the Athena client.
+
+        Returns:
+            None: This function only asserts the output of the _list_sessions method.
+
+        Raises:
+            AssertionError: If the output of the _list_sessions method does not match the expected output.
+        """
         with patch.object(athena_client, "list_sessions", return_value=session_status_response):
             response = athena_job_helper._list_sessions()
             assert response == expected_response
@@ -119,7 +147,20 @@ def test_list_sessions(self, session_status_response, expected_response, athena_
             ({"alias": "test_model", "schema": DATABASE_NAME}, 7200),
         ],
     )
-    def test_set_timeout(self, parsed_models, expected_timeout, athena_job_helper, monkeypatch):
+    def test_set_timeout(self, parsed_models, expected_timeout, athena_job_helper, monkeypatch) -> None:
+        """
+        Test case to verify that the `_set_timeout` method of the `AthenaPythonJobHelper` class
+        returns the expected timeout value.
+
+        Args:
+            parsed_models (dict): A dictionary containing the parsed model configuration.
+            expected_timeout (int): The expected timeout value.
+            athena_job_helper (AthenaPythonJobHelper): An instance of the `AthenaPythonJobHelper` class.
+            monkeypatch: A pytest fixture used to mock and patch objects in the test environment.
+
+        Returns:
+            None
+        """
         monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
         response = athena_job_helper._set_timeout()
         assert response == expected_timeout
@@ -129,12 +170,31 @@ def test_set_timeout(self, parsed_models, expected_timeout, athena_job_helper, m
         [
             ({"alias": "test_model", "schema": DATABASE_NAME, "config": {"polling_interval": 10}}, 10),
             pytest.param(
-                {"alias": "test_model", "schema": "test_database", "config": {"timeout": 0}}, 0, marks=pytest.mark.xfail
+                {"alias": "test_model", "schema": "test_database", "config": {"polling_interval": 0}},
+                0,
+                marks=pytest.mark.xfail,
             ),
             ({"alias": "test_model", "schema": DATABASE_NAME}, 5),
         ],
     )
-    def test_set_polling_interval(self, parsed_models, expected_polling_interval, athena_job_helper, monkeypatch):
+    def test_set_polling_interval(
+        self, parsed_models, expected_polling_interval, athena_job_helper, monkeypatch
+    ) -> None:
+        """
+        Test method to verify that _set_polling_interval() method of AthenaPythonJobHelper
+        sets the correct polling interval value based on the parsed model configuration.
+
+        Args:
+            parsed_models (dict): Dictionary containing the parsed configuration model for the Athena job.
+            expected_polling_interval (int): The expected polling interval value based on the
+            parsed model configuration.
+            athena_job_helper (AthenaPythonJobHelper): The instance of AthenaPythonJobHelper to be tested.
+            monkeypatch: A pytest monkeypatch fixture used to override the parsed model configuration
+            in AthenaPythonJobHelper.
+
+        Returns:
+            None
+        """
         monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
         response = athena_job_helper._set_polling_interval()
         assert response == expected_polling_interval
@@ -172,7 +232,22 @@ def test_set_polling_interval(self, parsed_models, expected_polling_interval, at
             ),
         ],
     )
-    def test_set_engine_config(self, parsed_models, expected_engine_config, athena_job_helper, monkeypatch):
+    def test_set_engine_config(self, parsed_models, expected_engine_config, athena_job_helper, monkeypatch) -> None:
+        """
+        Test method to verify the `_set_engine_config()` method of the AthenaPythonJobHelper class.
+
+        Args:
+            parsed_models: A dictionary containing the parsed model configuration data.
+            expected_engine_config: The expected engine configuration that is set.
+            athena_job_helper: An instance of the AthenaPythonJobHelper class.
+            monkeypatch: A fixture from the pytest library that allows modifying attributes at runtime for testing.
+
+        Raises:
+            KeyError: If the parsed model configuration dictionary does not contain the required key.
+
+        Returns:
+            None. The method asserts that the actual engine configuration set matches the expected engine configuration.
+        """
         monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
         if parsed_models.get("alias") == "test_wrong_model":
             with pytest.raises(KeyError):
@@ -217,7 +292,23 @@ def test_set_engine_config(self, parsed_models, expected_engine_config, athena_j
     )
     def test_terminate_session(
         self, session_status_response, test_session_id, expected_response, athena_job_helper, athena_client, monkeypatch
-    ):
+    ) -> None:
+        """
+        Test function to check if _terminate_session() method of AthenaPythonJobHelper class correctly
+        terminates an Athena session.
+
+        Args:
+            session_status_response: A mock response object containing the current status of the Athena session.
+            test_session_id: The session ID of the test Athena session.
+            expected_response: The expected response object after the Athena session is terminated.
+            athena_job_helper: An instance of the AthenaPythonJobHelper class.
+            athena_client: The mocked Athena client object.
+            monkeypatch: Pytest monkeypatch object for patching objects and values during testing.
+
+        Returns:
+            None
+        """
+
         with patch.multiple(
             athena_client,
             get_session_status=Mock(return_value=session_status_response),

From 8e1bf6fe6975519764dc773e21e6ccffed3f4470 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Sun, 23 Apr 2023 00:17:07 -0300
Subject: [PATCH 34/75] Fixed whitespace

---
 .../macros/adapters/python_submissions.sql    |  3 +-
 .../models/table/create_table_as.sql          | 30 +++++++++----------
 2 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index 6283e536..7524b872 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -1,5 +1,4 @@
 {%- macro athena__py_save_table_as(compiled_code, target_relation , **kwargs) -%}
-
     {% set location = kwargs.get("location") %} 
     {% set format = kwargs.get("format", "parquet") %}
     {% set mode = kwargs.get("mode", "overwrite") %}
@@ -18,7 +17,7 @@ def materialize(spark_session, df, target_relation):
     import pandas
     try:
         if isinstance(df, pyspark.sql.dataframe.DataFrame):
-            pass 
+            pass
         elif isinstance(df, pandas.core.frame.DataFrame):
             df = spark_session.createDataFrame(df)
         else:
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index 91b0b538..e0793781 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -77,22 +77,20 @@
     as
       {{ compiled_code }}
   {%- elif language == 'python' -%}
-    {{ 
-      athena__py_save_table_as(
-        compiled_code,
-        target_relation,
-        location=location,
-        format=format,
-        mode="overwrite",
-        partitioned_by=partitioned_by,
-        bucketed_by=bucketed_by,
-        write_compression=write_compression,
-        bucket_count=bucket_count,
-        field_delimiter=field_delimiter,
-        table_type=table_type,
-        extra_table_properties=extra_table_properties
-        ) 
-    }}
+    {{ athena__py_save_table_as(
+      compiled_code,
+      target_relation,
+      location=location,
+      format=format,
+      mode="overwrite",
+      partitioned_by=partitioned_by,
+      bucketed_by=bucketed_by,
+      write_compression=write_compression,
+      bucket_count=bucket_count,
+      field_delimiter=field_delimiter,
+      table_type=table_type,
+      extra_table_properties=extra_table_properties
+      ) }}
   {%- else -%}
     {% do exceptions.raise_compiler_error("athena__create_table_as macro doesn't support the provided language, it got %s" % language) %}
   {%- endif -%}

From 352e1f6b8a9cfa03b45807cfda4850d7d7da5d4f Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Sun, 23 Apr 2023 00:18:24 -0300
Subject: [PATCH 35/75] Fixed whitespace

---
 dbt/include/athena/macros/adapters/python_submissions.sql | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index 7524b872..301fc243 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -1,5 +1,5 @@
 {%- macro athena__py_save_table_as(compiled_code, target_relation , **kwargs) -%}
-    {% set location = kwargs.get("location") %} 
+    {% set location = kwargs.get("location") %}
     {% set format = kwargs.get("format", "parquet") %}
     {% set mode = kwargs.get("mode", "overwrite") %}
     {% set write_compression = kwargs.get("write_compression", "snappy") %}

From 25531c98c1d13d8707a4a588546b2e8f75f24d1a Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Sun, 23 Apr 2023 16:15:53 -0300
Subject: [PATCH 36/75] Added overrides to source and ref

---
 .../macros/adapters/python_submissions.sql    | 54 +++++++++++++++++--
 1 file changed, 49 insertions(+), 5 deletions(-)

diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index 301fc243..6ac83ec0 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -43,12 +43,16 @@ def materialize(spark_session, df, target_relation):
     except Exception:
         raise
 
-dbt = dbtObj(spark.table)
-df = model(dbt, spark)
-materialize(spark, df, dbt.this)
+{{ athena__py_get_spark_dbt_object() }}
+
+dbt = SparkdbtObj(spark)
+df = model(dbt, dbt.spark_session)
+materialize(dbt.spark_session, df, dbt.this)
 {%- endmacro -%}
 
 {%- macro athena__py_execute_query(query) -%}
+{{ athena__py_get_spark_dbt_object() }}
+
 def execute_query(spark_session):
     import pandas
     try:
@@ -57,6 +61,46 @@ def execute_query(spark_session):
     except Exception:
         raise
 
-dbt = dbtObj(spark.table)
-execute_query(spark)
+dbt = SparkdbtObj(spark)
+execute_query(dbt, dbt.spark_session)
 {%- endmacro -%}
+
+{%- macro athena__py_get_spark_dbt_object() -%}
+class SparkdbtObj(dbtObj, spark_session):
+    def __init__(self) -> None:
+        super().__init__(load_df_function=spark.table)
+        self.spark_session = spark_session
+        
+    @property
+    def source(self, *args):
+        """
+        Override the source attribute dynamically
+
+        spark.table('awsdatacatalog.analytics_dev.model')
+        Raises pyspark.sql.utils.AnalysisException:
+        spark_catalog requires a single-part namespace,
+        but got [awsdatacatalog, analytics_dev]
+
+        So the override removes the catalog component and only
+        provides the schema and identifer to spark.table()
+        """
+        args = [arg[arg.index('.')+1:] for arg in args]
+        return lambda *args: source(*args, dbt_load_df_function=spark.table)
+    
+    @property
+    def ref(self, *args):
+        """
+        Override the ref attribute dynamically
+
+        spark.table('awsdatacatalog.analytics_dev.model')
+        Raises pyspark.sql.utils.AnalysisException:
+        spark_catalog requires a single-part namespace,
+        but got [awsdatacatalog, analytics_dev]
+
+        So the override removes the catalog component and only
+        provides the schema and identifer to spark.table()
+        """
+        args = [arg[arg.index('.')+1:] for arg in args]
+        return lambda *args: ref(*args, dbt_load_df_function=spark.table)
+
+{%- endmacro -%}
\ No newline at end of file

From f86159da7cc90216394250f17bfd7525be446722 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Mon, 24 Apr 2023 00:09:46 -0300
Subject: [PATCH 37/75] Added support for configuring table output

---
 dbt/adapters/athena/python_submissions.py     |  44 +++++--
 .../macros/adapters/python_submissions.sql    | 107 ++++++++----------
 .../models/table/create_table_as.sql          |  27 ++---
 3 files changed, 96 insertions(+), 82 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 88490ff8..93126ac6 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -193,6 +193,25 @@ def _start_session(self) -> dict:
         if response["State"] != "IDLE":
             self._poll_until_session_creation(response["SessionId"])
         return response
+    
+    def _get_current_session_status(self) -> str:
+        """
+        Get the current session status.
+
+        Returns:
+            str: The status of the session
+        """
+        return self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
+    
+    def _poll_until_session_idle(self):
+        polling_interval = self.polling_interval
+        while True:
+            session_status = self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
+            if session_status == "IDLE":
+                return session_status
+            if session_status in ["FAILED", "TERMINATED", "DEGRADED"]:
+                return DbtRuntimeError(f"The session chosen was not available. Got status: {session_status}")
+
 
     def submit(self, compiled_code: str) -> dict:
         """
@@ -214,22 +233,29 @@ def submit(self, compiled_code: str) -> dict:
             DbtRuntimeError: If the execution ends in a state other than "COMPLETED".
 
         """
+        if self._get_current_session_status() == "BUSY":
+            self._poll_until_session_idle()
         try:
             calculation_execution_id = self.athena_client.start_calculation_execution(
                 SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
             )["CalculationExecutionId"]
-            logger.debug(f"Submitted calculation execution id {calculation_execution_id}")
+        except Exception as e:
+            raise DbtRuntimeError(f"Unable to complete python execution. Got: {e}")
+        try:
             execution_status = self._poll_until_execution_completion(calculation_execution_id)
-            logger.debug(f"Received execution status {execution_status}")
-            if execution_status == "COMPLETED":
-                result_s3_uri = self.athena_client.get_calculation_execution(
-                    CalculationExecutionId=calculation_execution_id
-                )["Result"]["ResultS3Uri"]
-                return result_s3_uri
-            else:
-                raise DbtRuntimeError(f"python model run ended in state {execution_status}")
+        except Exception as e:
+            logger.error(f"Unable to poll execution status: Got: {e}")
         finally:
             self._terminate_session()
+        logger.debug(f"Received execution status {execution_status}")
+        if execution_status == "COMPLETED":
+            result_s3_uri = self.athena_client.get_calculation_execution(
+                CalculationExecutionId=calculation_execution_id
+            )["Result"]["ResultS3Uri"]
+            return result_s3_uri
+        else:
+            raise DbtRuntimeError(f"python model run ended in state {execution_status}")
+
 
     def _terminate_session(self) -> None:
         """
diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index 6ac83ec0..8b175dae 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -1,16 +1,17 @@
-{%- macro athena__py_save_table_as(compiled_code, target_relation , **kwargs) -%}
-    {% set location = kwargs.get("location") %}
-    {% set format = kwargs.get("format", "parquet") %}
-    {% set mode = kwargs.get("mode", "overwrite") %}
-    {% set write_compression = kwargs.get("write_compression", "snappy") %}
-    {% set partitioned_by = kwargs.get("partitioned_by") %}
-    {% set bucketed_by = kwargs.get("bucketed_by") %}
-    {% set sorted_by = kwargs.get("sorted_by") %}
-    {% set merge_schema = kwargs.get("merge_schema", true) %}
-    {% set bucket_count = kwargs.get("bucket_count") %}
-    {% set field_delimiter = kwargs.get("field_delimiter") %}
-    {% set table_type = kwargs.get("table_type") %}
-    {% set extra_table_properties = kwargs.get("extra_table_properties") %}
+{%- macro athena__py_save_table_as(compiled_code, target_relation, optional_args={}) -%}
+    {% set location = optional_args.get("location") %}
+    {% set format = optional_args.get("format", "parquet") %}
+    {% set mode = optional_args.get("mode", "overwrite") %}
+    {% set write_compression = optional_args.get("write_compression", "snappy") %}
+    {% set partitioned_by = optional_args.get("partitioned_by") %}
+    {% set bucketed_by = optional_args.get("bucketed_by") %}
+    {% set sorted_by = optional_args.get("sorted_by") %}
+    {% set merge_schema = optional_args.get("merge_schema", true) %}
+    {% set bucket_count = optional_args.get("bucket_count") %}
+    {% set field_delimiter = optional_args.get("field_delimiter") %}
+
+import pyspark
+
 
 {{ compiled_code }}
 def materialize(spark_session, df, target_relation):
@@ -23,20 +24,20 @@ def materialize(spark_session, df, target_relation):
         else:
             msg = f"{type(df)} is not a supported type for dbt Python materialization"
             raise Exception(msg)
-        df.write \
+        writer = df.write \
         .format("{{ format }}") \
         .mode("{{ mode }}") \
-        .partitionBy("{{ partitioned_by }}") \
-        .bucketBy("{{ bucketed_by }}") \
-        .sortBy(" {{ sorted_by }}") \
         .option("path", "{{ location }}") \
         .option("compression", "{{ write_compression }}") \
         .option("mergeSchema", "{{ merge_schema }}") \
-        .option("numBuckets", "{{ bucket_count }}") \
-        .option("delimiter", "{{ field_delimiter }}") \
-        .option("tableType", "{{ table_type }}") \
-        .option("extra", "{{ extra_table_properties }}") \
-        .saveAsTable(
+        .option("delimiter", "{{ field_delimiter }}")
+        if {{ partitioned_by }} is not None:
+            writer = writer.partitionBy({{ partitioned_by }})
+        if {{ bucketed_by }} is not None:
+            writer = writer.bucketBy({{ bucket_count }},{{ bucketed_by }})
+        if {{ sorted_by }} is not None:
+            writer = writer.sortBy({{ sorted_by }})
+        writer.saveAsTable(
             name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
         )
         return "OK"
@@ -45,12 +46,15 @@ def materialize(spark_session, df, target_relation):
 
 {{ athena__py_get_spark_dbt_object() }}
 
-dbt = SparkdbtObj(spark)
-df = model(dbt, dbt.spark_session)
-materialize(dbt.spark_session, df, dbt.this)
+dbt = SparkdbtObj()
+df = model(dbt, spark)
+materialize(spark, df, dbt.this)
 {%- endmacro -%}
 
 {%- macro athena__py_execute_query(query) -%}
+import pyspark 
+
+
 {{ athena__py_get_spark_dbt_object() }}
 
 def execute_query(spark_session):
@@ -61,46 +65,29 @@ def execute_query(spark_session):
     except Exception:
         raise
 
-dbt = SparkdbtObj(spark)
-execute_query(dbt, dbt.spark_session)
+dbt = SparkdbtObj()
+execute_query(spark)
 {%- endmacro -%}
 
 {%- macro athena__py_get_spark_dbt_object() -%}
-class SparkdbtObj(dbtObj, spark_session):
-    def __init__(self) -> None:
-        super().__init__(load_df_function=spark.table)
-        self.spark_session = spark_session
-        
-    @property
-    def source(self, *args):
-        """
-        Override the source attribute dynamically
-
-        spark.table('awsdatacatalog.analytics_dev.model')
-        Raises pyspark.sql.utils.AnalysisException:
-        spark_catalog requires a single-part namespace,
-        but got [awsdatacatalog, analytics_dev]
+def get_spark_df(identifier):
+    """
+    Override the arguments to ref and source dynamically
 
-        So the override removes the catalog component and only
-        provides the schema and identifer to spark.table()
-        """
-        args = [arg[arg.index('.')+1:] for arg in args]
-        return lambda *args: source(*args, dbt_load_df_function=spark.table)
-    
-    @property
-    def ref(self, *args):
-        """
-        Override the ref attribute dynamically
+    spark.table('awsdatacatalog.analytics_dev.model')
+    Raises pyspark.sql.utils.AnalysisException:
+    spark_catalog requires a single-part namespace,
+    but got [awsdatacatalog, analytics_dev]
 
-        spark.table('awsdatacatalog.analytics_dev.model')
-        Raises pyspark.sql.utils.AnalysisException:
-        spark_catalog requires a single-part namespace,
-        but got [awsdatacatalog, analytics_dev]
+    So the override removes the catalog component and only
+    provides the schema and identifer to spark.table()
+    """
+    return spark.table(identifier.split(".", 1)[1])
 
-        So the override removes the catalog component and only
-        provides the schema and identifer to spark.table()
-        """
-        args = [arg[arg.index('.')+1:] for arg in args]
-        return lambda *args: ref(*args, dbt_load_df_function=spark.table)
+class SparkdbtObj(dbtObj):
+    def __init__(self):
+        super().__init__(load_df_function=get_spark_df)
+        self.source = lambda *args: source(*args, dbt_load_df_function=get_spark_df)
+        self.ref = lambda *args: ref(*args, dbt_load_df_function=get_spark_df)
 
 {%- endmacro -%}
\ No newline at end of file
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index e0793781..74644ae8 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -78,19 +78,20 @@
       {{ compiled_code }}
   {%- elif language == 'python' -%}
     {{ athena__py_save_table_as(
-      compiled_code,
-      target_relation,
-      location=location,
-      format=format,
-      mode="overwrite",
-      partitioned_by=partitioned_by,
-      bucketed_by=bucketed_by,
-      write_compression=write_compression,
-      bucket_count=bucket_count,
-      field_delimiter=field_delimiter,
-      table_type=table_type,
-      extra_table_properties=extra_table_properties
-      ) }}
+        compiled_code,
+        relation,
+        optional_args={
+          'location': location,
+          'format': format,
+          'mode': 'overwrite',
+          'partitioned_by': partitioned_by,
+          'bucketed_by': bucketed_by,
+          'write_compression': write_compression,
+          'bucket_count': bucket_count,
+          'field_delimiter': field_delimiter
+        }
+      )
+    }}
   {%- else -%}
     {% do exceptions.raise_compiler_error("athena__create_table_as macro doesn't support the provided language, it got %s" % language) %}
   {%- endif -%}

From 883519e346ea4d667f048397ba69b21de91bf4d6 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Mon, 24 Apr 2023 00:27:05 -0300
Subject: [PATCH 38/75] Renamed functions and fixed minor bugs

---
 dbt/adapters/athena/python_submissions.py | 58 ++++++++++++-----------
 1 file changed, 31 insertions(+), 27 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 93126ac6..39c95615 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -10,7 +10,7 @@
 from dbt.events import AdapterLogger
 from dbt.exceptions import DbtRuntimeError
 
-DEFAULT_POLLING_INTERVAL = 5
+DEFAULTpollING_INTERVAL = 5
 DEFAULT_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
 SUBMISSION_LANGUAGE = "python"
 DEFAULT_TIMEOUT = 60 * 60 * 2
@@ -63,9 +63,9 @@ def schema(self) -> str:
     @property
     @lru_cache()
     def session_id(self) -> str:
-        return self._set_session_id()
+        return self.set_session_id()
 
-    def _set_session_id(self) -> str:
+    def set_session_id(self) -> str:
         """
         Get the session ID.
 
@@ -78,12 +78,14 @@ def _set_session_id(self) -> str:
         """
         session_info = self._list_sessions()
         if session_info.get("SessionId") is None:
-            return self._start_session()["SessionId"]
+            return self.start_session()["SessionId"]
         return session_info["SessionId"]
 
     @property
     def spark_work_group(self) -> str:
-        return self.credentials.spark_work_group or "spark"
+        if self.credentials.spark_work_group is None:
+            raise ValueError("Need spark group for executing python functions. Add it to your dbt profile")
+        return self.credentials.spark_work_group
 
     def get_athena_client(self) -> Any:
         """
@@ -102,9 +104,9 @@ def get_athena_client(self) -> Any:
 
     @property
     def timeout(self) -> int:
-        return self._set_timeout()
+        return self.set_timeout()
 
-    def _set_timeout(self) -> int:
+    def set_timeout(self) -> int:
         """
         Get the timeout value.
 
@@ -133,10 +135,10 @@ def _set_timeout(self) -> int:
 
     @property
     def polling_interval(self):
-        return self._set_polling_interval()
+        return self.set_polling_interval()
 
-    def _set_polling_interval(self) -> int:
-        polling_interval = self.parsed_model.get("config", {}).get("polling_interval", DEFAULT_POLLING_INTERVAL)
+    def set_polling_interval(self) -> int:
+        polling_interval = self.parsed_model.get("config", {}).get("polling_interval", DEFAULTpollING_INTERVAL)
         if not isinstance(polling_interval, int) or polling_interval <= 0:
             raise ValueError("polling_interval must be a positive integer")
         logger.info(f"Setting polling_interval: {polling_interval}")
@@ -144,9 +146,9 @@ def _set_polling_interval(self) -> int:
 
     @property
     def engine_config(self):
-        return self._set_engine_config()
+        return self.set_engine_config()
 
-    def _set_engine_config(self) -> dict:
+    def set_engine_config(self) -> dict:
         engine_config = self.parsed_model.get("config", {}).get("engine_config", DEFAULT_ENGINE_CONFIG)
         if not isinstance(engine_config, dict):
             raise TypeError("engine configuration has to be of type dict")
@@ -174,7 +176,7 @@ def _list_sessions(self) -> dict:
             return {}
         return response.get("Sessions")[0]
 
-    def _start_session(self) -> dict:
+    def start_session(self) -> dict:
         """
         Start an Athena session.
 
@@ -191,27 +193,30 @@ def _start_session(self) -> dict:
             EngineConfiguration=self.engine_config,
         )
         if response["State"] != "IDLE":
-            self._poll_until_session_creation(response["SessionId"])
+            self.poll_until_session_creation(response["SessionId"])
         return response
-    
-    def _get_current_session_status(self) -> str:
+
+    def get_current_session_status(self) -> str:
         """
         Get the current session status.
 
         Returns:
             str: The status of the session
         """
-        return self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
-    
-    def _poll_until_session_idle(self):
+        return self.athena_client.get_session_status(SessionId=self.session_id)["Status"]["State"]
+
+    def poll_until_session_idle(self):
         polling_interval = self.polling_interval
         while True:
-            session_status = self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
+            session_status = self.athena_client.get_session_status(SessionId=self.session_id)["Status"]["State"]
             if session_status == "IDLE":
                 return session_status
             if session_status in ["FAILED", "TERMINATED", "DEGRADED"]:
                 return DbtRuntimeError(f"The session chosen was not available. Got status: {session_status}")
-
+            time.sleep(polling_interval)
+            polling_interval *= 2
+            if polling_interval > self.timeout:
+                raise DbtRuntimeError(f"Session {self.session_id} did not become free within {self.timeout} seconds.")
 
     def submit(self, compiled_code: str) -> dict:
         """
@@ -233,8 +238,8 @@ def submit(self, compiled_code: str) -> dict:
             DbtRuntimeError: If the execution ends in a state other than "COMPLETED".
 
         """
-        if self._get_current_session_status() == "BUSY":
-            self._poll_until_session_idle()
+        if self.get_current_session_status() == "BUSY":
+            self.poll_until_session_idle()
         try:
             calculation_execution_id = self.athena_client.start_calculation_execution(
                 SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
@@ -242,7 +247,7 @@ def submit(self, compiled_code: str) -> dict:
         except Exception as e:
             raise DbtRuntimeError(f"Unable to complete python execution. Got: {e}")
         try:
-            execution_status = self._poll_until_execution_completion(calculation_execution_id)
+            execution_status = self.poll_until_execution_completion(calculation_execution_id)
         except Exception as e:
             logger.error(f"Unable to poll execution status: Got: {e}")
         finally:
@@ -256,7 +261,6 @@ def submit(self, compiled_code: str) -> dict:
         else:
             raise DbtRuntimeError(f"python model run ended in state {execution_status}")
 
-
     def _terminate_session(self) -> None:
         """
         Terminate the current Athena session.
@@ -277,7 +281,7 @@ def _terminate_session(self) -> None:
             logger.debug(f"Terminating session: {self.session_id}")
             self.athena_client.terminate_session(SessionId=self.session_id)
 
-    def _poll_until_execution_completion(self, calculation_execution_id):
+    def poll_until_execution_completion(self, calculation_execution_id):
         """
         Poll the status of a calculation execution until it is completed, failed, or cancelled.
 
@@ -312,7 +316,7 @@ def _poll_until_execution_completion(self, calculation_execution_id):
                     f"Execution {calculation_execution_id} did not complete within {self.timeout} seconds."
                 )
 
-    def _poll_until_session_creation(self, session_id):
+    def poll_until_session_creation(self, session_id):
         """
         Polls the status of an Athena session creation until it is completed or reaches the timeout.
 

From 890b601477cb30a437f5f74634d07d79b4a0e34f Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Mon, 24 Apr 2023 19:31:52 -0300
Subject: [PATCH 39/75] Fixed CI

---
 dbt/include/athena/macros/adapters/python_submissions.sql | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index 8b175dae..cb7fd16f 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -52,7 +52,7 @@ materialize(spark, df, dbt.this)
 {%- endmacro -%}
 
 {%- macro athena__py_execute_query(query) -%}
-import pyspark 
+import pyspark
 
 
 {{ athena__py_get_spark_dbt_object() }}
@@ -90,4 +90,4 @@ class SparkdbtObj(dbtObj):
         self.source = lambda *args: source(*args, dbt_load_df_function=get_spark_df)
         self.ref = lambda *args: ref(*args, dbt_load_df_function=get_spark_df)
 
-{%- endmacro -%}
\ No newline at end of file
+{%- endmacro -%}

From ee9bfd863040e68d79a3df56a31df3f43016d0d8 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Mon, 24 Apr 2023 19:57:22 -0300
Subject: [PATCH 40/75] Fix names in test

---
 dbt/adapters/athena/python_submissions.py | 12 ++++-----
 tests/unit/test_python_submissions.py     | 30 +++++++++++------------
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 39c95615..6d2b59d2 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -10,7 +10,7 @@
 from dbt.events import AdapterLogger
 from dbt.exceptions import DbtRuntimeError
 
-DEFAULTpollING_INTERVAL = 5
+DEFAULT_POLLING_INTERVAL = 5
 DEFAULT_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
 SUBMISSION_LANGUAGE = "python"
 DEFAULT_TIMEOUT = 60 * 60 * 2
@@ -76,7 +76,7 @@ def set_session_id(self) -> str:
             str: The session ID.
 
         """
-        session_info = self._list_sessions()
+        session_info = self.list_sessions()
         if session_info.get("SessionId") is None:
             return self.start_session()["SessionId"]
         return session_info["SessionId"]
@@ -138,7 +138,7 @@ def polling_interval(self):
         return self.set_polling_interval()
 
     def set_polling_interval(self) -> int:
-        polling_interval = self.parsed_model.get("config", {}).get("polling_interval", DEFAULTpollING_INTERVAL)
+        polling_interval = self.parsed_model.get("config", {}).get("polling_interval", DEFAULT_POLLING_INTERVAL)
         if not isinstance(polling_interval, int) or polling_interval <= 0:
             raise ValueError("polling_interval must be a positive integer")
         logger.info(f"Setting polling_interval: {polling_interval}")
@@ -159,7 +159,7 @@ def set_engine_config(self) -> dict:
 
         return engine_config
 
-    def _list_sessions(self) -> dict:
+    def list_sessions(self) -> dict:
         """
         List Athena sessions.
 
@@ -251,7 +251,7 @@ def submit(self, compiled_code: str) -> dict:
         except Exception as e:
             logger.error(f"Unable to poll execution status: Got: {e}")
         finally:
-            self._terminate_session()
+            self.terminate_session()
         logger.debug(f"Received execution status {execution_status}")
         if execution_status == "COMPLETED":
             result_s3_uri = self.athena_client.get_calculation_execution(
@@ -261,7 +261,7 @@ def submit(self, compiled_code: str) -> dict:
         else:
             raise DbtRuntimeError(f"python model run ended in state {execution_status}")
 
-    def _terminate_session(self) -> None:
+    def terminate_session(self) -> None:
         """
         Terminate the current Athena session.
 
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 406ad05b..0c1e174d 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -45,14 +45,14 @@ def athena_job_helper(self, athena_credentials, athena_client, monkeypatch):
             ),
         ],
     )
-    def test_start_session(self, session_status_response, expected_response, athena_job_helper, athena_client) -> None:
+    def teststart_session(self, session_status_response, expected_response, athena_job_helper, athena_client) -> None:
         """
-        Test the _start_session method of the AthenaJobHelper class.
+        Test the start_session method of the AthenaJobHelper class.
 
         Args:
             session_status_response (dict): A dictionary containing the response from the Athena session
             creation status.
-            expected_response (Union[dict, DbtRuntimeError]): The expected response from the _start_session method.
+            expected_response (Union[dict, DbtRuntimeError]): The expected response from the start_session method.
             athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
             athena_client (botocore.client.BaseClient): An instance of the botocore Athena client.
 
@@ -61,13 +61,13 @@ def test_start_session(self, session_status_response, expected_response, athena_
         """
         with patch.multiple(
             athena_job_helper,
-            _poll_until_session_creation=Mock(return_value=session_status_response),
+            poll_until_session_creation=Mock(return_value=session_status_response),
         ), patch.multiple(
             athena_client,
             get_session_status=Mock(return_value=session_status_response),
             start_session=Mock(return_value=session_status_response.get("Status")),
         ):
-            response = athena_job_helper._start_session()
+            response = athena_job_helper.start_session()
             assert response == expected_response
 
     @pytest.mark.parametrize(
@@ -134,7 +134,7 @@ def test_list_sessions(self, session_status_response, expected_response, athena_
             AssertionError: If the output of the _list_sessions method does not match the expected output.
         """
         with patch.object(athena_client, "list_sessions", return_value=session_status_response):
-            response = athena_job_helper._list_sessions()
+            response = athena_job_helper.list_sessions()
             assert response == expected_response
 
     @pytest.mark.parametrize(
@@ -162,7 +162,7 @@ def test_set_timeout(self, parsed_models, expected_timeout, athena_job_helper, m
             None
         """
         monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
-        response = athena_job_helper._set_timeout()
+        response = athena_job_helper.set_timeout()
         assert response == expected_timeout
 
     @pytest.mark.parametrize(
@@ -181,7 +181,7 @@ def test_set_polling_interval(
         self, parsed_models, expected_polling_interval, athena_job_helper, monkeypatch
     ) -> None:
         """
-        Test method to verify that _set_polling_interval() method of AthenaPythonJobHelper
+        Test method to verify that set_polling_interval() method of AthenaPythonJobHelper
         sets the correct polling interval value based on the parsed model configuration.
 
         Args:
@@ -196,7 +196,7 @@ def test_set_polling_interval(
             None
         """
         monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
-        response = athena_job_helper._set_polling_interval()
+        response = athena_job_helper.set_polling_interval()
         assert response == expected_polling_interval
 
     @pytest.mark.parametrize(
@@ -234,7 +234,7 @@ def test_set_polling_interval(
     )
     def test_set_engine_config(self, parsed_models, expected_engine_config, athena_job_helper, monkeypatch) -> None:
         """
-        Test method to verify the `_set_engine_config()` method of the AthenaPythonJobHelper class.
+        Test method to verify the `set_engine_config()` method of the AthenaPythonJobHelper class.
 
         Args:
             parsed_models: A dictionary containing the parsed model configuration data.
@@ -251,8 +251,8 @@ def test_set_engine_config(self, parsed_models, expected_engine_config, athena_j
         monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
         if parsed_models.get("alias") == "test_wrong_model":
             with pytest.raises(KeyError):
-                athena_job_helper._set_engine_config()
-        response = athena_job_helper._set_engine_config()
+                athena_job_helper.set_engine_config()
+        response = athena_job_helper.set_engine_config()
         assert response == expected_engine_config
 
     @pytest.mark.parametrize(
@@ -315,10 +315,10 @@ def test_terminate_session(
             terminate_session=Mock(return_value=expected_response),
         ), patch.multiple(
             athena_job_helper,
-            _set_session_id=Mock(return_value=test_session_id),
-            _set_timeout=Mock(return_value=10),
+            set_session_id=Mock(return_value=test_session_id),
+            set_timeout=Mock(return_value=10),
         ):
-            terminate_session_response = athena_job_helper._terminate_session()
+            terminate_session_response = athena_job_helper.terminate_session()
             assert terminate_session_response == expected_response
 
     def test_poll_session_creation(self):

From 24cb7ff0a34dd8336980c20fe3b17b163c0aca4f Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Wed, 26 Apr 2023 15:30:34 -0300
Subject: [PATCH 41/75] Handle botocore client error

---
 dbt/adapters/athena/python_submissions.py | 41 ++++++++++++++++-------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 6d2b59d2..2fb43c05 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -4,6 +4,7 @@
 from typing import Any, Dict
 
 import boto3
+import botocore
 
 from dbt.adapters.athena.connections import AthenaCredentials
 from dbt.adapters.base import PythonJobHelper
@@ -63,7 +64,9 @@ def schema(self) -> str:
     @property
     @lru_cache()
     def session_id(self) -> str:
-        return self.set_session_id()
+        session_id = self.set_session_id()
+        logger.info(f"Setting session id: {session_id}")
+        return session_id
 
     def set_session_id(self) -> str:
         """
@@ -84,7 +87,7 @@ def set_session_id(self) -> str:
     @property
     def spark_work_group(self) -> str:
         if self.credentials.spark_work_group is None:
-            raise ValueError("Need spark group for executing python functions. Add it to your dbt profile")
+            raise ValueError("Need a spark group for executing python functions. Add it to your dbt profile.")
         return self.credentials.spark_work_group
 
     def get_athena_client(self) -> Any:
@@ -103,6 +106,7 @@ def get_athena_client(self) -> Any:
         ).client("athena")
 
     @property
+    @lru_cache()
     def timeout(self) -> int:
         return self.set_timeout()
 
@@ -134,6 +138,7 @@ def set_timeout(self) -> int:
         return timeout
 
     @property
+    @lru_cache()
     def polling_interval(self):
         return self.set_polling_interval()
 
@@ -145,6 +150,7 @@ def set_polling_interval(self) -> int:
         return polling_interval
 
     @property
+    @lru_cache()
     def engine_config(self):
         return self.set_engine_config()
 
@@ -203,12 +209,12 @@ def get_current_session_status(self) -> str:
         Returns:
             str: The status of the session
         """
-        return self.athena_client.get_session_status(SessionId=self.session_id)["Status"]["State"]
+        return self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
 
     def poll_until_session_idle(self):
         polling_interval = self.polling_interval
         while True:
-            session_status = self.athena_client.get_session_status(SessionId=self.session_id)["Status"]["State"]
+            session_status = self.get_current_session_status()["State"]
             if session_status == "IDLE":
                 return session_status
             if session_status in ["FAILED", "TERMINATED", "DEGRADED"]:
@@ -238,14 +244,23 @@ def submit(self, compiled_code: str) -> dict:
             DbtRuntimeError: If the execution ends in a state other than "COMPLETED".
 
         """
-        if self.get_current_session_status() == "BUSY":
-            self.poll_until_session_idle()
-        try:
-            calculation_execution_id = self.athena_client.start_calculation_execution(
-                SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
-            )["CalculationExecutionId"]
-        except Exception as e:
-            raise DbtRuntimeError(f"Unable to complete python execution. Got: {e}")
+        while True:
+            try:
+                calculation_execution_id = self.athena_client.start_calculation_execution(
+                    SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
+                )["CalculationExecutionId"]
+                break
+            except botocore.exceptions.ClientError as ce:
+                logger.exception(f"Encountered client error: {ce}")
+                if (
+                    ce.response["Error"]["Code"] == "InvalidRequestException"
+                    and "Session is in the BUSY state; needs to be IDLE to accept Calculations."
+                    in ce.response["Error"]["Message"]
+                ):
+                    logger.exception("Going to poll until session is IDLE")
+                    self.poll_until_session_idle()
+            except Exception as e:
+                raise DbtRuntimeError(f"Unable to complete python execution. Got: {e}")
         try:
             execution_status = self.poll_until_execution_completion(calculation_execution_id)
         except Exception as e:
@@ -274,7 +289,7 @@ def terminate_session(self) -> None:
             dict: The response from the Athena client after terminating the session.
 
         """
-        session_status = self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
+        session_status = self.get_current_session_status()
         if session_status["State"] in ["IDLE", "BUSY"] and (
             session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
         ):

From 08ec29f22fa6ddee865d7ad44a9ee6eb68bec790 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Sun, 30 Apr 2023 19:33:58 -0300
Subject: [PATCH 42/75] Fix conflict

---
 .../macros/materializations/models/table/table.sql       | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/dbt/include/athena/macros/materializations/models/table/table.sql b/dbt/include/athena/macros/materializations/models/table/table.sql
index 5857db21..d4e8d2cf 100644
--- a/dbt/include/athena/macros/materializations/models/table/table.sql
+++ b/dbt/include/athena/macros/materializations/models/table/table.sql
@@ -13,10 +13,11 @@
 
   {{ run_hooks(pre_hooks) }}
 
-  -- cleanup
-  {%- if old_relation is not none -%}
-    {{ drop_relation(old_relation) }}
-  {%- endif -%}
+  {%- if old_relation is none or table_type != 'iceberg' -%}
+    -- cleanup
+    {%- if old_relation is not none and language != 'python' -%}
+      {{ drop_relation(old_relation) }}
+    {%- endif -%}
 
     {%- call statement('main', language=language) -%}
       {{ create_table_as(False, target_relation, compiled_code, language) }}

From 2720dfcdc17daae6819fcb824b056fa827d726bf Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Wed, 3 May 2023 19:43:15 -0300
Subject: [PATCH 43/75] Added threading support

---
 dbt/adapters/athena/python_submissions.py     | 390 ++++++++++--------
 .../macros/adapters/python_submissions.sql    |   4 -
 .../materializations/models/table/table.sql   |   4 +-
 tests/unit/test_python_submissions.py         |   2 +-
 4 files changed, 223 insertions(+), 177 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 2fb43c05..a3edbf0a 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -1,7 +1,9 @@
+import threading
 import time
+import uuid
 from datetime import datetime, timedelta, timezone
 from functools import lru_cache
-from typing import Any, Dict
+from typing import Dict, List
 
 import boto3
 import botocore
@@ -15,82 +17,74 @@
 DEFAULT_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
 SUBMISSION_LANGUAGE = "python"
 DEFAULT_TIMEOUT = 60 * 60 * 2
+DEFAULT_SESSION_COUNT = 16
 
 logger = AdapterLogger("Athena")
+session_locks = {}
 
 
-class AthenaPythonJobHelper(PythonJobHelper):
-    """
-     A helper class for executing Python jobs on AWS Athena.
+class AthenaSparkSessionConfig:
+    def __init__(self, config: dict):
+        self.config = config
 
-    This class extends the base `PythonJobHelper` class and provides additional functionality
-    specific to executing jobs on Athena. It takes a parsed model and credentials as inputs
-    during initialization, and provides methods for executing Athena jobs, setting timeout,
-    polling interval, region name, AWS profile name, and Spark work group.
+    def set_timeout(self) -> int:
+        """
+        Get the timeout value.
 
-    Args:
-        parsed_model (Dict): A dictionary representing the parsed model of the Athena job.
-            It should contain keys such as 'alias' for job identifier and 'schema' for
-            job schema.
-        credentials (AthenaCredentials): An instance of the `AthenaCredentials` class
-            containing AWS credentials for accessing Athena.
+        This function retrieves the timeout value from the parsed model's configuration. If the timeout value
+        is not defined, it falls back to the default timeout value. If the retrieved timeout value is less than or
+        equal to 0, a ValueError is raised as timeout must be a positive integer.
 
-    Attributes:
-        identifier (str): A string representing the alias or identifier of the Athena job.
-        schema (str): A string representing the schema of the Athena job.
-        parsed_model (Dict): A dictionary representing the parsed model of the Athena job.
-        timeout (int): An integer representing the timeout value in seconds for the Athena job.
-        polling_interval (int): An integer representing the polling interval in seconds for
-            checking the status of the Athena job.
-        region_name (str): A string representing the AWS region name for executing the Athena job.
-        profile_name (str): A string representing the AWS profile name for accessing Athena.
-        spark_work_group (str): A string representing the Spark work group for executing the Athena job.
+        Returns:
+            int: The timeout value in seconds.
 
-    """
+        Raises:
+            ValueError: If the timeout value is not a positive integer.
 
-    def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
-        self.parsed_model = parsed_model
-        self.credentials = credentials
-        self.athena_client = self.get_athena_client()
+        """
+        timeout = self.config.get("timeout", DEFAULT_TIMEOUT)
+        if not isinstance(timeout, int):
+            raise TypeError("Timeout must be an integer")
+        if timeout <= 0:
+            raise ValueError("Timeout must be a positive integer")
+        logger.debug(f"Setting timeout: {timeout}")
+        return timeout
 
-    @property
-    def identifier(self) -> str:
-        return self.parsed_model["alias"]
+    def set_polling_interval(self) -> int:
+        polling_interval = self.config.get("polling_interval", DEFAULT_POLLING_INTERVAL)
+        if not isinstance(polling_interval, int) or polling_interval <= 0:
+            raise ValueError("polling_interval must be a positive integer")
+        logger.debug(f"Setting polling_interval: {polling_interval}")
+        return polling_interval
 
-    @property
-    def schema(self) -> str:
-        return self.parsed_model["schema"]
+    def set_engine_config(self) -> dict:
+        engine_config = self.config.get("engine_config", DEFAULT_ENGINE_CONFIG)
+        if not isinstance(engine_config, dict):
+            raise TypeError("engine configuration has to be of type dict")
 
-    @property
-    @lru_cache()
-    def session_id(self) -> str:
-        session_id = self.set_session_id()
-        logger.info(f"Setting session id: {session_id}")
-        return session_id
+        expected_keys = {"CoordinatorDpuSize", "MaxConcurrentDpus", "DefaultExecutorDpuSize"}
+        if set(engine_config.keys()) != expected_keys:
+            raise KeyError(f"The keys of the dictionary entered do not match the expected format: {expected_keys}")
+        return engine_config
 
-    def set_session_id(self) -> str:
-        """
-        Get the session ID.
 
-        This function retrieves the session ID from the stored session information. If session information
-        is not available, a new session is started and its session ID is returned.
+class AthenaSparkSessionManager:
+    """_summary_
 
-        Returns:
-            str: The session ID.
+    Args:
+        AthenaConnectionManager (AthenaConnectionManager): _description_
+    """
 
-        """
-        session_info = self.list_sessions()
-        if session_info.get("SessionId") is None:
-            return self.start_session()["SessionId"]
-        return session_info["SessionId"]
+    def __init__(self, credentials: str, **kwargs):
+        self.credentials = credentials
+        self.timeout = kwargs.get("timeout")
+        self.polling_interval = kwargs.get("polling_interval")
+        self.engine_config = kwargs.get("engine_config")
+        self.lock = threading.Lock()
 
     @property
-    def spark_work_group(self) -> str:
-        if self.credentials.spark_work_group is None:
-            raise ValueError("Need a spark group for executing python functions. Add it to your dbt profile.")
-        return self.credentials.spark_work_group
-
-    def get_athena_client(self) -> Any:
+    @lru_cache
+    def athena_client(self):
         """
         Get the AWS Athena client.
 
@@ -105,69 +99,42 @@ def get_athena_client(self) -> Any:
             region_name=self.credentials.region_name, profile_name=self.credentials.aws_profile_name
         ).client("athena")
 
-    @property
-    @lru_cache()
-    def timeout(self) -> int:
-        return self.set_timeout()
+    def get_sessions(self) -> List[uuid.UUID]:
+        sessions = self.list_sessions()
+        existing_sessions = set(session_locks.keys())
+        new_sessions = [session["SessionId"] for session in sessions if session["SessionId"] not in existing_sessions]
+        logger.debug(f"Setting sessions: {new_sessions}")
+        return [uuid.UUID(session) for session in new_sessions]
 
-    def set_timeout(self) -> int:
+    def update_session_locks(self) -> None:
+        for session_uuid in self.get_sessions():
+            session_locks.setdefault(session_uuid, threading.Lock())
+        logger.debug(f"Updated session locks: {session_locks}")
+
+    def get_session_id(self) -> str:
         """
-        Get the timeout value.
+        Get the session ID.
 
-        This function retrieves the timeout value from the parsed model's configuration. If the timeout value
-        is not defined, it falls back to the default timeout value. If the retrieved timeout value is less than or
-        equal to 0, a ValueError is raised as timeout must be a positive integer.
+        This function retrieves the session ID from the stored session information. If session information
+        is not available, a new session is started and its session ID is returned.
 
         Returns:
-            int: The timeout value in seconds.
-
-        Raises:
-            ValueError: If the timeout value is not a positive integer.
+            str: The session ID.
 
         """
-        if self.parsed_model.get("config") is not None:
-            timeout = self.parsed_model["config"].get("timeout", DEFAULT_TIMEOUT)
-            if not isinstance(timeout, int):
-                raise TypeError("Timeout must be an integer")
-            if timeout <= 0:
-                raise ValueError("Timeout must be a positive integer")
-            logger.info(f"Setting timeout: {timeout}")
-        else:
-            logger.info(f"Using default timeout: {DEFAULT_TIMEOUT}")
-            timeout = DEFAULT_TIMEOUT
-        return timeout
-
-    @property
-    @lru_cache()
-    def polling_interval(self):
-        return self.set_polling_interval()
-
-    def set_polling_interval(self) -> int:
-        polling_interval = self.parsed_model.get("config", {}).get("polling_interval", DEFAULT_POLLING_INTERVAL)
-        if not isinstance(polling_interval, int) or polling_interval <= 0:
-            raise ValueError("polling_interval must be a positive integer")
-        logger.info(f"Setting polling_interval: {polling_interval}")
-        return polling_interval
-
-    @property
-    @lru_cache()
-    def engine_config(self):
-        return self.set_engine_config()
-
-    def set_engine_config(self) -> dict:
-        engine_config = self.parsed_model.get("config", {}).get("engine_config", DEFAULT_ENGINE_CONFIG)
-        if not isinstance(engine_config, dict):
-            raise TypeError("engine configuration has to be of type dict")
-
-        expected_keys = {"CoordinatorDpuSize", "MaxConcurrentDpus", "DefaultExecutorDpuSize"}
-        if set(engine_config.keys()) != expected_keys:
-            raise KeyError(f"The keys of the dictionary entered do not match the expected format: {expected_keys}")
-
-        return engine_config
-
-    def list_sessions(self) -> dict:
+        self.update_session_locks()
+        with self.lock:
+            for session_uuid, lock in session_locks.items():
+                if not lock.locked():
+                    logger.debug(f"Locking existing session: {session_uuid}")
+                    lock.acquire()
+                    return session_uuid
+        logger.debug("All sessions are currently locked. Starting new session.")
+        return self.start_session()
+
+    def list_sessions(self, max_results: int = DEFAULT_SESSION_COUNT, state: str = "IDLE") -> dict:
         """
-        List Athena sessions.
+        List idle athena spark sessions.
 
         This function sends a request to the Athena service to list the sessions in the specified Spark workgroup.
         It filters the sessions by state, only returning the first session that is in IDLE state. If no idle sessions
@@ -177,10 +144,12 @@ def list_sessions(self) -> dict:
             dict: The session information dictionary if an idle session is found, None otherwise.
 
         """
-        response = self.athena_client.list_sessions(WorkGroup=self.spark_work_group, MaxResults=1, StateFilter="IDLE")
+        response = self.athena_client.list_sessions(
+            WorkGroup=self.credentials.spark_work_group, MaxResults=max_results, StateFilter=state
+        )
         if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
             return {}
-        return response.get("Sessions")[0]
+        return response.get("Sessions")
 
     def start_session(self) -> dict:
         """
@@ -194,13 +163,141 @@ def start_session(self) -> dict:
             dict: The session information dictionary.
 
         """
-        response = self.athena_client.start_session(
-            WorkGroup=self.spark_work_group,
-            EngineConfiguration=self.engine_config,
+        with self.lock:
+            if len(session_locks) >= DEFAULT_SESSION_COUNT:
+                # Raise this exception but also poll until a session is free and assign that
+                raise Exception(
+                    f"""Maximum session count: {DEFAULT_SESSION_COUNT} reached.
+                    Cannot start new spark session."""
+                )
+            response = self.athena_client.start_session(
+                WorkGroup=self.credentials.spark_work_group,
+                EngineConfiguration=self.engine_config,
+            )
+            if response["State"] != "IDLE":
+                self.poll_until_session_creation(response["SessionId"])
+            session_uuid = uuid.UUID(response["SessionId"])
+            logger.debug(f"Locking new session: {session_uuid}")
+            lock = threading.Lock()
+            session_locks[session_uuid] = lock
+            session_locks[session_uuid].acquire()
+            return session_uuid
+
+    def poll_until_session_creation(self, session_id):
+        """
+        Polls the status of an Athena session creation until it is completed or reaches the timeout.
+
+        Args:
+            session_id (str): The ID of the session being created.
+
+        Returns:
+            str: The final status of the session, which will be "IDLE" if the session creation is successful.
+
+        Raises:
+            DbtRuntimeError: If the session creation fails, is terminated, or degrades during polling.
+            DbtRuntimeError: If the session does not become IDLE within the specified timeout.
+
+        """
+        polling_interval = self.polling_interval
+        while True:
+            creation_status = self.get_session_status(session_id)["State"]
+            if creation_status in ["FAILED", "TERMINATED", "DEGRADED"]:
+                raise DbtRuntimeError(f"Unable to create session: {session_id}. Got status: {creation_status}.")
+            elif creation_status == "IDLE":
+                return creation_status
+            time.sleep(polling_interval)
+            polling_interval *= 2
+            if polling_interval > self.timeout:
+                raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
+
+    def release_session_lock(self, session_id) -> None:
+        """
+        Terminate the current Athena session.
+
+        This function terminates the current Athena session if it is in IDLE or BUSY state and has exceeded the
+        configured timeout period. It retrieves the session status, and if the session state is IDLE or BUSY and the
+        duration since the session start time exceeds the timeout period, the session is terminated. The session ID is
+        used to terminate the session via the Athena client.
+
+        Returns:
+            dict: The response from the Athena client after terminating the session.
+
+        """
+        session_status = self.get_session_status(session_id)
+        if session_status["State"] in ["IDLE", "BUSY"] and (
+            session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
+        ):
+            logger.debug(f"Terminating session: {session_id}")
+            self.athena_client.terminate_session(SessionId=session_id)
+        with self.lock:
+            logger.debug(f"Releasing lock for session: {session_id}")
+            session_locks[uuid.UUID(session_id)].release()
+
+    def get_session_status(self, session_id) -> str:
+        """
+        Get the session status.
+
+        Returns:
+            str: The status of the session
+        """
+        return self.athena_client.get_session_status(SessionId=session_id)["Status"]
+
+
+class AthenaPythonJobHelper(PythonJobHelper):
+    """
+     A helper class for executing Python jobs on AWS Athena.
+
+    This class extends the base `PythonJobHelper` class and provides additional functionality
+    specific to executing jobs on Athena. It takes a parsed model and credentials as inputs
+    during initialization, and provides methods for executing Athena jobs, setting timeout,
+    polling interval, region name, AWS profile name, and Spark work group.
+
+    Args:
+        parsed_model (Dict): A dictionary representing the parsed model of the Athena job.
+            It should contain keys such as 'alias' for job identifier and 'schema' for
+            job schema.
+        credentials (AthenaCredentials): An instance of the `AthenaCredentials` class
+            containing AWS credentials for accessing Athena.
+
+    Attributes:
+        identifier (str): A string representing the alias or identifier of the Athena job.
+        schema (str): A string representing the schema of the Athena job.
+        parsed_model (Dict): A dictionary representing the parsed model of the Athena job.
+        timeout (int): An integer representing the timeout value in seconds for the Athena job.
+        polling_interval (int): An integer representing the polling interval in seconds for
+            checking the status of the Athena job.
+        region_name (str): A string representing the AWS region name for executing the Athena job.
+        profile_name (str): A string representing the AWS profile name for accessing Athena.
+        spark_work_group (str): A string representing the Spark work group for executing the Athena job.
+
+    """
+
+    def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
+        self.config = AthenaSparkSessionConfig(parsed_model.get("config", {}))
+        self.spark_connection = AthenaSparkSessionManager(
+            credentials, timeout=self.timeout, polling_interval=self.polling_interval, engine_config=self.engine_config
         )
-        if response["State"] != "IDLE":
-            self.poll_until_session_creation(response["SessionId"])
-        return response
+        self.athena_client = self.spark_connection.athena_client
+
+    @property
+    @lru_cache()
+    def timeout(self):
+        return self.config.set_timeout()
+
+    @property
+    @lru_cache()
+    def session_id(self) -> str:
+        return str(self.spark_connection.get_session_id())
+
+    @property
+    @lru_cache()
+    def polling_interval(self):
+        return self.config.set_polling_interval()
+
+    @property
+    @lru_cache()
+    def engine_config(self):
+        return self.config.set_engine_config()
 
     def get_current_session_status(self) -> str:
         """
@@ -266,7 +363,7 @@ def submit(self, compiled_code: str) -> dict:
         except Exception as e:
             logger.error(f"Unable to poll execution status: Got: {e}")
         finally:
-            self.terminate_session()
+            self.spark_connection.release_session_lock(self.session_id)
         logger.debug(f"Received execution status {execution_status}")
         if execution_status == "COMPLETED":
             result_s3_uri = self.athena_client.get_calculation_execution(
@@ -276,26 +373,6 @@ def submit(self, compiled_code: str) -> dict:
         else:
             raise DbtRuntimeError(f"python model run ended in state {execution_status}")
 
-    def terminate_session(self) -> None:
-        """
-        Terminate the current Athena session.
-
-        This function terminates the current Athena session if it is in IDLE or BUSY state and has exceeded the
-        configured timeout period. It retrieves the session status, and if the session state is IDLE or BUSY and the
-        duration since the session start time exceeds the timeout period, the session is terminated. The session ID is
-        used to terminate the session via the Athena client.
-
-        Returns:
-            dict: The response from the Athena client after terminating the session.
-
-        """
-        session_status = self.get_current_session_status()
-        if session_status["State"] in ["IDLE", "BUSY"] and (
-            session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
-        ):
-            logger.debug(f"Terminating session: {self.session_id}")
-            self.athena_client.terminate_session(SessionId=self.session_id)
-
     def poll_until_execution_completion(self, calculation_execution_id):
         """
         Poll the status of a calculation execution until it is completed, failed, or cancelled.
@@ -330,30 +407,3 @@ def poll_until_execution_completion(self, calculation_execution_id):
                 raise DbtRuntimeError(
                     f"Execution {calculation_execution_id} did not complete within {self.timeout} seconds."
                 )
-
-    def poll_until_session_creation(self, session_id):
-        """
-        Polls the status of an Athena session creation until it is completed or reaches the timeout.
-
-        Args:
-            session_id (str): The ID of the session being created.
-
-        Returns:
-            str: The final status of the session, which will be "IDLE" if the session creation is successful.
-
-        Raises:
-            DbtRuntimeError: If the session creation fails, is terminated, or degrades during polling.
-            DbtRuntimeError: If the session does not become IDLE within the specified timeout.
-
-        """
-        polling_interval = self.polling_interval
-        while True:
-            creation_status = self.athena_client.get_session_status(SessionId=session_id)["Status"]["State"]
-            if creation_status in ["FAILED", "TERMINATED", "DEGRADED"]:
-                raise DbtRuntimeError(f"Unable to create session: {session_id}. Got status: {creation_status}.")
-            elif creation_status == "IDLE":
-                return creation_status
-            time.sleep(polling_interval)
-            polling_interval *= 2
-            if polling_interval > self.timeout:
-                raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index cb7fd16f..f0b31215 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -52,13 +52,9 @@ materialize(spark, df, dbt.this)
 {%- endmacro -%}
 
 {%- macro athena__py_execute_query(query) -%}
-import pyspark
-
-
 {{ athena__py_get_spark_dbt_object() }}
 
 def execute_query(spark_session):
-    import pandas
     try:
         spark_session.sql("""{{ query }}""")
         return "OK"
diff --git a/dbt/include/athena/macros/materializations/models/table/table.sql b/dbt/include/athena/macros/materializations/models/table/table.sql
index d4e8d2cf..647f5c79 100644
--- a/dbt/include/athena/macros/materializations/models/table/table.sql
+++ b/dbt/include/athena/macros/materializations/models/table/table.sql
@@ -45,8 +45,8 @@
       {%- do drop_relation(old_relation_bkp) -%}
     {%- endif -%}
 
-    {%- call statement('main') -%}
-      {{ create_table_as(False, tmp_relation, sql) }}
+    {%- call statement('main', language=language) -%}
+      {{ create_table_as(False, tmp_relation, compiled_code, language) }}
     {%- endcall -%}
 
     {{ rename_relation(old_relation, old_relation_bkp) }}
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 0c1e174d..97919ab0 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -45,7 +45,7 @@ def athena_job_helper(self, athena_credentials, athena_client, monkeypatch):
             ),
         ],
     )
-    def teststart_session(self, session_status_response, expected_response, athena_job_helper, athena_client) -> None:
+    def test_start_session(self, session_status_response, expected_response, athena_job_helper, athena_client) -> None:
         """
         Test the start_session method of the AthenaJobHelper class.
 

From 71cd4ee1463427864d9c4e2dd9d8564d0ed0bb43 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 5 May 2023 18:33:15 -0300
Subject: [PATCH 44/75] Added tests for python job helper

---
 dbt/adapters/athena/python_submissions.py |  78 +--
 tests/unit/test_python_submissions.py     | 591 ++++++++++++++--------
 2 files changed, 426 insertions(+), 243 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index a3edbf0a..93e67d8a 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -24,6 +24,10 @@
 
 
 class AthenaSparkSessionConfig:
+    """
+    A helper class to manage Athena Spark Session Configuration.
+    """
+
     def __init__(self, config: dict):
         self.config = config
 
@@ -69,10 +73,8 @@ def set_engine_config(self) -> dict:
 
 
 class AthenaSparkSessionManager:
-    """_summary_
-
-    Args:
-        AthenaConnectionManager (AthenaConnectionManager): _description_
+    """
+    A helper class to manage Athena Spark Sessions.
     """
 
     def __init__(self, credentials: str, **kwargs):
@@ -81,10 +83,9 @@ def __init__(self, credentials: str, **kwargs):
         self.polling_interval = kwargs.get("polling_interval")
         self.engine_config = kwargs.get("engine_config")
         self.lock = threading.Lock()
+        self.athena_client = self.get_athena_client()
 
-    @property
-    @lru_cache
-    def athena_client(self):
+    def get_athena_client(self):
         """
         Get the AWS Athena client.
 
@@ -130,11 +131,16 @@ def get_session_id(self) -> str:
                     lock.acquire()
                     return session_uuid
         logger.debug("All sessions are currently locked. Starting new session.")
-        return self.start_session()
+        session_uuid = uuid.UUID(self.start_session())
+        with self.lock:
+            logger.debug(f"Locking new session: {session_uuid}")
+            session_locks[session_uuid] = threading.Lock()
+            session_locks[session_uuid].acquire()
+            return session_uuid
 
     def list_sessions(self, max_results: int = DEFAULT_SESSION_COUNT, state: str = "IDLE") -> dict:
         """
-        List idle athena spark sessions.
+        List athena spark sessions.
 
         This function sends a request to the Athena service to list the sessions in the specified Spark workgroup.
         It filters the sessions by state, only returning the first session that is in IDLE state. If no idle sessions
@@ -163,25 +169,19 @@ def start_session(self) -> dict:
             dict: The session information dictionary.
 
         """
-        with self.lock:
-            if len(session_locks) >= DEFAULT_SESSION_COUNT:
-                # Raise this exception but also poll until a session is free and assign that
-                raise Exception(
-                    f"""Maximum session count: {DEFAULT_SESSION_COUNT} reached.
-                    Cannot start new spark session."""
-                )
-            response = self.athena_client.start_session(
-                WorkGroup=self.credentials.spark_work_group,
-                EngineConfiguration=self.engine_config,
+        if len(session_locks) >= DEFAULT_SESSION_COUNT:
+            # Raise this exception but also poll until a session is free and assign that
+            raise Exception(
+                f"""Maximum session count: {DEFAULT_SESSION_COUNT} reached.
+                Cannot start new spark session."""
             )
-            if response["State"] != "IDLE":
-                self.poll_until_session_creation(response["SessionId"])
-            session_uuid = uuid.UUID(response["SessionId"])
-            logger.debug(f"Locking new session: {session_uuid}")
-            lock = threading.Lock()
-            session_locks[session_uuid] = lock
-            session_locks[session_uuid].acquire()
-            return session_uuid
+        response = self.athena_client.start_session(
+            WorkGroup=self.credentials.spark_work_group,
+            EngineConfiguration=self.engine_config,
+        )
+        if response["State"] != "IDLE":
+            self.poll_until_session_creation(response["SessionId"])
+        return response["SessionId"]
 
     def poll_until_session_creation(self, session_id):
         """
@@ -233,7 +233,7 @@ def release_session_lock(self, session_id) -> None:
             logger.debug(f"Releasing lock for session: {session_id}")
             session_locks[uuid.UUID(session_id)].release()
 
-    def get_session_status(self, session_id) -> str:
+    def get_session_status(self, session_id) -> dict:
         """
         Get the session status.
 
@@ -277,7 +277,7 @@ def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
         self.spark_connection = AthenaSparkSessionManager(
             credentials, timeout=self.timeout, polling_interval=self.polling_interval, engine_config=self.engine_config
         )
-        self.athena_client = self.spark_connection.athena_client
+        self.athena_client = self.spark_connection.get_athena_client()
 
     @property
     @lru_cache()
@@ -306,7 +306,7 @@ def get_current_session_status(self) -> str:
         Returns:
             str: The status of the session
         """
-        return self.athena_client.get_session_status(SessionId=self.session_id)["Status"]
+        return self.spark_connection.get_session_status(self.session_id)
 
     def poll_until_session_idle(self):
         polling_interval = self.polling_interval
@@ -315,7 +315,7 @@ def poll_until_session_idle(self):
             if session_status == "IDLE":
                 return session_status
             if session_status in ["FAILED", "TERMINATED", "DEGRADED"]:
-                return DbtRuntimeError(f"The session chosen was not available. Got status: {session_status}")
+                raise DbtRuntimeError(f"The session chosen was not available. Got status: {session_status}")
             time.sleep(polling_interval)
             polling_interval *= 2
             if polling_interval > self.timeout:
@@ -360,18 +360,18 @@ def submit(self, compiled_code: str) -> dict:
                 raise DbtRuntimeError(f"Unable to complete python execution. Got: {e}")
         try:
             execution_status = self.poll_until_execution_completion(calculation_execution_id)
+            logger.debug(f"Received execution status {execution_status}")
+            if execution_status == "COMPLETED":
+                result_s3_uri = self.athena_client.get_calculation_execution(
+                    CalculationExecutionId=calculation_execution_id
+                )["Result"]["ResultS3Uri"]
+                return result_s3_uri
+            else:
+                raise DbtRuntimeError(f"python model run ended in state {execution_status}")
         except Exception as e:
             logger.error(f"Unable to poll execution status: Got: {e}")
         finally:
             self.spark_connection.release_session_lock(self.session_id)
-        logger.debug(f"Received execution status {execution_status}")
-        if execution_status == "COMPLETED":
-            result_s3_uri = self.athena_client.get_calculation_execution(
-                CalculationExecutionId=calculation_execution_id
-            )["Result"]["ResultS3Uri"]
-            return result_s3_uri
-        else:
-            raise DbtRuntimeError(f"python model run ended in state {execution_status}")
 
     def poll_until_execution_completion(self, calculation_execution_id):
         """
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 97919ab0..67fab4c9 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -1,123 +1,141 @@
+import time
 from datetime import datetime
 from unittest.mock import Mock, patch
 
 import pytest
 import pytz
 
-from dbt.adapters.athena.python_submissions import AthenaPythonJobHelper
+from dbt.adapters.athena.python_submissions import (
+    AthenaPythonJobHelper,
+    AthenaSparkSessionConfig,
+    AthenaSparkSessionManager,
+)
 from dbt.exceptions import DbtRuntimeError
 
 from .constants import DATABASE_NAME
 
 
-@pytest.mark.usefixtures("athena_credentials", "athena_client")
-class TestPythonSubmission:
+class TestAthenaSparkSessionConfig:
     """
-    A class to test the AthenaPythonJobHelper
+    A class to test AthenaSparkSessionConfig
     """
 
-    @pytest.fixture()
-    def athena_job_helper(self, athena_credentials, athena_client, monkeypatch):
-        parsed_model = {"alias": "test_model", "schema": DATABASE_NAME, "config": {"timeout": 10}}
-        mock_job_helper = AthenaPythonJobHelper(parsed_model, athena_credentials)
-        monkeypatch.setattr(mock_job_helper, "athena_client", athena_client)
-        return mock_job_helper
+    @pytest.fixture
+    def spark_config(self, request):
+        return {
+            "timeout": request.param.get("timeout", 7200),
+            "polling_interval": request.param.get("polling_interval", 5),
+            "engine_config": request.param.get(
+                "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+            ),
+        }
+
+    @pytest.fixture
+    def spark_config_helper(self, spark_config):
+        return AthenaSparkSessionConfig(spark_config)
 
     @pytest.mark.parametrize(
-        "session_status_response, expected_response",
+        "spark_config",
         [
-            pytest.param(
-                {"Status": {"SessionId": "test_session_id", "State": "CREATING"}},
-                DbtRuntimeError(
-                    """Session <MagicMock name='client.start_session().__getitem__()' id='140219810489792'>
-                    did not create within 10 seconds."""
-                ),
-                marks=pytest.mark.xfail,
-            ),
-            (
-                {"Status": {"SessionId": "test_session_id", "State": "IDLE"}},
-                {"SessionId": "test_session_id", "State": "IDLE"},
-            ),
-            pytest.param(
-                {"Status": {"SessionId": "test_session_id", "State": "TERMINATED"}},
-                DbtRuntimeError("Unable to create session: test_session_id. Got status: TERMINATED."),
-                marks=pytest.mark.xfail,
-            ),
+            {"timeout": 5},
+            {"timeout": 10},
+            {"timeout": 20},
+            {},
+            pytest.param({"timeout": -1}, marks=pytest.mark.xfail),
+            pytest.param({"timeout": None}, marks=pytest.mark.xfail),
         ],
+        indirect=True,
     )
-    def test_start_session(self, session_status_response, expected_response, athena_job_helper, athena_client) -> None:
-        """
-        Test the start_session method of the AthenaJobHelper class.
+    def test_set_timeout(self, spark_config_helper):
+        timeout = spark_config_helper.set_timeout()
+        assert timeout == spark_config_helper.config.get("timeout", 7200)
 
-        Args:
-            session_status_response (dict): A dictionary containing the response from the Athena session
-            creation status.
-            expected_response (Union[dict, DbtRuntimeError]): The expected response from the start_session method.
-            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
-            athena_client (botocore.client.BaseClient): An instance of the botocore Athena client.
+    @pytest.mark.parametrize(
+        "spark_config",
+        [
+            {"polling_interval": 5},
+            {"polling_interval": 10},
+            {"polling_interval": 20},
+            {},
+            pytest.param({"polling_interval": -1}, marks=pytest.mark.xfail),
+        ],
+        indirect=True,
+    )
+    def test_set_polling_interval(self, spark_config_helper):
+        polling_interval = spark_config_helper.set_polling_interval()
+        assert polling_interval == spark_config_helper.config.get("polling_interval", 5)
 
-        Returns:
-            None
-        """
-        with patch.multiple(
-            athena_job_helper,
-            poll_until_session_creation=Mock(return_value=session_status_response),
-        ), patch.multiple(
-            athena_client,
-            get_session_status=Mock(return_value=session_status_response),
-            start_session=Mock(return_value=session_status_response.get("Status")),
-        ):
-            response = athena_job_helper.start_session()
-            assert response == expected_response
+    @pytest.mark.parametrize(
+        "spark_config",
+        [
+            {"engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}},
+            {"engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 2}},
+            {},
+            pytest.param({"engine_config": {"CoordinatorDpuSize": 1}}, marks=pytest.mark.xfail),
+            pytest.param({"engine_config": [1, 1, 1]}, marks=pytest.mark.xfail),
+        ],
+        indirect=True,
+    )
+    def test_set_engine_config(self, spark_config_helper):
+        engine_config = spark_config_helper.set_engine_config()
+        assert engine_config == spark_config_helper.config.get(
+            "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+        )
+
+
+@pytest.mark.usefixtures("athena_credentials", "athena_client")
+class TestAthenaSparkSessionManager:
+    """
+    A class to test the AthenaSparkSessionManager
+    """
+
+    @pytest.fixture
+    def spark_session_manager(self, athena_credentials, athena_client, monkeypatch):
+        mock_session_manager = AthenaSparkSessionManager(
+            athena_credentials,
+            timeout=10,
+            polling_interval=5,
+            engine_config={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
+        )
+        monkeypatch.setattr(mock_session_manager, "athena_client", athena_client)
+        return mock_session_manager
 
     @pytest.mark.parametrize(
         "session_status_response, expected_response",
         [
             pytest.param(
                 {
-                    "NextToken": "test_token",
                     "Sessions": [
                         {
-                            "Description": "string",
-                            "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
-                            "NotebookVersion": "string",
                             "SessionId": "string",
                             "Status": {
-                                "EndDateTime": "number",
-                                "IdleSinceDateTime": "number",
-                                "LastModifiedDateTime": "number",
                                 "StartDateTime": "number",
                                 "State": "IDLE",
-                                "StateChangeReason": "string",
                             },
                         }
                     ],
                 },
-                {
-                    "Description": "string",
-                    "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
-                    "NotebookVersion": "string",
-                    "SessionId": "string",
-                    "Status": {
-                        "EndDateTime": "number",
-                        "IdleSinceDateTime": "number",
-                        "LastModifiedDateTime": "number",
-                        "StartDateTime": "number",
-                        "State": "IDLE",
-                        "StateChangeReason": "string",
-                    },
-                },
+                [
+                    {
+                        "SessionId": "string",
+                        "Status": {
+                            "StartDateTime": "number",
+                            "State": "IDLE",
+                        },
+                    }
+                ],
             ),
             (
                 {
-                    "NextToken": "string",
                     "Sessions": [],
                 },
                 {},
             ),
         ],
     )
-    def test_list_sessions(self, session_status_response, expected_response, athena_job_helper, athena_client) -> None:
+    def test_list_sessions(
+        self, session_status_response, expected_response, spark_session_manager, athena_client
+    ) -> None:
         """
         Test the _list_sessions method of the AthenaJobHelper class.
 
@@ -134,198 +152,363 @@ def test_list_sessions(self, session_status_response, expected_response, athena_
             AssertionError: If the output of the _list_sessions method does not match the expected output.
         """
         with patch.object(athena_client, "list_sessions", return_value=session_status_response):
-            response = athena_job_helper.list_sessions()
+            response = spark_session_manager.list_sessions()
             assert response == expected_response
 
     @pytest.mark.parametrize(
-        "parsed_models, expected_timeout",
+        "session_status_response, expected_response",
         [
-            ({"alias": "test_model", "schema": DATABASE_NAME, "config": {"timeout": 10}}, 10),
             pytest.param(
-                {"alias": "test_model", "schema": "test_database", "config": {"timeout": 0}}, 0, marks=pytest.mark.xfail
+                {"Status": {"SessionId": "test_session_id", "State": "CREATING"}},
+                DbtRuntimeError(
+                    """Session <MagicMock name='client.start_session().__getitem__()' id='140219810489792'>
+                    did not create within 10 seconds."""
+                ),
+                marks=pytest.mark.xfail,
+            ),
+            (
+                {"Status": {"SessionId": "test_session_id", "State": "IDLE"}},
+                "test_session_id",
+            ),
+            pytest.param(
+                {"Status": {"SessionId": "test_session_id", "State": "TERMINATED"}},
+                DbtRuntimeError("Unable to create session: test_session_id. Got status: TERMINATED."),
+                marks=pytest.mark.xfail,
             ),
-            ({"alias": "test_model", "schema": DATABASE_NAME}, 7200),
         ],
     )
-    def test_set_timeout(self, parsed_models, expected_timeout, athena_job_helper, monkeypatch) -> None:
+    def test_start_session(
+        self, session_status_response, expected_response, spark_session_manager, athena_client
+    ) -> None:
         """
-        Test case to verify that the `_set_timeout` method of the `AthenaPythonJobHelper` class
-        returns the expected timeout value.
+        Test the start_session method of the AthenaJobHelper class.
 
         Args:
-            parsed_models (dict): A dictionary containing the parsed model configuration.
-            expected_timeout (int): The expected timeout value.
-            athena_job_helper (AthenaPythonJobHelper): An instance of the `AthenaPythonJobHelper` class.
-            monkeypatch: A pytest fixture used to mock and patch objects in the test environment.
+            session_status_response (dict): A dictionary containing the response from the Athena session
+            creation status.
+            expected_response (Union[dict, DbtRuntimeError]): The expected response from the start_session method.
+            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
+            athena_client (botocore.client.BaseClient): An instance of the botocore Athena client.
 
         Returns:
             None
         """
-        monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
-        response = athena_job_helper.set_timeout()
-        assert response == expected_timeout
+        with patch.multiple(
+            spark_session_manager,
+            poll_until_session_creation=Mock(return_value=session_status_response),
+        ), patch.multiple(
+            athena_client,
+            get_session_status=Mock(return_value=session_status_response),
+            start_session=Mock(return_value=session_status_response.get("Status")),
+        ):
+            response = spark_session_manager.start_session()
+            assert response == expected_response
 
     @pytest.mark.parametrize(
-        "parsed_models, expected_polling_interval",
+        "session_status_response, expected_status",
         [
-            ({"alias": "test_model", "schema": DATABASE_NAME, "config": {"polling_interval": 10}}, 10),
-            pytest.param(
-                {"alias": "test_model", "schema": "test_database", "config": {"polling_interval": 0}},
-                0,
-                marks=pytest.mark.xfail,
+            (
+                {
+                    "SessionId": "test_session_id",
+                    "Status": {
+                        "State": "CREATING",
+                    },
+                },
+                {
+                    "State": "CREATING",
+                },
+            ),
+            (
+                {
+                    "SessionId": "test_session_id",
+                    "Status": {
+                        "State": "IDLE",
+                    },
+                },
+                {
+                    "State": "IDLE",
+                },
             ),
-            ({"alias": "test_model", "schema": DATABASE_NAME}, 5),
         ],
     )
-    def test_set_polling_interval(
-        self, parsed_models, expected_polling_interval, athena_job_helper, monkeypatch
-    ) -> None:
-        """
-        Test method to verify that set_polling_interval() method of AthenaPythonJobHelper
-        sets the correct polling interval value based on the parsed model configuration.
+    def test_get_session_status(self, session_status_response, expected_status, spark_session_manager, athena_client):
+        with patch.multiple(athena_client, get_session_status=Mock(return_value=session_status_response)):
+            response = spark_session_manager.get_session_status("test_session_id")
+            assert response == expected_status
 
-        Args:
-            parsed_models (dict): Dictionary containing the parsed configuration model for the Athena job.
-            expected_polling_interval (int): The expected polling interval value based on the
-            parsed model configuration.
-            athena_job_helper (AthenaPythonJobHelper): The instance of AthenaPythonJobHelper to be tested.
-            monkeypatch: A pytest monkeypatch fixture used to override the parsed model configuration
-            in AthenaPythonJobHelper.
+    def test_get_sessions(self):
+        pass
 
-        Returns:
-            None
-        """
-        monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
-        response = athena_job_helper.set_polling_interval()
-        assert response == expected_polling_interval
+    def test_update_session_locks(self):
+        pass
+
+    def test_get_session_id(self):
+        pass
+
+    def test_release_session_lock(self):
+        pass
+
+
+@pytest.mark.usefixtures("athena_credentials", "athena_client")
+class TestAthenaPythonJobHelper:
+    """
+    A class to test the AthenaPythonJobHelper
+    """
+
+    @pytest.fixture
+    def parsed_model(self, request):
+        return {
+            "alias": "test_model",
+            "schema": DATABASE_NAME,
+            "config": {
+                "timeout": request.param.get("timeout", 7200),
+                "polling_interval": request.param.get("polling_interval", 5),
+                "engine_config": request.param.get(
+                    "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+                ),
+            },
+        }
+
+    @pytest.fixture
+    def athena_spark_session_manager(self, athena_credentials, parsed_model):
+        return AthenaSparkSessionManager(
+            athena_credentials,
+            timeout=parsed_model["config"]["timeout"],
+            polling_interval=parsed_model["config"]["polling_interval"],
+            engine_config=parsed_model["config"]["engine_config"],
+        )
+
+    @pytest.fixture
+    def athena_job_helper(
+        self, athena_credentials, athena_client, athena_spark_session_manager, parsed_model, monkeypatch
+    ):
+        mock_job_helper = AthenaPythonJobHelper(parsed_model, athena_credentials)
+        monkeypatch.setattr(mock_job_helper, "athena_client", athena_client)
+        monkeypatch.setattr(mock_job_helper, "spark_connection", athena_spark_session_manager)
+        return mock_job_helper
+
+    # @pytest.mark.parametrize(
+    #     "session_status_response, test_session_id, expected_response",
+    #     [
+    #         (
+    #             {
+    #                 "SessionId": "test_session_id",
+    #                 "Status": {
+    #                     "EndDateTime": "number",
+    #                     "IdleSinceDateTime": "number",
+    #                     "LastModifiedDateTime": "number",
+    #                     "StartDateTime": datetime(2023, 4, 21, 0, tzinfo=pytz.timezone("UTC")),
+    #                     "State": "IDLE",
+    #                     "StateChangeReason": "string",
+    #                 },
+    #             },
+    #             "test_session_id",
+    #             None,
+    #         ),
+    #         (
+    #             {
+    #                 "SessionId": "test_session_id_2",
+    #                 "Status": {
+    #                     "EndDateTime": "number",
+    #                     "IdleSinceDateTime": "number",
+    #                     "LastModifiedDateTime": "number",
+    #                     "StartDateTime": datetime(2023, 4, 21, 0, tzinfo=pytz.timezone("UTC")),
+    #                     "State": "TERMINATED",
+    #                     "StateChangeReason": "string",
+    #                 },
+    #             },
+    #             "test_session_id_2",
+    #             None,
+    #         ),
+    #     ],
+    # )
+    # def test_terminate_session(
+    #     self, session_status_response, test_session_id, expected_response, athena_job_helper, athena_client, monkeypatch
+    # ) -> None:
+    #     """
+    #     Test function to check if _terminate_session() method of AthenaPythonJobHelper class correctly
+    #     terminates an Athena session.
+
+    #     Args:
+    #         session_status_response: A mock response object containing the current status of the Athena session.
+    #         test_session_id: The session ID of the test Athena session.
+    #         expected_response: The expected response object after the Athena session is terminated.
+    #         athena_job_helper: An instance of the AthenaPythonJobHelper class.
+    #         athena_client: The mocked Athena client object.
+    #         monkeypatch: Pytest monkeypatch object for patching objects and values during testing.
+
+    #     Returns:
+    #         None
+    #     """
+
+    #     with patch.multiple(
+    #         athena_client,
+    #         get_session_status=Mock(return_value=session_status_response),
+    #         terminate_session=Mock(return_value=expected_response),
+    #     ), patch.multiple(
+    #         athena_job_helper,
+    #         set_session_id=Mock(return_value=test_session_id),
+    #         set_timeout=Mock(return_value=10),
+    #     ):
+    #         terminate_session_response = athena_job_helper.terminate_session()
+    #         assert terminate_session_response == expected_response
 
     @pytest.mark.parametrize(
-        "parsed_models, expected_engine_config",
+        "parsed_model, session_status_response, expected_response",
         [
             (
+                {"config": {"timeout": 5, "polling_interval": 5}},
                 {
-                    "alias": "test_model",
-                    "schema": DATABASE_NAME,
-                    "config": {
-                        "engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 44, "DefaultExecutorDpuSize": 1}
-                    },
+                    "State": "IDLE",
                 },
-                {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 44, "DefaultExecutorDpuSize": 1},
+                "IDLE",
             ),
             pytest.param(
-                {"alias": "test_model", "schema": "test_database", "config": {"engine_config": 0}},
-                0,
+                {"config": {"timeout": 5, "polling_interval": 5}},
+                {
+                    "State": "FAILED",
+                },
+                "FAILED",
                 marks=pytest.mark.xfail,
             ),
             pytest.param(
+                {"config": {"timeout": 5, "polling_interval": 5}},
                 {
-                    "alias": "test_wrong_model",
-                    "schema": "test_database",
-                    "config": {"engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2}},
+                    "State": "TERMINATED",
                 },
-                (),
+                "TERMINATED",
                 marks=pytest.mark.xfail,
             ),
-            (
-                {"alias": "test_model", "schema": DATABASE_NAME},
-                {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
+            pytest.param(
+                {"config": {"timeout": 1, "polling_interval": 5}},
+                {
+                    "State": "CREATING",
+                },
+                "CREATING",
+                marks=pytest.mark.xfail,
             ),
         ],
+        indirect=["parsed_model"],
     )
-    def test_set_engine_config(self, parsed_models, expected_engine_config, athena_job_helper, monkeypatch) -> None:
-        """
-        Test method to verify the `set_engine_config()` method of the AthenaPythonJobHelper class.
+    def test_poll_session_idle(
+        self, session_status_response, expected_response, athena_job_helper, athena_spark_session_manager, monkeypatch
+    ):
+        with patch.multiple(
+            athena_spark_session_manager,
+            get_session_status=Mock(return_value=session_status_response),
+            get_session_id=Mock(return_value="test_session_id"),
+        ):
 
-        Args:
-            parsed_models: A dictionary containing the parsed model configuration data.
-            expected_engine_config: The expected engine configuration that is set.
-            athena_job_helper: An instance of the AthenaPythonJobHelper class.
-            monkeypatch: A fixture from the pytest library that allows modifying attributes at runtime for testing.
+            def mock_sleep(_):
+                pass
 
-        Raises:
-            KeyError: If the parsed model configuration dictionary does not contain the required key.
-
-        Returns:
-            None. The method asserts that the actual engine configuration set matches the expected engine configuration.
-        """
-        monkeypatch.setattr(athena_job_helper, "parsed_model", parsed_models)
-        if parsed_models.get("alias") == "test_wrong_model":
-            with pytest.raises(KeyError):
-                athena_job_helper.set_engine_config()
-        response = athena_job_helper.set_engine_config()
-        assert response == expected_engine_config
+            monkeypatch.setattr(time, "sleep", mock_sleep)
+            poll_response = athena_job_helper.poll_until_session_idle()
+            assert poll_response == expected_response
 
     @pytest.mark.parametrize(
-        "session_status_response, test_session_id, expected_response",
+        "parsed_model, execution_status, expected_response",
         [
             (
+                {"config": {"timeout": 1, "polling_interval": 5}},
                 {
-                    "SessionId": "test_session_id",
                     "Status": {
-                        "EndDateTime": "number",
-                        "IdleSinceDateTime": "number",
-                        "LastModifiedDateTime": "number",
-                        "StartDateTime": datetime(2023, 4, 21, 0, tzinfo=pytz.timezone("UTC")),
-                        "State": "IDLE",
-                        "StateChangeReason": "string",
-                    },
+                        "State": "COMPLETED",
+                    }
                 },
-                "test_session_id",
-                None,
+                "COMPLETED",
             ),
             (
+                {"config": {"timeout": 1, "polling_interval": 5}},
                 {
-                    "SessionId": "test_session_id_2",
                     "Status": {
-                        "EndDateTime": "number",
-                        "IdleSinceDateTime": "number",
-                        "LastModifiedDateTime": "number",
-                        "StartDateTime": datetime(2023, 4, 21, 0, tzinfo=pytz.timezone("UTC")),
-                        "State": "TERMINATED",
-                        "StateChangeReason": "string",
-                    },
+                        "State": "FAILED",
+                    }
+                },
+                "FAILED",
+            ),
+            pytest.param(
+                {"config": {"timeout": 1, "polling_interval": 5}},
+                {
+                    "Status": {
+                        "State": "RUNNING",
+                    }
                 },
-                "test_session_id_2",
-                None,
+                "RUNNING",
+                marks=pytest.mark.xfail,
             ),
         ],
+        indirect=["parsed_model"],
     )
-    def test_terminate_session(
-        self, session_status_response, test_session_id, expected_response, athena_job_helper, athena_client, monkeypatch
-    ) -> None:
-        """
-        Test function to check if _terminate_session() method of AthenaPythonJobHelper class correctly
-        terminates an Athena session.
+    def test_poll_execution(
+        self,
+        execution_status,
+        expected_response,
+        athena_job_helper,
+        athena_spark_session_manager,
+        athena_client,
+        monkeypatch,
+    ):
+        with patch.multiple(
+            athena_spark_session_manager,
+            get_session_id=Mock(return_value="test_session_id"),
+        ), patch.multiple(
+            athena_client,
+            get_calculation_execution_status=Mock(return_value=execution_status),
+        ):
 
-        Args:
-            session_status_response: A mock response object containing the current status of the Athena session.
-            test_session_id: The session ID of the test Athena session.
-            expected_response: The expected response object after the Athena session is terminated.
-            athena_job_helper: An instance of the AthenaPythonJobHelper class.
-            athena_client: The mocked Athena client object.
-            monkeypatch: Pytest monkeypatch object for patching objects and values during testing.
+            def mock_sleep(_):
+                pass
 
-        Returns:
-            None
-        """
+            monkeypatch.setattr(time, "sleep", mock_sleep)
+            poll_response = athena_job_helper.poll_until_execution_completion("test_calculation_id")
+            assert poll_response == expected_response
 
+    @pytest.mark.parametrize(
+        "parsed_model, test_calculation_execution_id, test_calculation_execution, test_calculation_execution_status",
+        [
+            pytest.param(
+                {"config": {"timeout": 1, "polling_interval": 5}},
+                {"CalculationExecutionId": "test_execution_id"},
+                {"Result": {"ResultS3Uri": "test_results_s3_uri"}},
+                {"Status": {"State": "COMPLETED"}},
+            ),
+            pytest.param(
+                {"config": {"timeout": 1, "polling_interval": 5}},
+                {"CalculationExecutionId": "test_execution_id"},
+                {"Result": {"ResultS3Uri": None}},
+                {"Status": {"State": "FAILED"}},
+            ),
+            pytest.param(
+                {"config": {"timeout": 1, "polling_interval": 5}},
+                {},
+                {"Result": {"ResultS3Uri": None}},
+                {"Status": {"State": "FAILED"}},
+                marks=pytest.mark.xfail,
+            ),
+        ],
+        indirect=["parsed_model"],
+    )
+    def test_submission(
+        self,
+        test_calculation_execution_id,
+        test_calculation_execution,
+        test_calculation_execution_status,
+        athena_job_helper,
+        athena_spark_session_manager,
+        athena_client,
+    ):
         with patch.multiple(
+            athena_spark_session_manager,
+            get_session_id=Mock(return_value="test_session_id"),
+            release_session_lock=Mock(),
+        ), patch.multiple(
             athena_client,
-            get_session_status=Mock(return_value=session_status_response),
-            terminate_session=Mock(return_value=expected_response),
+            start_calculation_execution=Mock(return_value=test_calculation_execution_id),
+            get_calculation_execution=Mock(return_value=test_calculation_execution),
+            get_calculation_execution_status=Mock(return_value=test_calculation_execution_status),
         ), patch.multiple(
-            athena_job_helper,
-            set_session_id=Mock(return_value=test_session_id),
-            set_timeout=Mock(return_value=10),
+            athena_job_helper, poll_until_session_idle=Mock(return_value="IDLE")
         ):
-            terminate_session_response = athena_job_helper.terminate_session()
-            assert terminate_session_response == expected_response
-
-    def test_poll_session_creation(self):
-        pass
-
-    def test_poll_execution(self):
-        pass
-
-    def test_submission(self):
-        pass
+            result = athena_job_helper.submit("hello world")
+            assert result == test_calculation_execution["Result"]["ResultS3Uri"]

From e61c4d930659ed90d848a1e3b0fe971a20671373 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 5 May 2023 18:34:41 -0300
Subject: [PATCH 45/75] Fix flake8 tests

---
 tests/unit/test_python_submissions.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 67fab4c9..5c439808 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -1,9 +1,7 @@
 import time
-from datetime import datetime
 from unittest.mock import Mock, patch
 
 import pytest
-import pytz
 
 from dbt.adapters.athena.python_submissions import (
     AthenaPythonJobHelper,
@@ -323,7 +321,8 @@ def athena_job_helper(
     #     ],
     # )
     # def test_terminate_session(
-    #     self, session_status_response, test_session_id, expected_response, athena_job_helper, athena_client, monkeypatch
+    #     self, session_status_response, test_session_id, expected_response, athena_job_helper,
+    # athena_client, monkeypatch
     # ) -> None:
     #     """
     #     Test function to check if _terminate_session() method of AthenaPythonJobHelper class correctly

From 2dc8afd0a429c25732d91f0d0cab7bd587838580 Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Sun, 7 May 2023 11:34:30 -0300
Subject: [PATCH 46/75] Added tests for listing and updating sessions

---
 .python-version                       |  1 +
 tests/unit/test_python_submissions.py | 82 +++++++++++++++++++++++++--
 2 files changed, 79 insertions(+), 4 deletions(-)
 create mode 100644 .python-version

diff --git a/.python-version b/.python-version
new file mode 100644
index 00000000..1281604a
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.10.7
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 5c439808..12e5e7fc 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -1,8 +1,10 @@
 import time
+import uuid
 from unittest.mock import Mock, patch
 
 import pytest
 
+from dbt.adapters.athena import python_submissions
 from dbt.adapters.athena.python_submissions import (
     AthenaPythonJobHelper,
     AthenaSparkSessionConfig,
@@ -234,11 +236,83 @@ def test_get_session_status(self, session_status_response, expected_status, spar
             response = spark_session_manager.get_session_status("test_session_id")
             assert response == expected_status
 
-    def test_get_sessions(self):
-        pass
+    @pytest.mark.parametrize(
+        "list_sessions_response, session_locks",
+        [
+            (
+                [
+                    {
+                        "Description": "string",
+                        "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
+                        "NotebookVersion": "string",
+                        "SessionId": "106d7aca-4b3f-468d-a81d-308120e7f73c",
+                        "Status": {
+                            "State": "string",
+                            "StateChangeReason": "string",
+                        },
+                    },
+                    {
+                        "Description": "string",
+                        "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
+                        "NotebookVersion": "string",
+                        "SessionId": "39cb8fc0-f855-4b67-91f1-81f068499071",
+                        "Status": {
+                            "State": "string",
+                            "StateChangeReason": "string",
+                        },
+                    },
+                ],
+                {"test_session_id": None},
+            ),
+            (
+                [],
+                {},
+            ),
+            (
+                [
+                    {
+                        "Description": "string",
+                        "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
+                        "NotebookVersion": "string",
+                        "SessionId": "106d7aca-4b3f-468d-a81d-308120e7f73c",
+                        "Status": {
+                            "State": "string",
+                            "StateChangeReason": "string",
+                        },
+                    },
+                ],
+                {uuid.UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): "lock"},
+            ),
+        ],
+    )
+    def test_get_sessions(
+        self, list_sessions_response, session_locks, spark_session_manager, athena_client, monkeypatch
+    ):
+        monkeypatch.setattr(python_submissions, "session_locks", session_locks)
+        with patch.multiple(
+            spark_session_manager,
+            list_sessions=Mock(return_value=list_sessions_response),
+        ):
+            sessions = spark_session_manager.get_sessions()
+            assert sessions == [uuid.UUID(response["SessionId"]) for response in list_sessions_response]
 
-    def test_update_session_locks(self):
-        pass
+    @pytest.mark.parametrize(
+        "get_session_response, current_session_locks",
+        [([], {}), ([uuid.UUID("106d7aca-4b3f-468d-a81d-308120e7f73c")], {})],
+    )
+    def test_update_session_locks(
+        self, get_session_response, current_session_locks, spark_session_manager, monkeypatch
+    ):
+        print(get_session_response)
+        monkeypatch.setattr(python_submissions, "session_locks", current_session_locks)
+        with patch.multiple(
+            spark_session_manager,
+            get_sessions=Mock(return_value=get_session_response),
+        ):
+            spark_session_manager.update_session_locks()
+            for session in get_session_response:
+                assert session in python_submissions.session_locks.keys()
+                assert type(python_submissions.session_locks[session]) is not None
 
     def test_get_session_id(self):
         pass

From f281a0622d6ebe311becc29fba7a525d188c7e5b Mon Sep 17 00:00:00 2001
From: Avinash-1394 <43074786+Avinash-1394@users.noreply.github.com>
Date: Mon, 8 May 2023 20:26:34 -0300
Subject: [PATCH 47/75] Added docs to tests

---
 dbt/adapters/athena/python_submissions.py |  13 ++
 tests/unit/test_python_submissions.py     | 228 ++++++++++++++--------
 2 files changed, 159 insertions(+), 82 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 93e67d8a..a1645457 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -108,6 +108,19 @@ def get_sessions(self) -> List[uuid.UUID]:
         return [uuid.UUID(session) for session in new_sessions]
 
     def update_session_locks(self) -> None:
+        """
+        Update session locks for each session.
+
+        This function iterates over the existing sessions and ensures that a session lock is created for each session.
+        If a session lock already exists, it is left unchanged. After updating the session locks,
+        a debug log is generated to display the updated session locks.
+
+        Args:
+            self: The instance of the class.
+
+        Returns:
+            None
+        """
         for session_uuid in self.get_sessions():
             session_locks.setdefault(session_uuid, threading.Lock())
         logger.debug(f"Updated session locks: {session_locks}")
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 12e5e7fc..37675c8e 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -22,6 +22,23 @@ class TestAthenaSparkSessionConfig:
 
     @pytest.fixture
     def spark_config(self, request):
+        """
+        Fixture for providing Spark configuration parameters.
+
+        This fixture returns a dictionary containing the Spark configuration parameters. The parameters can be
+        customized using the `request.param` object. The default values are:
+        - `timeout`: 7200 seconds
+        - `polling_interval`: 5 seconds
+        - `engine_config`: {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+
+        Args:
+            self: The test class instance.
+            request: The pytest request object.
+
+        Returns:
+            dict: The Spark configuration parameters.
+
+        """
         return {
             "timeout": request.param.get("timeout", 7200),
             "polling_interval": request.param.get("polling_interval", 5),
@@ -32,6 +49,14 @@ def spark_config(self, request):
 
     @pytest.fixture
     def spark_config_helper(self, spark_config):
+        """Fixture for testing AthenaSparkSessionConfig class.
+
+        Args:
+            spark_config (dict): Fixture for default spark config.
+
+        Returns:
+            AthenaSparkSessionConfig: An instance of AthenaSparkSessionConfig class.
+        """
         return AthenaSparkSessionConfig(spark_config)
 
     @pytest.mark.parametrize(
@@ -91,6 +116,23 @@ class TestAthenaSparkSessionManager:
 
     @pytest.fixture
     def spark_session_manager(self, athena_credentials, athena_client, monkeypatch):
+        """
+        Fixture for creating a mock Spark session manager.
+
+        This fixture creates an instance of AthenaSparkSessionManager with the provided Athena credentials,
+        timeout, polling interval, and engine configuration. It then patches the Athena client of the manager
+        with the provided `athena_client` object. The fixture returns the mock Spark session manager.
+
+        Args:
+            self: The test class instance.
+            athena_credentials: The Athena credentials.
+            athena_client: The Athena client object.
+            monkeypatch: The monkeypatch object for mocking.
+
+        Returns:
+            The mock Spark session manager.
+
+        """
         mock_session_manager = AthenaSparkSessionManager(
             athena_credentials,
             timeout=10,
@@ -232,6 +274,22 @@ def test_start_session(
         ],
     )
     def test_get_session_status(self, session_status_response, expected_status, spark_session_manager, athena_client):
+        """
+        Test the get_session_status function.
+
+        Args:
+            self: The test class instance.
+            session_status_response (dict): The response from get_session_status.
+            expected_status (dict): The expected session status.
+            spark_session_manager: The Spark session manager object.
+            athena_client: The Athena client object.
+
+        Returns:
+            None
+
+        Raises:
+            AssertionError: If the retrieved session status is not correct.
+        """
         with patch.multiple(athena_client, get_session_status=Mock(return_value=session_status_response)):
             response = spark_session_manager.get_session_status("test_session_id")
             assert response == expected_status
@@ -242,23 +300,15 @@ def test_get_session_status(self, session_status_response, expected_status, spar
             (
                 [
                     {
-                        "Description": "string",
-                        "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
-                        "NotebookVersion": "string",
                         "SessionId": "106d7aca-4b3f-468d-a81d-308120e7f73c",
                         "Status": {
                             "State": "string",
-                            "StateChangeReason": "string",
                         },
                     },
                     {
-                        "Description": "string",
-                        "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
-                        "NotebookVersion": "string",
                         "SessionId": "39cb8fc0-f855-4b67-91f1-81f068499071",
                         "Status": {
                             "State": "string",
-                            "StateChangeReason": "string",
                         },
                     },
                 ],
@@ -271,13 +321,9 @@ def test_get_session_status(self, session_status_response, expected_status, spar
             (
                 [
                     {
-                        "Description": "string",
-                        "EngineVersion": {"EffectiveEngineVersion": "string", "SelectedEngineVersion": "string"},
-                        "NotebookVersion": "string",
                         "SessionId": "106d7aca-4b3f-468d-a81d-308120e7f73c",
                         "Status": {
                             "State": "string",
-                            "StateChangeReason": "string",
                         },
                     },
                 ],
@@ -288,6 +334,23 @@ def test_get_session_status(self, session_status_response, expected_status, spar
     def test_get_sessions(
         self, list_sessions_response, session_locks, spark_session_manager, athena_client, monkeypatch
     ):
+        """
+        Test the get_sessions function.
+
+        Args:
+            self: The test class instance.
+            list_sessions_response (list): The response from list_sessions.
+            session_locks (dict): The session locks.
+            spark_session_manager: The Spark session manager object.
+            athena_client: The Athena client object.
+            monkeypatch: The monkeypatch object for mocking.
+
+        Returns:
+            None
+
+        Raises:
+            AssertionError: If the retrieved sessions are not correct.
+        """
         monkeypatch.setattr(python_submissions, "session_locks", session_locks)
         with patch.multiple(
             spark_session_manager,
@@ -303,7 +366,19 @@ def test_get_sessions(
     def test_update_session_locks(
         self, get_session_response, current_session_locks, spark_session_manager, monkeypatch
     ):
-        print(get_session_response)
+        """
+        Test the update_session_locks function.
+
+        Args:
+            self: The test class instance.
+            get_session_response (list): The response from get_sessions.
+            current_session_locks (dict): The current session locks.
+            spark_session_manager: The Spark session manager object.
+            monkeypatch: The monkeypatch object for mocking.
+
+        Raises:
+            AssertionError: If the session locks are not updated correctly.
+        """
         monkeypatch.setattr(python_submissions, "session_locks", current_session_locks)
         with patch.multiple(
             spark_session_manager,
@@ -317,8 +392,64 @@ def test_update_session_locks(
     def test_get_session_id(self):
         pass
 
-    def test_release_session_lock(self):
-        pass
+    @pytest.mark.parametrize(
+        "test_session_id, get_session_status_response, current_session_locks, terminate_session_response",
+        [
+            (
+                "106d7aca-4b3f-468d-a81d-308120e7f73c",
+                {
+                    "State": "string",
+                },
+                {uuid.UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): Mock()},
+                {"State": "TERMINATED"},
+            ),
+            (
+                "106d7aca-4b3f-468d-a81d-308120e7f73c",
+                {
+                    "State": "string",
+                },
+                {uuid.UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): Mock()},
+                {"State": "CREATED"},
+            ),
+        ],
+    )
+    def test_release_session_lock(
+        self,
+        test_session_id,
+        get_session_status_response,
+        current_session_locks,
+        terminate_session_response,
+        spark_session_manager,
+        athena_client,
+        monkeypatch,
+    ):
+        """
+        Test the release_session_lock function.
+
+        Args:
+            self: The test class instance.
+            test_session_id (str): The ID of the test session.
+            get_session_status_response (dict): The response from get_session_status.
+            current_session_locks (dict): The current session locks.
+            terminate_session_response (dict): The response from terminate_session.
+            spark_session_manager: The Spark session manager object.
+            athena_client: The Athena client object.
+            monkeypatch: The monkeypatch object for mocking.
+
+        Raises:
+            AssertionError: If the session lock is not released correctly.
+        """
+        monkeypatch.setattr(python_submissions, "session_locks", current_session_locks)
+        with patch.multiple(
+            spark_session_manager,
+            get_session_status=Mock(return_value=get_session_status_response),
+        ), patch.multiple(
+            athena_client,
+            terminate_session=Mock(return_value=terminate_session_response),
+        ):
+            spark_session_manager.release_session_lock(test_session_id)
+            assert uuid.UUID(test_session_id) in python_submissions.session_locks.keys()
+            assert type(python_submissions.session_locks[uuid.UUID(test_session_id)]) is not None
 
 
 @pytest.mark.usefixtures("athena_credentials", "athena_client")
@@ -359,73 +490,6 @@ def athena_job_helper(
         monkeypatch.setattr(mock_job_helper, "spark_connection", athena_spark_session_manager)
         return mock_job_helper
 
-    # @pytest.mark.parametrize(
-    #     "session_status_response, test_session_id, expected_response",
-    #     [
-    #         (
-    #             {
-    #                 "SessionId": "test_session_id",
-    #                 "Status": {
-    #                     "EndDateTime": "number",
-    #                     "IdleSinceDateTime": "number",
-    #                     "LastModifiedDateTime": "number",
-    #                     "StartDateTime": datetime(2023, 4, 21, 0, tzinfo=pytz.timezone("UTC")),
-    #                     "State": "IDLE",
-    #                     "StateChangeReason": "string",
-    #                 },
-    #             },
-    #             "test_session_id",
-    #             None,
-    #         ),
-    #         (
-    #             {
-    #                 "SessionId": "test_session_id_2",
-    #                 "Status": {
-    #                     "EndDateTime": "number",
-    #                     "IdleSinceDateTime": "number",
-    #                     "LastModifiedDateTime": "number",
-    #                     "StartDateTime": datetime(2023, 4, 21, 0, tzinfo=pytz.timezone("UTC")),
-    #                     "State": "TERMINATED",
-    #                     "StateChangeReason": "string",
-    #                 },
-    #             },
-    #             "test_session_id_2",
-    #             None,
-    #         ),
-    #     ],
-    # )
-    # def test_terminate_session(
-    #     self, session_status_response, test_session_id, expected_response, athena_job_helper,
-    # athena_client, monkeypatch
-    # ) -> None:
-    #     """
-    #     Test function to check if _terminate_session() method of AthenaPythonJobHelper class correctly
-    #     terminates an Athena session.
-
-    #     Args:
-    #         session_status_response: A mock response object containing the current status of the Athena session.
-    #         test_session_id: The session ID of the test Athena session.
-    #         expected_response: The expected response object after the Athena session is terminated.
-    #         athena_job_helper: An instance of the AthenaPythonJobHelper class.
-    #         athena_client: The mocked Athena client object.
-    #         monkeypatch: Pytest monkeypatch object for patching objects and values during testing.
-
-    #     Returns:
-    #         None
-    #     """
-
-    #     with patch.multiple(
-    #         athena_client,
-    #         get_session_status=Mock(return_value=session_status_response),
-    #         terminate_session=Mock(return_value=expected_response),
-    #     ), patch.multiple(
-    #         athena_job_helper,
-    #         set_session_id=Mock(return_value=test_session_id),
-    #         set_timeout=Mock(return_value=10),
-    #     ):
-    #         terminate_session_response = athena_job_helper.terminate_session()
-    #         assert terminate_session_response == expected_response
-
     @pytest.mark.parametrize(
         "parsed_model, session_status_response, expected_response",
         [

From 0038628b652d25095ea63b0bb2df5e7e0f34cdc1 Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Sun, 28 May 2023 16:29:12 -0300
Subject: [PATCH 48/75] Split the class objects into separate modules. Handled
 threading deadlocks.

---
 dbt/adapters/athena/config.py                 |  59 +++
 dbt/adapters/athena/constants.py              |   2 +-
 dbt/adapters/athena/impl.py                   |   2 +-
 dbt/adapters/athena/python_submissions.py     | 313 ++----------
 dbt/adapters/athena/session.py                | 204 ++++++++
 .../macros/adapters/python_submissions.sql    |   2 +-
 tests/unit/test_config.py                     |  96 +++-
 tests/unit/test_python_submissions.py         | 467 +-----------------
 tests/unit/test_session.py                    | 341 ++++++++++++-
 9 files changed, 750 insertions(+), 736 deletions(-)

diff --git a/dbt/adapters/athena/config.py b/dbt/adapters/athena/config.py
index 5e426f1c..8e5aff39 100644
--- a/dbt/adapters/athena/config.py
+++ b/dbt/adapters/athena/config.py
@@ -3,9 +3,68 @@
 import pkg_resources
 from botocore import config
 
+from dbt.adapters.athena.constants import LOGGER
+
+DEFAULT_POLLING_INTERVAL = 5
+DEFAULT_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+DEFAULT_TIMEOUT = 60 * 60 * 2
+
 
 @lru_cache()
 def get_boto3_config() -> config.Config:
     return config.Config(
         user_agent_extra="dbt-athena-community/" + pkg_resources.get_distribution("dbt-athena-community").version
     )
+
+
+class AthenaSparkSessionConfig:
+    """
+    A helper class to manage Athena Spark Session Configuration.
+    """
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+
+    def set_timeout(self) -> int:
+        """
+        Get the timeout value.
+
+        This function retrieves the timeout value from the parsed model's configuration. If the timeout value
+        is not defined, it falls back to the default timeout value. If the retrieved timeout value is less than or
+        equal to 0, a ValueError is raised as timeout must be a positive integer.
+
+        Returns:
+            int: The timeout value in seconds.
+
+        Raises:
+            ValueError: If the timeout value is not a positive integer.
+
+        """
+        timeout = self.config.get("timeout", DEFAULT_TIMEOUT)
+        if not isinstance(timeout, int):
+            raise TypeError("Timeout must be an integer")
+        if timeout <= 0:
+            raise ValueError("Timeout must be a positive integer")
+        LOGGER.debug(f"Setting timeout: {timeout}")
+        return timeout
+
+    def set_polling_interval(self) -> float:
+        polling_interval = self.config.get("polling_interval", DEFAULT_POLLING_INTERVAL)
+        if not isinstance(polling_interval, int) or polling_interval <= 0:
+            raise ValueError("Polling_interval must be a positive integer")
+        LOGGER.debug(f"Setting polling_interval: {polling_interval}")
+        return polling_interval
+
+    def set_engine_config(self) -> dict:
+        engine_config = self.config.get("engine_config", DEFAULT_ENGINE_CONFIG)
+        if not isinstance(engine_config, dict):
+            raise TypeError("Engine configuration has to be of type dict")
+
+        expected_keys = {"CoordinatorDpuSize", "MaxConcurrentDpus", "DefaultExecutorDpuSize"}
+        if set(engine_config.keys()) != expected_keys:
+            raise KeyError(f"The keys of the dictionary entered do not match the expected format: {expected_keys}")
+
+        if engine_config["MaxConcurrentDpus"] == 1:
+            raise KeyError("The lowest value supported for MaxConcurrentDpus is 2")
+        LOGGER.debug(f"Setting engine configuration: {engine_config}")
+        return engine_config
diff --git a/dbt/adapters/athena/constants.py b/dbt/adapters/athena/constants.py
index bfedb302..bfd6e4b0 100644
--- a/dbt/adapters/athena/constants.py
+++ b/dbt/adapters/athena/constants.py
@@ -1,3 +1,3 @@
 from dbt.events import AdapterLogger
 
-LOGGER = AdapterLogger("Athena")
+LOGGER = AdapterLogger(__name__)
diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index b21c390e..48f982b1 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -630,7 +630,7 @@ def persist_docs_to_glue(
         glue_client.update_table(DatabaseName=relation.schema, TableInput=updated_table)
 
     def generate_python_submission_response(self, submission_result: Any) -> AdapterResponse:
-        if submission_result is None:
+        if not submission_result:
             return AdapterResponse(_message="ERROR")
         return AdapterResponse(_message="OK")
 
diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index a1645457..e4dc2b2e 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -1,259 +1,17 @@
-import threading
 import time
-import uuid
-from datetime import datetime, timedelta, timezone
 from functools import lru_cache
-from typing import Dict, List
+from typing import Any, Dict
 
-import boto3
 import botocore
 
+from dbt.adapters.athena.config import AthenaSparkSessionConfig
 from dbt.adapters.athena.connections import AthenaCredentials
+from dbt.adapters.athena.constants import LOGGER
+from dbt.adapters.athena.session import AthenaSparkSessionManager
 from dbt.adapters.base import PythonJobHelper
-from dbt.events import AdapterLogger
 from dbt.exceptions import DbtRuntimeError
 
-DEFAULT_POLLING_INTERVAL = 5
-DEFAULT_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
 SUBMISSION_LANGUAGE = "python"
-DEFAULT_TIMEOUT = 60 * 60 * 2
-DEFAULT_SESSION_COUNT = 16
-
-logger = AdapterLogger("Athena")
-session_locks = {}
-
-
-class AthenaSparkSessionConfig:
-    """
-    A helper class to manage Athena Spark Session Configuration.
-    """
-
-    def __init__(self, config: dict):
-        self.config = config
-
-    def set_timeout(self) -> int:
-        """
-        Get the timeout value.
-
-        This function retrieves the timeout value from the parsed model's configuration. If the timeout value
-        is not defined, it falls back to the default timeout value. If the retrieved timeout value is less than or
-        equal to 0, a ValueError is raised as timeout must be a positive integer.
-
-        Returns:
-            int: The timeout value in seconds.
-
-        Raises:
-            ValueError: If the timeout value is not a positive integer.
-
-        """
-        timeout = self.config.get("timeout", DEFAULT_TIMEOUT)
-        if not isinstance(timeout, int):
-            raise TypeError("Timeout must be an integer")
-        if timeout <= 0:
-            raise ValueError("Timeout must be a positive integer")
-        logger.debug(f"Setting timeout: {timeout}")
-        return timeout
-
-    def set_polling_interval(self) -> int:
-        polling_interval = self.config.get("polling_interval", DEFAULT_POLLING_INTERVAL)
-        if not isinstance(polling_interval, int) or polling_interval <= 0:
-            raise ValueError("polling_interval must be a positive integer")
-        logger.debug(f"Setting polling_interval: {polling_interval}")
-        return polling_interval
-
-    def set_engine_config(self) -> dict:
-        engine_config = self.config.get("engine_config", DEFAULT_ENGINE_CONFIG)
-        if not isinstance(engine_config, dict):
-            raise TypeError("engine configuration has to be of type dict")
-
-        expected_keys = {"CoordinatorDpuSize", "MaxConcurrentDpus", "DefaultExecutorDpuSize"}
-        if set(engine_config.keys()) != expected_keys:
-            raise KeyError(f"The keys of the dictionary entered do not match the expected format: {expected_keys}")
-        return engine_config
-
-
-class AthenaSparkSessionManager:
-    """
-    A helper class to manage Athena Spark Sessions.
-    """
-
-    def __init__(self, credentials: str, **kwargs):
-        self.credentials = credentials
-        self.timeout = kwargs.get("timeout")
-        self.polling_interval = kwargs.get("polling_interval")
-        self.engine_config = kwargs.get("engine_config")
-        self.lock = threading.Lock()
-        self.athena_client = self.get_athena_client()
-
-    def get_athena_client(self):
-        """
-        Get the AWS Athena client.
-
-        This function returns an AWS Athena client object that can be used to interact with the Athena service.
-        The client is created using the region name and profile name provided during object instantiation.
-
-        Returns:
-            Any: The Athena client object.
-
-        """
-        return boto3.session.Session(
-            region_name=self.credentials.region_name, profile_name=self.credentials.aws_profile_name
-        ).client("athena")
-
-    def get_sessions(self) -> List[uuid.UUID]:
-        sessions = self.list_sessions()
-        existing_sessions = set(session_locks.keys())
-        new_sessions = [session["SessionId"] for session in sessions if session["SessionId"] not in existing_sessions]
-        logger.debug(f"Setting sessions: {new_sessions}")
-        return [uuid.UUID(session) for session in new_sessions]
-
-    def update_session_locks(self) -> None:
-        """
-        Update session locks for each session.
-
-        This function iterates over the existing sessions and ensures that a session lock is created for each session.
-        If a session lock already exists, it is left unchanged. After updating the session locks,
-        a debug log is generated to display the updated session locks.
-
-        Args:
-            self: The instance of the class.
-
-        Returns:
-            None
-        """
-        for session_uuid in self.get_sessions():
-            session_locks.setdefault(session_uuid, threading.Lock())
-        logger.debug(f"Updated session locks: {session_locks}")
-
-    def get_session_id(self) -> str:
-        """
-        Get the session ID.
-
-        This function retrieves the session ID from the stored session information. If session information
-        is not available, a new session is started and its session ID is returned.
-
-        Returns:
-            str: The session ID.
-
-        """
-        self.update_session_locks()
-        with self.lock:
-            for session_uuid, lock in session_locks.items():
-                if not lock.locked():
-                    logger.debug(f"Locking existing session: {session_uuid}")
-                    lock.acquire()
-                    return session_uuid
-        logger.debug("All sessions are currently locked. Starting new session.")
-        session_uuid = uuid.UUID(self.start_session())
-        with self.lock:
-            logger.debug(f"Locking new session: {session_uuid}")
-            session_locks[session_uuid] = threading.Lock()
-            session_locks[session_uuid].acquire()
-            return session_uuid
-
-    def list_sessions(self, max_results: int = DEFAULT_SESSION_COUNT, state: str = "IDLE") -> dict:
-        """
-        List athena spark sessions.
-
-        This function sends a request to the Athena service to list the sessions in the specified Spark workgroup.
-        It filters the sessions by state, only returning the first session that is in IDLE state. If no idle sessions
-        are found or if an error occurs, None is returned.
-
-        Returns:
-            dict: The session information dictionary if an idle session is found, None otherwise.
-
-        """
-        response = self.athena_client.list_sessions(
-            WorkGroup=self.credentials.spark_work_group, MaxResults=max_results, StateFilter=state
-        )
-        if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
-            return {}
-        return response.get("Sessions")
-
-    def start_session(self) -> dict:
-        """
-        Start an Athena session.
-
-        This function sends a request to the Athena service to start a session in the specified Spark workgroup.
-        It configures the session with specific engine configurations. If the session state is not IDLE, the function
-        polls until the session creation is complete. The response containing session information is returned.
-
-        Returns:
-            dict: The session information dictionary.
-
-        """
-        if len(session_locks) >= DEFAULT_SESSION_COUNT:
-            # Raise this exception but also poll until a session is free and assign that
-            raise Exception(
-                f"""Maximum session count: {DEFAULT_SESSION_COUNT} reached.
-                Cannot start new spark session."""
-            )
-        response = self.athena_client.start_session(
-            WorkGroup=self.credentials.spark_work_group,
-            EngineConfiguration=self.engine_config,
-        )
-        if response["State"] != "IDLE":
-            self.poll_until_session_creation(response["SessionId"])
-        return response["SessionId"]
-
-    def poll_until_session_creation(self, session_id):
-        """
-        Polls the status of an Athena session creation until it is completed or reaches the timeout.
-
-        Args:
-            session_id (str): The ID of the session being created.
-
-        Returns:
-            str: The final status of the session, which will be "IDLE" if the session creation is successful.
-
-        Raises:
-            DbtRuntimeError: If the session creation fails, is terminated, or degrades during polling.
-            DbtRuntimeError: If the session does not become IDLE within the specified timeout.
-
-        """
-        polling_interval = self.polling_interval
-        while True:
-            creation_status = self.get_session_status(session_id)["State"]
-            if creation_status in ["FAILED", "TERMINATED", "DEGRADED"]:
-                raise DbtRuntimeError(f"Unable to create session: {session_id}. Got status: {creation_status}.")
-            elif creation_status == "IDLE":
-                return creation_status
-            time.sleep(polling_interval)
-            polling_interval *= 2
-            if polling_interval > self.timeout:
-                raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
-
-    def release_session_lock(self, session_id) -> None:
-        """
-        Terminate the current Athena session.
-
-        This function terminates the current Athena session if it is in IDLE or BUSY state and has exceeded the
-        configured timeout period. It retrieves the session status, and if the session state is IDLE or BUSY and the
-        duration since the session start time exceeds the timeout period, the session is terminated. The session ID is
-        used to terminate the session via the Athena client.
-
-        Returns:
-            dict: The response from the Athena client after terminating the session.
-
-        """
-        session_status = self.get_session_status(session_id)
-        if session_status["State"] in ["IDLE", "BUSY"] and (
-            session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
-        ):
-            logger.debug(f"Terminating session: {session_id}")
-            self.athena_client.terminate_session(SessionId=session_id)
-        with self.lock:
-            logger.debug(f"Releasing lock for session: {session_id}")
-            session_locks[uuid.UUID(session_id)].release()
-
-    def get_session_status(self, session_id) -> dict:
-        """
-        Get the session status.
-
-        Returns:
-            str: The status of the session
-        """
-        return self.athena_client.get_session_status(SessionId=session_id)["Status"]
 
 
 class AthenaPythonJobHelper(PythonJobHelper):
@@ -288,31 +46,31 @@ class AthenaPythonJobHelper(PythonJobHelper):
     def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
         self.config = AthenaSparkSessionConfig(parsed_model.get("config", {}))
         self.spark_connection = AthenaSparkSessionManager(
-            credentials, timeout=self.timeout, polling_interval=self.polling_interval, engine_config=self.engine_config
+            credentials, self.timeout, self.polling_interval, self.engine_config
         )
         self.athena_client = self.spark_connection.get_athena_client()
 
     @property
-    @lru_cache()
-    def timeout(self):
+    @lru_cache(maxsize=1)
+    def timeout(self) -> int:
         return self.config.set_timeout()
 
     @property
-    @lru_cache()
+    @lru_cache(maxsize=1)
     def session_id(self) -> str:
         return str(self.spark_connection.get_session_id())
 
     @property
-    @lru_cache()
-    def polling_interval(self):
+    @lru_cache(maxsize=1)
+    def polling_interval(self) -> float:
         return self.config.set_polling_interval()
 
     @property
-    @lru_cache()
-    def engine_config(self):
+    @lru_cache(maxsize=1)
+    def engine_config(self) -> Dict[str, int]:
         return self.config.set_engine_config()
 
-    def get_current_session_status(self) -> str:
+    def get_current_session_status(self) -> Dict[str, Any]:
         """
         Get the current session status.
 
@@ -321,14 +79,14 @@ def get_current_session_status(self) -> str:
         """
         return self.spark_connection.get_session_status(self.session_id)
 
-    def poll_until_session_idle(self):
+    def poll_until_session_idle(self) -> None:
         polling_interval = self.polling_interval
         while True:
             session_status = self.get_current_session_status()["State"]
-            if session_status == "IDLE":
-                return session_status
             if session_status in ["FAILED", "TERMINATED", "DEGRADED"]:
                 raise DbtRuntimeError(f"The session chosen was not available. Got status: {session_status}")
+            if session_status == "IDLE":
+                break
             time.sleep(polling_interval)
             polling_interval *= 2
             if polling_interval > self.timeout:
@@ -361,32 +119,30 @@ def submit(self, compiled_code: str) -> dict:
                 )["CalculationExecutionId"]
                 break
             except botocore.exceptions.ClientError as ce:
-                logger.exception(f"Encountered client error: {ce}")
+                LOGGER.exception(f"Encountered client error: {ce}")
                 if (
                     ce.response["Error"]["Code"] == "InvalidRequestException"
                     and "Session is in the BUSY state; needs to be IDLE to accept Calculations."
                     in ce.response["Error"]["Message"]
                 ):
-                    logger.exception("Going to poll until session is IDLE")
+                    LOGGER.exception("Going to poll until session is IDLE")
                     self.poll_until_session_idle()
             except Exception as e:
                 raise DbtRuntimeError(f"Unable to complete python execution. Got: {e}")
-        try:
-            execution_status = self.poll_until_execution_completion(calculation_execution_id)
-            logger.debug(f"Received execution status {execution_status}")
-            if execution_status == "COMPLETED":
-                result_s3_uri = self.athena_client.get_calculation_execution(
-                    CalculationExecutionId=calculation_execution_id
-                )["Result"]["ResultS3Uri"]
-                return result_s3_uri
-            else:
-                raise DbtRuntimeError(f"python model run ended in state {execution_status}")
-        except Exception as e:
-            logger.error(f"Unable to poll execution status: Got: {e}")
-        finally:
-            self.spark_connection.release_session_lock(self.session_id)
+        execution_status = self.poll_until_execution_completion(calculation_execution_id)
+        LOGGER.debug(f"Received execution status {execution_status}")
+        if execution_status == "COMPLETED":
+            try:
+                result = self.athena_client.get_calculation_execution(CalculationExecutionId=calculation_execution_id)[
+                    "Result"
+                ]
+            except Exception as e:
+                LOGGER.error(f"Unable to poll execution status: Got: {e}")
+                result = {}
+        self.spark_connection.release_session_lock(self.session_id)
+        return result
 
-    def poll_until_execution_completion(self, calculation_execution_id):
+    def poll_until_execution_completion(self, calculation_execution_id) -> str:
         """
         Poll the status of a calculation execution until it is completed, failed, or cancelled.
 
@@ -412,7 +168,12 @@ def poll_until_execution_completion(self, calculation_execution_id):
             execution_status = self.athena_client.get_calculation_execution_status(
                 CalculationExecutionId=calculation_execution_id
             )["Status"]["State"]
-            if execution_status in ["COMPLETED", "FAILED", "CANCELLED"]:
+            if execution_status in ["FAILED", "CANCELLED"]:
+                raise DbtRuntimeError(
+                    f"""Execution {calculation_execution_id} did not complete successfully.
+                    Got: {execution_status} status."""
+                )
+            if execution_status == "COMPLETED":
                 return execution_status
             time.sleep(polling_interval)
             polling_interval *= 2
diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index 60c86fba..138e0d61 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -1,6 +1,18 @@
+import threading
+import time
+from datetime import datetime, timedelta, timezone
+from typing import Any, Dict, List
+from uuid import UUID
+
+import boto3
 import boto3.session
 
+from dbt.adapters.athena.constants import LOGGER
 from dbt.contracts.connection import Connection
+from dbt.exceptions import DbtRuntimeError
+
+DEFAULT_SESSION_COUNT = 4
+spark_session_locks: Dict[UUID, threading.Lock] = {}
 
 
 def get_boto3_session(connection: Connection) -> boto3.session.Session:
@@ -10,3 +22,195 @@ def get_boto3_session(connection: Connection) -> boto3.session.Session:
         region_name=connection.credentials.region_name,
         profile_name=connection.credentials.aws_profile_name,
     )
+
+
+class AthenaSparkSessionManager:
+    """
+    A helper class to manage Athena Spark Sessions.
+    """
+
+    def __init__(self, credentials, timeout: int, polling_interval: float, engine_config: Dict[str, int]):
+        self.credentials = credentials
+        self.timeout = timeout
+        self.polling_interval = polling_interval
+        self.engine_config = engine_config
+        self.lock = threading.Lock()
+        self.athena_client = self.get_athena_client()
+
+    def get_athena_client(self):
+        """
+        Get the AWS Athena client.
+
+        This function returns an AWS Athena client object that can be used to interact with the Athena service.
+        The client is created using the region name and profile name provided during object instantiation.
+
+        Returns:
+            Any: The Athena client object.
+
+        """
+        return boto3.session.Session(
+            region_name=self.credentials.region_name, profile_name=self.credentials.aws_profile_name
+        ).client("athena")
+
+    def get_new_sessions(self) -> List[UUID]:
+        """
+        Retrieves a list of new sessions by subtracting the existing sessions from the complete session list.
+
+        Returns:
+            List[UUID]: A list of new session UUIDs.
+
+        """
+        sessions = self.list_sessions()
+        existing_sessions = set(spark_session_locks.keys())
+        new_sessions = [session for session in sessions if session not in existing_sessions]
+        LOGGER.debug(f"Setting sessions: {new_sessions}")
+        return new_sessions
+
+    def update_spark_session_locks(self) -> None:
+        """
+        Update session locks for each session.
+
+        This function iterates over the existing sessions and ensures that a session lock is created for each session.
+        If a session lock already exists, it is left unchanged. After updating the session locks,
+        a debug log is generated to display the updated session locks.
+
+        Args:
+            self: The instance of the class.
+
+        Returns:
+            None
+        """
+        for session_uuid in self.get_new_sessions():
+            spark_session_locks.setdefault(session_uuid, threading.Lock())
+        LOGGER.debug(f"Updated session locks: {spark_session_locks}")
+
+    def get_session_id(self) -> UUID:
+        """
+        Get the session ID.
+
+        This function retrieves the session ID from the stored session information. If session information
+        is not available, a new session is started and its session ID is returned.
+
+        Returns:
+            str: The session ID.
+
+        """
+        polling_interval = self.polling_interval
+        self.update_spark_session_locks()
+        while True:
+            for session_uuid, lock in spark_session_locks.items():
+                if not lock.locked():
+                    LOGGER.debug(f"Locking existing session: {session_uuid}")
+                    lock.acquire(blocking=False)
+                    return session_uuid
+            LOGGER.debug(
+                f"""All available spark sessions: {spark_session_locks.keys()} are locked.
+                Going to sleep: {polling_interval} seconds."""
+            )
+            time.sleep(polling_interval)
+            polling_interval *= 2
+
+    def list_sessions(self, max_results: int = DEFAULT_SESSION_COUNT, state: str = "IDLE") -> List[UUID]:
+        """
+        List athena spark sessions.
+
+        This function sends a request to the Athena service to list the sessions in the specified Spark workgroup.
+        It filters the sessions by state, only returning the first session that is in IDLE state. If no idle sessions
+        are found or if an error occurs, None is returned.
+
+        Returns:
+            List[UUID]: A list of session UUIDs if an idle sessions are found, else start a new session and return
+            the list of the returned session id.
+
+        """
+        response = self.athena_client.list_sessions(
+            WorkGroup=self.credentials.spark_work_group, MaxResults=max_results, StateFilter=state
+        )
+        if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
+            if len(spark_session_locks) < DEFAULT_SESSION_COUNT:
+                return [self.start_session()]
+            LOGGER.warning(
+                f"""Maximum spark session count: {DEFAULT_SESSION_COUNT} reached.
+            Cannot start new spark session."""
+            )
+        return [UUID(session_string["SessionId"]) for session_string in response.get("Sessions")]
+
+    def start_session(self) -> UUID:
+        """
+        Start an Athena session.
+
+        This function sends a request to the Athena service to start a session in the specified Spark workgroup.
+        It configures the session with specific engine configurations. If the session state is not IDLE, the function
+        polls until the session creation is complete. The response containing session information is returned.
+
+        Returns:
+            dict: The session information dictionary.
+
+        """
+        response = self.athena_client.start_session(
+            WorkGroup=self.credentials.spark_work_group,
+            EngineConfiguration=self.engine_config,
+        )
+        if response["State"] != "IDLE":
+            self.poll_until_session_creation(response["SessionId"])
+        return UUID(response["SessionId"])
+
+    def poll_until_session_creation(self, session_id) -> None:
+        """
+        Polls the status of an Athena session creation until it is completed or reaches the timeout.
+
+        Args:
+            session_id (str): The ID of the session being created.
+
+        Returns:
+            str: The final status of the session, which will be "IDLE" if the session creation is successful.
+
+        Raises:
+            DbtRuntimeError: If the session creation fails, is terminated, or degrades during polling.
+            DbtRuntimeError: If the session does not become IDLE within the specified timeout.
+
+        """
+        polling_interval = self.polling_interval
+        while True:
+            creation_status = self.get_session_status(session_id)["State"]
+            if creation_status in ["FAILED", "TERMINATED", "DEGRADED"]:
+                raise DbtRuntimeError(f"Unable to create session: {session_id}. Got status: {creation_status}.")
+            elif creation_status == "IDLE":
+                LOGGER.debug(f"Session: {session_id} created")
+                break
+            time.sleep(polling_interval)
+            polling_interval *= 2
+            if polling_interval > self.timeout:
+                raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
+
+    def release_session_lock(self, session_id: str) -> None:
+        """
+        Terminate the current Athena session.
+
+        This function terminates the current Athena session if it is in IDLE or BUSY state and has exceeded the
+        configured timeout period. It retrieves the session status, and if the session state is IDLE or BUSY and the
+        duration since the session start time exceeds the timeout period, the session is terminated. The session ID is
+        used to terminate the session via the Athena client.
+
+        Returns:
+            None
+
+        """
+        session_status = self.get_session_status(session_id)
+        if session_status["State"] in ["IDLE", "BUSY"] and (
+            session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
+        ):
+            LOGGER.debug(f"Terminating session: {session_id}")
+            self.athena_client.terminate_session(SessionId=session_id)
+        with self.lock:
+            LOGGER.debug(f"Releasing lock for session: {session_id}")
+            spark_session_locks[UUID(session_id)].release()
+
+    def get_session_status(self, session_id) -> Dict[str, Any]:
+        """
+        Get the session status.
+
+        Returns:
+            str: The status of the session
+        """
+        return self.athena_client.get_session_status(SessionId=session_id)["Status"]
diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index f0b31215..bf389e4a 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -78,7 +78,7 @@ def get_spark_df(identifier):
     So the override removes the catalog component and only
     provides the schema and identifer to spark.table()
     """
-    return spark.table(identifier.split(".", 1)[1])
+    return spark.table(".".join(identifier.split(".")[1:]).replace('"', ''))
 
 class SparkdbtObj(dbtObj):
     def __init__(self):
diff --git a/tests/unit/test_config.py b/tests/unit/test_config.py
index 28b33ab1..aebcc8fe 100644
--- a/tests/unit/test_config.py
+++ b/tests/unit/test_config.py
@@ -1,8 +1,9 @@
 from unittest.mock import Mock
 
 import pkg_resources
+import pytest
 
-from dbt.adapters.athena.config import get_boto3_config
+from dbt.adapters.athena.config import AthenaSparkSessionConfig, get_boto3_config
 
 
 class TestConfig:
@@ -11,3 +12,96 @@ def test_get_boto3_config(self):
         get_boto3_config.cache_clear()
         config = get_boto3_config()
         assert config._user_provided_options["user_agent_extra"] == "dbt-athena-community/2.4.6"
+
+
+class TestAthenaSparkSessionConfig:
+    """
+    A class to test AthenaSparkSessionConfig
+    """
+
+    @pytest.fixture
+    def spark_config(self, request):
+        """
+        Fixture for providing Spark configuration parameters.
+
+        This fixture returns a dictionary containing the Spark configuration parameters. The parameters can be
+        customized using the `request.param` object. The default values are:
+        - `timeout`: 7200 seconds
+        - `polling_interval`: 5 seconds
+        - `engine_config`: {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+
+        Args:
+            self: The test class instance.
+            request: The pytest request object.
+
+        Returns:
+            dict: The Spark configuration parameters.
+
+        """
+        return {
+            "timeout": request.param.get("timeout", 7200),
+            "polling_interval": request.param.get("polling_interval", 5),
+            "engine_config": request.param.get(
+                "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+            ),
+        }
+
+    @pytest.fixture
+    def spark_config_helper(self, spark_config):
+        """Fixture for testing AthenaSparkSessionConfig class.
+
+        Args:
+            spark_config (dict): Fixture for default spark config.
+
+        Returns:
+            AthenaSparkSessionConfig: An instance of AthenaSparkSessionConfig class.
+        """
+        return AthenaSparkSessionConfig(spark_config)
+
+    @pytest.mark.parametrize(
+        "spark_config",
+        [
+            {"timeout": 5},
+            {"timeout": 10},
+            {"timeout": 20},
+            {},
+            pytest.param({"timeout": -1}, marks=pytest.mark.xfail),
+            pytest.param({"timeout": None}, marks=pytest.mark.xfail),
+        ],
+        indirect=True,
+    )
+    def test_set_timeout(self, spark_config_helper):
+        timeout = spark_config_helper.set_timeout()
+        assert timeout == spark_config_helper.config.get("timeout", 7200)
+
+    @pytest.mark.parametrize(
+        "spark_config",
+        [
+            {"polling_interval": 5},
+            {"polling_interval": 10},
+            {"polling_interval": 20},
+            {},
+            pytest.param({"polling_interval": -1}, marks=pytest.mark.xfail),
+        ],
+        indirect=True,
+    )
+    def test_set_polling_interval(self, spark_config_helper):
+        polling_interval = spark_config_helper.set_polling_interval()
+        assert polling_interval == spark_config_helper.config.get("polling_interval", 5)
+
+    @pytest.mark.parametrize(
+        "spark_config",
+        [
+            {"engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}},
+            {"engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 2}},
+            {},
+            pytest.param({"engine_config": {"CoordinatorDpuSize": 1}}, marks=pytest.mark.xfail),
+            pytest.param({"engine_config": [1, 1, 1]}, marks=pytest.mark.xfail),
+        ],
+        indirect=True,
+    )
+    def test_set_engine_config(self, spark_config_helper):
+        engine_config = spark_config_helper.set_engine_config()
+        assert engine_config == spark_config_helper.config.get(
+            "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+        )
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 37675c8e..73189943 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -1,457 +1,14 @@
 import time
-import uuid
 from unittest.mock import Mock, patch
 
 import pytest
 
-from dbt.adapters.athena import python_submissions
-from dbt.adapters.athena.python_submissions import (
-    AthenaPythonJobHelper,
-    AthenaSparkSessionConfig,
-    AthenaSparkSessionManager,
-)
-from dbt.exceptions import DbtRuntimeError
+from dbt.adapters.athena.python_submissions import AthenaPythonJobHelper
+from dbt.adapters.athena.session import AthenaSparkSessionManager
 
 from .constants import DATABASE_NAME
 
 
-class TestAthenaSparkSessionConfig:
-    """
-    A class to test AthenaSparkSessionConfig
-    """
-
-    @pytest.fixture
-    def spark_config(self, request):
-        """
-        Fixture for providing Spark configuration parameters.
-
-        This fixture returns a dictionary containing the Spark configuration parameters. The parameters can be
-        customized using the `request.param` object. The default values are:
-        - `timeout`: 7200 seconds
-        - `polling_interval`: 5 seconds
-        - `engine_config`: {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
-
-        Args:
-            self: The test class instance.
-            request: The pytest request object.
-
-        Returns:
-            dict: The Spark configuration parameters.
-
-        """
-        return {
-            "timeout": request.param.get("timeout", 7200),
-            "polling_interval": request.param.get("polling_interval", 5),
-            "engine_config": request.param.get(
-                "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
-            ),
-        }
-
-    @pytest.fixture
-    def spark_config_helper(self, spark_config):
-        """Fixture for testing AthenaSparkSessionConfig class.
-
-        Args:
-            spark_config (dict): Fixture for default spark config.
-
-        Returns:
-            AthenaSparkSessionConfig: An instance of AthenaSparkSessionConfig class.
-        """
-        return AthenaSparkSessionConfig(spark_config)
-
-    @pytest.mark.parametrize(
-        "spark_config",
-        [
-            {"timeout": 5},
-            {"timeout": 10},
-            {"timeout": 20},
-            {},
-            pytest.param({"timeout": -1}, marks=pytest.mark.xfail),
-            pytest.param({"timeout": None}, marks=pytest.mark.xfail),
-        ],
-        indirect=True,
-    )
-    def test_set_timeout(self, spark_config_helper):
-        timeout = spark_config_helper.set_timeout()
-        assert timeout == spark_config_helper.config.get("timeout", 7200)
-
-    @pytest.mark.parametrize(
-        "spark_config",
-        [
-            {"polling_interval": 5},
-            {"polling_interval": 10},
-            {"polling_interval": 20},
-            {},
-            pytest.param({"polling_interval": -1}, marks=pytest.mark.xfail),
-        ],
-        indirect=True,
-    )
-    def test_set_polling_interval(self, spark_config_helper):
-        polling_interval = spark_config_helper.set_polling_interval()
-        assert polling_interval == spark_config_helper.config.get("polling_interval", 5)
-
-    @pytest.mark.parametrize(
-        "spark_config",
-        [
-            {"engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}},
-            {"engine_config": {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 2}},
-            {},
-            pytest.param({"engine_config": {"CoordinatorDpuSize": 1}}, marks=pytest.mark.xfail),
-            pytest.param({"engine_config": [1, 1, 1]}, marks=pytest.mark.xfail),
-        ],
-        indirect=True,
-    )
-    def test_set_engine_config(self, spark_config_helper):
-        engine_config = spark_config_helper.set_engine_config()
-        assert engine_config == spark_config_helper.config.get(
-            "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
-        )
-
-
-@pytest.mark.usefixtures("athena_credentials", "athena_client")
-class TestAthenaSparkSessionManager:
-    """
-    A class to test the AthenaSparkSessionManager
-    """
-
-    @pytest.fixture
-    def spark_session_manager(self, athena_credentials, athena_client, monkeypatch):
-        """
-        Fixture for creating a mock Spark session manager.
-
-        This fixture creates an instance of AthenaSparkSessionManager with the provided Athena credentials,
-        timeout, polling interval, and engine configuration. It then patches the Athena client of the manager
-        with the provided `athena_client` object. The fixture returns the mock Spark session manager.
-
-        Args:
-            self: The test class instance.
-            athena_credentials: The Athena credentials.
-            athena_client: The Athena client object.
-            monkeypatch: The monkeypatch object for mocking.
-
-        Returns:
-            The mock Spark session manager.
-
-        """
-        mock_session_manager = AthenaSparkSessionManager(
-            athena_credentials,
-            timeout=10,
-            polling_interval=5,
-            engine_config={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
-        )
-        monkeypatch.setattr(mock_session_manager, "athena_client", athena_client)
-        return mock_session_manager
-
-    @pytest.mark.parametrize(
-        "session_status_response, expected_response",
-        [
-            pytest.param(
-                {
-                    "Sessions": [
-                        {
-                            "SessionId": "string",
-                            "Status": {
-                                "StartDateTime": "number",
-                                "State": "IDLE",
-                            },
-                        }
-                    ],
-                },
-                [
-                    {
-                        "SessionId": "string",
-                        "Status": {
-                            "StartDateTime": "number",
-                            "State": "IDLE",
-                        },
-                    }
-                ],
-            ),
-            (
-                {
-                    "Sessions": [],
-                },
-                {},
-            ),
-        ],
-    )
-    def test_list_sessions(
-        self, session_status_response, expected_response, spark_session_manager, athena_client
-    ) -> None:
-        """
-        Test the _list_sessions method of the AthenaJobHelper class.
-
-        Args:
-            session_status_response (dict): The response object to be returned by the mock Athena client.
-            expected_response (dict): The expected output of the _list_sessions method.
-            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
-            athena_client (Mock): A mock instance of the Athena client.
-
-        Returns:
-            None: This function only asserts the output of the _list_sessions method.
-
-        Raises:
-            AssertionError: If the output of the _list_sessions method does not match the expected output.
-        """
-        with patch.object(athena_client, "list_sessions", return_value=session_status_response):
-            response = spark_session_manager.list_sessions()
-            assert response == expected_response
-
-    @pytest.mark.parametrize(
-        "session_status_response, expected_response",
-        [
-            pytest.param(
-                {"Status": {"SessionId": "test_session_id", "State": "CREATING"}},
-                DbtRuntimeError(
-                    """Session <MagicMock name='client.start_session().__getitem__()' id='140219810489792'>
-                    did not create within 10 seconds."""
-                ),
-                marks=pytest.mark.xfail,
-            ),
-            (
-                {"Status": {"SessionId": "test_session_id", "State": "IDLE"}},
-                "test_session_id",
-            ),
-            pytest.param(
-                {"Status": {"SessionId": "test_session_id", "State": "TERMINATED"}},
-                DbtRuntimeError("Unable to create session: test_session_id. Got status: TERMINATED."),
-                marks=pytest.mark.xfail,
-            ),
-        ],
-    )
-    def test_start_session(
-        self, session_status_response, expected_response, spark_session_manager, athena_client
-    ) -> None:
-        """
-        Test the start_session method of the AthenaJobHelper class.
-
-        Args:
-            session_status_response (dict): A dictionary containing the response from the Athena session
-            creation status.
-            expected_response (Union[dict, DbtRuntimeError]): The expected response from the start_session method.
-            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
-            athena_client (botocore.client.BaseClient): An instance of the botocore Athena client.
-
-        Returns:
-            None
-        """
-        with patch.multiple(
-            spark_session_manager,
-            poll_until_session_creation=Mock(return_value=session_status_response),
-        ), patch.multiple(
-            athena_client,
-            get_session_status=Mock(return_value=session_status_response),
-            start_session=Mock(return_value=session_status_response.get("Status")),
-        ):
-            response = spark_session_manager.start_session()
-            assert response == expected_response
-
-    @pytest.mark.parametrize(
-        "session_status_response, expected_status",
-        [
-            (
-                {
-                    "SessionId": "test_session_id",
-                    "Status": {
-                        "State": "CREATING",
-                    },
-                },
-                {
-                    "State": "CREATING",
-                },
-            ),
-            (
-                {
-                    "SessionId": "test_session_id",
-                    "Status": {
-                        "State": "IDLE",
-                    },
-                },
-                {
-                    "State": "IDLE",
-                },
-            ),
-        ],
-    )
-    def test_get_session_status(self, session_status_response, expected_status, spark_session_manager, athena_client):
-        """
-        Test the get_session_status function.
-
-        Args:
-            self: The test class instance.
-            session_status_response (dict): The response from get_session_status.
-            expected_status (dict): The expected session status.
-            spark_session_manager: The Spark session manager object.
-            athena_client: The Athena client object.
-
-        Returns:
-            None
-
-        Raises:
-            AssertionError: If the retrieved session status is not correct.
-        """
-        with patch.multiple(athena_client, get_session_status=Mock(return_value=session_status_response)):
-            response = spark_session_manager.get_session_status("test_session_id")
-            assert response == expected_status
-
-    @pytest.mark.parametrize(
-        "list_sessions_response, session_locks",
-        [
-            (
-                [
-                    {
-                        "SessionId": "106d7aca-4b3f-468d-a81d-308120e7f73c",
-                        "Status": {
-                            "State": "string",
-                        },
-                    },
-                    {
-                        "SessionId": "39cb8fc0-f855-4b67-91f1-81f068499071",
-                        "Status": {
-                            "State": "string",
-                        },
-                    },
-                ],
-                {"test_session_id": None},
-            ),
-            (
-                [],
-                {},
-            ),
-            (
-                [
-                    {
-                        "SessionId": "106d7aca-4b3f-468d-a81d-308120e7f73c",
-                        "Status": {
-                            "State": "string",
-                        },
-                    },
-                ],
-                {uuid.UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): "lock"},
-            ),
-        ],
-    )
-    def test_get_sessions(
-        self, list_sessions_response, session_locks, spark_session_manager, athena_client, monkeypatch
-    ):
-        """
-        Test the get_sessions function.
-
-        Args:
-            self: The test class instance.
-            list_sessions_response (list): The response from list_sessions.
-            session_locks (dict): The session locks.
-            spark_session_manager: The Spark session manager object.
-            athena_client: The Athena client object.
-            monkeypatch: The monkeypatch object for mocking.
-
-        Returns:
-            None
-
-        Raises:
-            AssertionError: If the retrieved sessions are not correct.
-        """
-        monkeypatch.setattr(python_submissions, "session_locks", session_locks)
-        with patch.multiple(
-            spark_session_manager,
-            list_sessions=Mock(return_value=list_sessions_response),
-        ):
-            sessions = spark_session_manager.get_sessions()
-            assert sessions == [uuid.UUID(response["SessionId"]) for response in list_sessions_response]
-
-    @pytest.mark.parametrize(
-        "get_session_response, current_session_locks",
-        [([], {}), ([uuid.UUID("106d7aca-4b3f-468d-a81d-308120e7f73c")], {})],
-    )
-    def test_update_session_locks(
-        self, get_session_response, current_session_locks, spark_session_manager, monkeypatch
-    ):
-        """
-        Test the update_session_locks function.
-
-        Args:
-            self: The test class instance.
-            get_session_response (list): The response from get_sessions.
-            current_session_locks (dict): The current session locks.
-            spark_session_manager: The Spark session manager object.
-            monkeypatch: The monkeypatch object for mocking.
-
-        Raises:
-            AssertionError: If the session locks are not updated correctly.
-        """
-        monkeypatch.setattr(python_submissions, "session_locks", current_session_locks)
-        with patch.multiple(
-            spark_session_manager,
-            get_sessions=Mock(return_value=get_session_response),
-        ):
-            spark_session_manager.update_session_locks()
-            for session in get_session_response:
-                assert session in python_submissions.session_locks.keys()
-                assert type(python_submissions.session_locks[session]) is not None
-
-    def test_get_session_id(self):
-        pass
-
-    @pytest.mark.parametrize(
-        "test_session_id, get_session_status_response, current_session_locks, terminate_session_response",
-        [
-            (
-                "106d7aca-4b3f-468d-a81d-308120e7f73c",
-                {
-                    "State": "string",
-                },
-                {uuid.UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): Mock()},
-                {"State": "TERMINATED"},
-            ),
-            (
-                "106d7aca-4b3f-468d-a81d-308120e7f73c",
-                {
-                    "State": "string",
-                },
-                {uuid.UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): Mock()},
-                {"State": "CREATED"},
-            ),
-        ],
-    )
-    def test_release_session_lock(
-        self,
-        test_session_id,
-        get_session_status_response,
-        current_session_locks,
-        terminate_session_response,
-        spark_session_manager,
-        athena_client,
-        monkeypatch,
-    ):
-        """
-        Test the release_session_lock function.
-
-        Args:
-            self: The test class instance.
-            test_session_id (str): The ID of the test session.
-            get_session_status_response (dict): The response from get_session_status.
-            current_session_locks (dict): The current session locks.
-            terminate_session_response (dict): The response from terminate_session.
-            spark_session_manager: The Spark session manager object.
-            athena_client: The Athena client object.
-            monkeypatch: The monkeypatch object for mocking.
-
-        Raises:
-            AssertionError: If the session lock is not released correctly.
-        """
-        monkeypatch.setattr(python_submissions, "session_locks", current_session_locks)
-        with patch.multiple(
-            spark_session_manager,
-            get_session_status=Mock(return_value=get_session_status_response),
-        ), patch.multiple(
-            athena_client,
-            terminate_session=Mock(return_value=terminate_session_response),
-        ):
-            spark_session_manager.release_session_lock(test_session_id)
-            assert uuid.UUID(test_session_id) in python_submissions.session_locks.keys()
-            assert type(python_submissions.session_locks[uuid.UUID(test_session_id)]) is not None
-
-
 @pytest.mark.usefixtures("athena_credentials", "athena_client")
 class TestAthenaPythonJobHelper:
     """
@@ -498,14 +55,14 @@ def athena_job_helper(
                 {
                     "State": "IDLE",
                 },
-                "IDLE",
+                None,
             ),
             pytest.param(
                 {"config": {"timeout": 5, "polling_interval": 5}},
                 {
                     "State": "FAILED",
                 },
-                "FAILED",
+                None,
                 marks=pytest.mark.xfail,
             ),
             pytest.param(
@@ -513,7 +70,7 @@ def athena_job_helper(
                 {
                     "State": "TERMINATED",
                 },
-                "TERMINATED",
+                None,
                 marks=pytest.mark.xfail,
             ),
             pytest.param(
@@ -521,7 +78,7 @@ def athena_job_helper(
                 {
                     "State": "CREATING",
                 },
-                "CREATING",
+                None,
                 marks=pytest.mark.xfail,
             ),
         ],
@@ -555,14 +112,15 @@ def mock_sleep(_):
                 },
                 "COMPLETED",
             ),
-            (
+            pytest.param(
                 {"config": {"timeout": 1, "polling_interval": 5}},
                 {
                     "Status": {
                         "State": "FAILED",
                     }
                 },
-                "FAILED",
+                None,
+                marks=pytest.mark.xfail,
             ),
             pytest.param(
                 {"config": {"timeout": 1, "polling_interval": 5}},
@@ -613,13 +171,14 @@ def mock_sleep(_):
             pytest.param(
                 {"config": {"timeout": 1, "polling_interval": 5}},
                 {"CalculationExecutionId": "test_execution_id"},
-                {"Result": {"ResultS3Uri": None}},
+                {"Result": {}},
                 {"Status": {"State": "FAILED"}},
+                marks=pytest.mark.xfail,
             ),
             pytest.param(
                 {"config": {"timeout": 1, "polling_interval": 5}},
                 {},
-                {"Result": {"ResultS3Uri": None}},
+                {"Result": {}},
                 {"Status": {"State": "FAILED"}},
                 marks=pytest.mark.xfail,
             ),
@@ -648,4 +207,4 @@ def test_submission(
             athena_job_helper, poll_until_session_idle=Mock(return_value="IDLE")
         ):
             result = athena_job_helper.submit("hello world")
-            assert result == test_calculation_execution["Result"]["ResultS3Uri"]
+            assert result == test_calculation_execution["Result"]
diff --git a/tests/unit/test_session.py b/tests/unit/test_session.py
index 7e9c4e43..cd4681fb 100644
--- a/tests/unit/test_session.py
+++ b/tests/unit/test_session.py
@@ -1,9 +1,13 @@
+from unittest.mock import Mock, patch
+from uuid import UUID
+
 import botocore.session
 import pytest
 
-from dbt.adapters.athena import AthenaCredentials
-from dbt.adapters.athena.session import get_boto3_session
+from dbt.adapters.athena import AthenaCredentials, session
+from dbt.adapters.athena.session import AthenaSparkSessionManager, get_boto3_session
 from dbt.contracts.connection import Connection
+from dbt.exceptions import DbtRuntimeError
 
 
 class TestSession:
@@ -35,3 +39,336 @@ def mock___build_profile_map(_):
         session = get_boto3_session(connection)
         assert session.region_name == "eu-west-1"
         assert session.profile_name == boto_profile_name
+
+
+@pytest.mark.usefixtures("athena_credentials", "athena_client")
+class TestAthenaSparkSessionManager:
+    """
+    A class to test the AthenaSparkSessionManager
+    """
+
+    @pytest.fixture
+    def spark_session_manager(self, athena_credentials, athena_client, monkeypatch):
+        """
+        Fixture for creating a mock Spark session manager.
+
+        This fixture creates an instance of AthenaSparkSessionManager with the provided Athena credentials,
+        timeout, polling interval, and engine configuration. It then patches the Athena client of the manager
+        with the provided `athena_client` object. The fixture returns the mock Spark session manager.
+
+        Args:
+            self: The test class instance.
+            athena_credentials: The Athena credentials.
+            athena_client: The Athena client object.
+            monkeypatch: The monkeypatch object for mocking.
+
+        Returns:
+            The mock Spark session manager.
+
+        """
+        mock_session_manager = AthenaSparkSessionManager(
+            athena_credentials,
+            timeout=10,
+            polling_interval=5,
+            engine_config={"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1},
+        )
+        monkeypatch.setattr(mock_session_manager, "athena_client", athena_client)
+        return mock_session_manager
+
+    @pytest.mark.parametrize(
+        "session_status_response, expected_response",
+        [
+            pytest.param(
+                {
+                    "Sessions": [
+                        {
+                            "SessionId": "635c1c6d-766c-408b-8bce-fae8ea7006f7",
+                            "Status": {
+                                "StartDateTime": "number",
+                                "State": "IDLE",
+                            },
+                        }
+                    ],
+                },
+                [UUID("635c1c6d-766c-408b-8bce-fae8ea7006f7")],
+            ),
+            (
+                {
+                    "Sessions": [],
+                },
+                [UUID("635c1c6d-766c-408b-8bce-fae8ea7006f7")],
+            ),
+        ],
+    )
+    def test_list_sessions(
+        self, session_status_response, expected_response, spark_session_manager, athena_client
+    ) -> None:
+        """
+        Test the _list_sessions method of the AthenaJobHelper class.
+
+        Args:
+            session_status_response (dict): The response object to be returned by the mock Athena client.
+            expected_response (dict): The expected output of the _list_sessions method.
+            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
+            athena_client (Mock): A mock instance of the Athena client.
+
+        Returns:
+            None: This function only asserts the output of the _list_sessions method.
+
+        Raises:
+            AssertionError: If the output of the _list_sessions method does not match the expected output.
+        """
+        with patch.object(athena_client, "list_sessions", return_value=session_status_response), patch.object(
+            AthenaSparkSessionManager, "start_session", return_value=UUID("635c1c6d-766c-408b-8bce-fae8ea7006f7")
+        ):
+            response = spark_session_manager.list_sessions()
+            assert response == expected_response
+
+    @pytest.mark.parametrize(
+        "session_status_response, expected_response",
+        [
+            pytest.param(
+                {"Status": {"SessionId": "test_session_id", "State": "CREATING"}},
+                DbtRuntimeError(
+                    """Session <MagicMock name='client.start_session().__getitem__()' id='140219810489792'>
+                    did not create within 10 seconds."""
+                ),
+                marks=pytest.mark.xfail,
+            ),
+            (
+                {"Status": {"SessionId": "635c1c6d-766c-408b-8bce-fae8ea7006f7", "State": "IDLE"}},
+                UUID("635c1c6d-766c-408b-8bce-fae8ea7006f7"),
+            ),
+            pytest.param(
+                {"Status": {"SessionId": "test_session_id", "State": "TERMINATED"}},
+                DbtRuntimeError("Unable to create session: test_session_id. Got status: TERMINATED."),
+                marks=pytest.mark.xfail,
+            ),
+        ],
+    )
+    def test_start_session(
+        self, session_status_response, expected_response, spark_session_manager, athena_client
+    ) -> None:
+        """
+        Test the start_session method of the AthenaJobHelper class.
+
+        Args:
+            session_status_response (dict): A dictionary containing the response from the Athena session
+            creation status.
+            expected_response (Union[dict, DbtRuntimeError]): The expected response from the start_session method.
+            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
+            athena_client (botocore.client.BaseClient): An instance of the botocore Athena client.
+
+        Returns:
+            None
+        """
+        with patch.multiple(
+            spark_session_manager,
+            poll_until_session_creation=Mock(return_value=session_status_response),
+        ), patch.multiple(
+            athena_client,
+            get_session_status=Mock(return_value=session_status_response),
+            start_session=Mock(return_value=session_status_response.get("Status")),
+        ):
+            response = spark_session_manager.start_session()
+            assert response == expected_response
+
+    @pytest.mark.parametrize(
+        "session_status_response, expected_status",
+        [
+            (
+                {
+                    "SessionId": "test_session_id",
+                    "Status": {
+                        "State": "CREATING",
+                    },
+                },
+                {
+                    "State": "CREATING",
+                },
+            ),
+            (
+                {
+                    "SessionId": "test_session_id",
+                    "Status": {
+                        "State": "IDLE",
+                    },
+                },
+                {
+                    "State": "IDLE",
+                },
+            ),
+        ],
+    )
+    def test_get_session_status(self, session_status_response, expected_status, spark_session_manager, athena_client):
+        """
+        Test the get_session_status function.
+
+        Args:
+            self: The test class instance.
+            session_status_response (dict): The response from get_session_status.
+            expected_status (dict): The expected session status.
+            spark_session_manager: The Spark session manager object.
+            athena_client: The Athena client object.
+
+        Returns:
+            None
+
+        Raises:
+            AssertionError: If the retrieved session status is not correct.
+        """
+        with patch.multiple(athena_client, get_session_status=Mock(return_value=session_status_response)):
+            response = spark_session_manager.get_session_status("test_session_id")
+            assert response == expected_status
+
+    @pytest.mark.parametrize(
+        "list_sessions_response, spark_session_locks, expected_new_sessions",
+        [
+            (
+                [
+                    UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"),
+                    UUID("39cb8fc0-f855-4b67-91f1-81f068499071"),
+                ],
+                {"test_session_id": None},
+                [
+                    UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"),
+                    UUID("39cb8fc0-f855-4b67-91f1-81f068499071"),
+                ],
+            ),
+            (
+                [],
+                {},
+                [],
+            ),
+            (
+                [UUID("106d7aca-4b3f-468d-a81d-308120e7f73c")],
+                {UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): "lock"},
+                [],
+            ),
+        ],
+    )
+    def test_get_sessions(
+        self,
+        list_sessions_response,
+        spark_session_locks,
+        expected_new_sessions,
+        spark_session_manager,
+        athena_client,
+        monkeypatch,
+    ):
+        """
+        Test the get_sessions function.
+
+        Args:
+            self: The test class instance.
+            list_sessions_response (list): The response from list_sessions.
+            spark_session_locks (dict): The session locks.
+            spark_session_manager: The Spark session manager object.
+            athena_client: The Athena client object.
+            monkeypatch: The monkeypatch object for mocking.
+
+        Returns:
+            None
+
+        Raises:
+            AssertionError: If the retrieved sessions are not correct.
+        """
+        monkeypatch.setattr(session, "spark_session_locks", spark_session_locks)
+        with patch.multiple(
+            spark_session_manager,
+            list_sessions=Mock(return_value=list_sessions_response),
+        ):
+            sessions = spark_session_manager.get_new_sessions()
+            assert sessions == expected_new_sessions
+
+    @pytest.mark.parametrize(
+        "get_session_response, current_spark_session_locks",
+        [([], {}), ([UUID("106d7aca-4b3f-468d-a81d-308120e7f73c")], {})],
+    )
+    def test_update_spark_session_locks(
+        self, get_session_response, current_spark_session_locks, spark_session_manager, monkeypatch
+    ):
+        """
+        Test the update_spark_session_locks function.
+
+        Args:
+            self: The test class instance.
+            get_session_response (list): The response from get_sessions.
+            current_spark_session_locks (dict): The current session locks.
+            spark_session_manager: The Spark session manager object.
+            monkeypatch: The monkeypatch object for mocking.
+
+        Raises:
+            AssertionError: If the session locks are not updated correctly.
+        """
+        monkeypatch.setattr(session, "spark_session_locks", current_spark_session_locks)
+        with patch.multiple(
+            spark_session_manager,
+            get_new_sessions=Mock(return_value=get_session_response),
+        ):
+            spark_session_manager.update_spark_session_locks()
+            for each_session in get_session_response:
+                assert each_session in session.spark_session_locks.keys()
+                assert type(session.spark_session_locks[each_session]) is not None
+
+    def test_get_session_id(self):
+        pass
+
+    @pytest.mark.parametrize(
+        "test_session_id, get_session_status_response, current_spark_session_locks, terminate_session_response",
+        [
+            (
+                "106d7aca-4b3f-468d-a81d-308120e7f73c",
+                {
+                    "State": "string",
+                },
+                {UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): Mock()},
+                {"State": "TERMINATED"},
+            ),
+            (
+                "106d7aca-4b3f-468d-a81d-308120e7f73c",
+                {
+                    "State": "string",
+                },
+                {UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): Mock()},
+                {"State": "CREATED"},
+            ),
+        ],
+    )
+    def test_release_session_lock(
+        self,
+        test_session_id,
+        get_session_status_response,
+        current_spark_session_locks,
+        terminate_session_response,
+        spark_session_manager,
+        athena_client,
+        monkeypatch,
+    ):
+        """
+        Test the release_session_lock function.
+
+        Args:
+            self: The test class instance.
+            test_session_id (str): The ID of the test session.
+            get_session_status_response (dict): The response from get_session_status.
+            current_spark_session_locks (dict): The current session locks.
+            terminate_session_response (dict): The response from terminate_session.
+            spark_session_manager: The Spark session manager object.
+            athena_client: The Athena client object.
+            monkeypatch: The monkeypatch object for mocking.
+
+        Raises:
+            AssertionError: If the session lock is not released correctly.
+        """
+        monkeypatch.setattr(session, "spark_session_locks", current_spark_session_locks)
+        with patch.multiple(
+            spark_session_manager,
+            get_session_status=Mock(return_value=get_session_status_response),
+        ), patch.multiple(
+            athena_client,
+            terminate_session=Mock(return_value=terminate_session_response),
+        ):
+            spark_session_manager.release_session_lock(test_session_id)
+            assert UUID(test_session_id) in session.spark_session_locks.keys()
+            assert type(session.spark_session_locks[UUID(test_session_id)]) is not None

From 76c5c88da42058a598d7bb971a5e249fd749944f Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Sat, 10 Jun 2023 00:18:46 -0300
Subject: [PATCH 49/75] Extracted session_count and spark work group methods

---
 dbt/adapters/athena/constants.py |  3 +++
 dbt/adapters/athena/session.py   | 24 ++++++++++++++++++------
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/dbt/adapters/athena/constants.py b/dbt/adapters/athena/constants.py
index bfd6e4b0..df6bd86b 100644
--- a/dbt/adapters/athena/constants.py
+++ b/dbt/adapters/athena/constants.py
@@ -1,3 +1,6 @@
 from dbt.events import AdapterLogger
 
+DEFAULT_THREAD_COUNT = 4
+DEFAULT_RETRY_ATTEMPTS = 3
+
 LOGGER = AdapterLogger(__name__)
diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index 138e0d61..2068fc42 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -7,11 +7,10 @@
 import boto3
 import boto3.session
 
-from dbt.adapters.athena.constants import LOGGER
+from dbt.adapters.athena.constants import DEFAULT_THREAD_COUNT, LOGGER
 from dbt.contracts.connection import Connection
 from dbt.exceptions import DbtRuntimeError
 
-DEFAULT_SESSION_COUNT = 4
 spark_session_locks: Dict[UUID, threading.Lock] = {}
 
 
@@ -37,6 +36,16 @@ def __init__(self, credentials, timeout: int, polling_interval: float, engine_co
         self.lock = threading.Lock()
         self.athena_client = self.get_athena_client()
 
+    def get_max_session_count(self):
+        if not self.credentials.threads:
+            return DEFAULT_THREAD_COUNT
+        return self.credentials.threads
+
+    def get_spark_work_group(self):
+        if not self.credentials.spark_work_group:
+            raise DbtRuntimeError("Expected spark_work_group in profile")
+        return self.credentials.spark_work_group
+
     def get_athena_client(self):
         """
         Get the AWS Athena client.
@@ -110,7 +119,7 @@ def get_session_id(self) -> UUID:
             time.sleep(polling_interval)
             polling_interval *= 2
 
-    def list_sessions(self, max_results: int = DEFAULT_SESSION_COUNT, state: str = "IDLE") -> List[UUID]:
+    def list_sessions(self, state: str = "IDLE") -> List[UUID]:
         """
         List athena spark sessions.
 
@@ -123,14 +132,17 @@ def list_sessions(self, max_results: int = DEFAULT_SESSION_COUNT, state: str = "
             the list of the returned session id.
 
         """
+        max_results = self.get_max_session_count()
         response = self.athena_client.list_sessions(
-            WorkGroup=self.credentials.spark_work_group, MaxResults=max_results, StateFilter=state
+            WorkGroup=self.get_spark_work_group(),
+            MaxResults=max_results,
+            StateFilter=state,
         )
         if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
-            if len(spark_session_locks) < DEFAULT_SESSION_COUNT:
+            if len(spark_session_locks) < max_results:
                 return [self.start_session()]
             LOGGER.warning(
-                f"""Maximum spark session count: {DEFAULT_SESSION_COUNT} reached.
+                f"""Maximum spark session count: {max_results} reached.
             Cannot start new spark session."""
             )
         return [UUID(session_string["SessionId"]) for session_string in response.get("Sessions")]

From 1fd436ef65547f6b8218c7ef1581e8f0efb9db51 Mon Sep 17 00:00:00 2001
From: Julian Steger <108534789+juliansteger-sc@users.noreply.github.com>
Date: Fri, 9 Jun 2023 13:40:28 +0200
Subject: [PATCH 50/75] fix: BatchDeletePartitions only accepts up to 25
 partitions (#328)

---
 dbt/adapters/athena/impl.py  | 37 ++++++++++++++++++++++--------------
 dbt/adapters/athena/utils.py | 11 ++++++++++-
 tests/unit/test_adapter.py   |  4 ++--
 tests/unit/test_utils.py     | 19 +++++++++++++++++-
 tests/unit/utils.py          |  2 +-
 5 files changed, 54 insertions(+), 19 deletions(-)

diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index 48f982b1..2c4e47e6 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -35,7 +35,7 @@
     get_table_type,
 )
 from dbt.adapters.athena.s3 import S3DataNaming
-from dbt.adapters.athena.utils import clean_sql_comment, get_catalog_id
+from dbt.adapters.athena.utils import clean_sql_comment, get_catalog_id, get_chunks
 from dbt.adapters.base import ConstraintSupport, PythonJobHelper, available
 from dbt.adapters.base.relation import BaseRelation, InformationSchema
 from dbt.adapters.sql import SQLAdapter
@@ -48,6 +48,9 @@
 
 
 class AthenaAdapter(SQLAdapter):
+    BATCH_CREATE_PARTITION_API_LIMIT = 100
+    BATCH_DELETE_PARTITION_API_LIMIT = 25
+
     ConnectionManager = AthenaConnectionManager
     Relation = AthenaRelation
 
@@ -524,21 +527,27 @@ def swap_table(self, src_relation: AthenaRelation, target_relation: AthenaRelati
         # if source table has partitions we need to delete and add partitions
         # it source table hasn't any partitions we need to delete target table partitions
         if target_table_partitions:
-            glue_client.batch_delete_partition(
-                DatabaseName=target_relation.schema,
-                TableName=target_relation.identifier,
-                PartitionsToDelete=[{"Values": i["Values"]} for i in target_table_partitions],
-            )
+            for partition_batch in get_chunks(target_table_partitions, AthenaAdapter.BATCH_DELETE_PARTITION_API_LIMIT):
+                glue_client.batch_delete_partition(
+                    DatabaseName=target_relation.schema,
+                    TableName=target_relation.identifier,
+                    PartitionsToDelete=[{"Values": partition["Values"]} for partition in partition_batch],
+                )
 
         if src_table_partitions:
-            glue_client.batch_create_partition(
-                DatabaseName=target_relation.schema,
-                TableName=target_relation.identifier,
-                PartitionInputList=[
-                    {"Values": p["Values"], "StorageDescriptor": p["StorageDescriptor"], "Parameters": p["Parameters"]}
-                    for p in src_table_partitions
-                ],
-            )
+            for partition_batch in get_chunks(src_table_partitions, AthenaAdapter.BATCH_CREATE_PARTITION_API_LIMIT):
+                glue_client.batch_create_partition(
+                    DatabaseName=target_relation.schema,
+                    TableName=target_relation.identifier,
+                    PartitionInputList=[
+                        {
+                            "Values": partition["Values"],
+                            "StorageDescriptor": partition["StorageDescriptor"],
+                            "Parameters": partition["Parameters"],
+                        }
+                        for partition in partition_batch
+                    ],
+                )
 
     def _get_glue_table_versions_to_expire(self, relation: AthenaRelation, to_keep: int):
         """
diff --git a/dbt/adapters/athena/utils.py b/dbt/adapters/athena/utils.py
index b0e9bbdf..ee3b20bc 100644
--- a/dbt/adapters/athena/utils.py
+++ b/dbt/adapters/athena/utils.py
@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Collection, List, Optional, TypeVar
 
 from mypy_boto3_athena.type_defs import DataCatalogTypeDef
 
@@ -11,3 +11,12 @@ def clean_sql_comment(comment: str) -> str:
 def get_catalog_id(catalog: Optional[DataCatalogTypeDef]) -> Optional[str]:
     if catalog:
         return catalog["Parameters"]["catalog-id"]
+
+
+T = TypeVar("T")
+
+
+def get_chunks(lst: Collection[T], n: int) -> Collection[List[T]]:
+    """Yield successive n-sized chunks from lst."""
+    for i in range(0, len(lst), n):
+        yield lst[i : i + n]
diff --git a/tests/unit/test_adapter.py b/tests/unit/test_adapter.py
index 55397f10..ad66d536 100644
--- a/tests/unit/test_adapter.py
+++ b/tests/unit/test_adapter.py
@@ -728,7 +728,7 @@ def test_swap_table_with_partitions(self, mock_aws_service):
         mock_aws_service.create_table(source_table)
         mock_aws_service.add_partitions_to_table(DATABASE_NAME, source_table)
         mock_aws_service.create_table(target_table)
-        mock_aws_service.add_partitions_to_table(DATABASE_NAME, source_table)
+        mock_aws_service.add_partitions_to_table(DATABASE_NAME, target_table)
         source_relation = self.adapter.Relation.create(
             database=DATA_CATALOG_NAME,
             schema=DATABASE_NAME,
@@ -836,7 +836,7 @@ def test_swap_table_with_no_partitions_to_one_with(self, mock_aws_service):
         ).get("Partitions")
 
         assert self.adapter.get_glue_table_location(target_relation) == f"s3://{BUCKET}/tables/{source_table}"
-        assert len(target_table_partitions_after) == 3
+        assert len(target_table_partitions_after) == 26
 
     @mock_athena
     @mock_glue
diff --git a/tests/unit/test_utils.py b/tests/unit/test_utils.py
index b72d9311..23851360 100644
--- a/tests/unit/test_utils.py
+++ b/tests/unit/test_utils.py
@@ -1,4 +1,4 @@
-from dbt.adapters.athena.utils import clean_sql_comment
+from dbt.adapters.athena.utils import clean_sql_comment, get_chunks
 
 
 def test_clean_comment():
@@ -12,3 +12,20 @@ def test_clean_comment():
         )
         == "my long comment on several lines with weird spaces and indents."
     )
+
+
+def test_get_chunks_empty():
+    assert len(list(get_chunks([], 5))) == 0
+
+
+def test_get_chunks_uneven():
+    chunks = list(get_chunks([1, 2, 3], 2))
+    assert chunks[0] == [1, 2]
+    assert chunks[1] == [3]
+    assert len(chunks) == 2
+
+
+def test_get_chunks_more_elements_than_chunk():
+    chunks = list(get_chunks([1, 2, 3], 4))
+    assert chunks[0] == [1, 2, 3]
+    assert len(chunks) == 1
diff --git a/tests/unit/utils.py b/tests/unit/utils.py
index eeacd230..60ec02ed 100644
--- a/tests/unit/utils.py
+++ b/tests/unit/utils.py
@@ -450,7 +450,7 @@ def add_partitions_to_table(self, database, table_name):
                 },
                 "Parameters": {"compressionType": "snappy", "classification": "parquet"},
             }
-            for dt in ["2022-01-01", "2022-01-02", "2022-01-03"]
+            for dt in [f"2022-01-{day:02d}" for day in range(1, 27)]
         ]
         glue = boto3.client("glue", region_name=AWS_REGION)
         glue.batch_create_partition(

From 0bdaa7ed9b765c549f75921f4ce0e84152a7611f Mon Sep 17 00:00:00 2001
From: Serhii Dimchenko <39801237+svdimchenko@users.noreply.github.com>
Date: Fri, 9 Jun 2023 14:00:25 +0200
Subject: [PATCH 51/75] feat: enable mypy pre-commit check (#329)

---
 .pre-commit-config.yaml              | 13 ++++++
 README.md                            |  1 +
 dbt/adapters/athena/column.py        | 10 ++---
 dbt/adapters/athena/connections.py   | 28 ++++++------
 dbt/adapters/athena/impl.py          | 65 ++++++++++++++--------------
 dbt/adapters/athena/lakeformation.py | 10 +++--
 dbt/adapters/athena/relation.py      | 15 +++----
 dbt/adapters/athena/utils.py         |  7 ++-
 setup.py                             |  5 ++-
 9 files changed, 85 insertions(+), 69 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 0381617f..9e88365e 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -59,3 +59,16 @@ repos:
           - 'Flake8-pyproject~=1.1'
         args:
           - '.'
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.3.0
+    hooks:
+      - id: mypy
+        args:
+          - --strict
+          - --ignore-missing-imports
+          - --install-types
+          - --allow-subclassing-any
+          - --allow-untyped-decorators
+        additional_dependencies:
+          - types-setuptools==67.8.0.0
+        exclude: ^tests/
diff --git a/README.md b/README.md
index 4579c7a1..50a9592b 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,7 @@
     <a href="https://pypi.org/project/dbt-athena-community/"><img src="https://badge.fury.io/py/dbt-athena-community.svg" /></a>
     <a href="https://pycqa.github.io/isort/"><img src="https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336" /></a>
     <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg" /></a>
+    <a href="https://github.com/python/mypy"><img src="https://www.mypy-lang.org/static/mypy_badge.svg" /></a>
     <a href="https://pepy.tech/project/dbt-athena-community"><img src="https://pepy.tech/badge/dbt-athena-community/month" /></a>
 </p>
 <p align="center">
diff --git a/dbt/adapters/athena/column.py b/dbt/adapters/athena/column.py
index e5dfdadd..75fc1bdc 100644
--- a/dbt/adapters/athena/column.py
+++ b/dbt/adapters/athena/column.py
@@ -37,19 +37,17 @@ def timestamp_type(self) -> str:
     def string_size(self) -> int:
         if not self.is_string():
             raise DbtRuntimeError("Called string_size() on non-string field!")
-        if not self.char_size:
-            # Handle error: '>' not supported between instances of 'NoneType' and 'NoneType' for union relations macro
-            return 0
-        return self.char_size
+        # Handle error: '>' not supported between instances of 'NoneType' and 'NoneType' for union relations macro
+        return self.char_size or 0
 
     @property
     def data_type(self) -> str:
         if self.is_string():
             return self.string_type(self.string_size())
         elif self.is_numeric():
-            return self.numeric_type(self.dtype, self.numeric_precision, self.numeric_scale)
+            return self.numeric_type(self.dtype, self.numeric_precision, self.numeric_scale)  # type: ignore
         elif self.is_binary():
             return self.binary_type()
         elif self.is_timestamp():
             return self.timestamp_type()
-        return self.dtype
+        return self.dtype  # type: ignore
diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index b8965cc6..00c7f42a 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -4,7 +4,7 @@
 from copy import deepcopy
 from dataclasses import dataclass
 from decimal import Decimal
-from typing import Any, ContextManager, Dict, List, Optional, Tuple, Union
+from typing import Any, ContextManager, Dict, List, Optional, Tuple
 
 import tenacity
 from pyathena.connection import Connection as AthenaConnection
@@ -58,7 +58,7 @@ def type(self) -> str:
         return "athena"
 
     @property
-    def unique_field(self):
+    def unique_field(self) -> str:
         return f"athena-{hashlib.md5(self.s3_staging_dir.encode()).hexdigest()}"
 
     def _connection_keys(self) -> Tuple[str, ...]:
@@ -81,7 +81,7 @@ def _connection_keys(self) -> Tuple[str, ...]:
 
 
 class AthenaCursor(Cursor):
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs) -> None:  # type: ignore
         super().__init__(**kwargs)
         self._executor = ThreadPoolExecutor()
 
@@ -95,7 +95,7 @@ def _collect_result_set(self, query_id: str) -> AthenaResultSet:
             retry_config=self._retry_config,
         )
 
-    def execute(
+    def execute(  # type: ignore
         self,
         operation: str,
         parameters: Optional[Dict[str, Any]] = None,
@@ -106,7 +106,7 @@ def execute(
         cache_expiration_time: int = 0,
         **kwargs,
     ):
-        def inner():
+        def inner() -> AthenaCursor:
             query_id = self._execute(
                 operation,
                 parameters=parameters,
@@ -146,7 +146,7 @@ class AthenaConnectionManager(SQLConnectionManager):
     TYPE = "athena"
 
     @classmethod
-    def data_type_code_to_name(cls, type_code: Union[int, str]) -> str:
+    def data_type_code_to_name(cls, type_code: str) -> str:
         """
         Get the string representation of the data type from the Athena metadata. Dbt performs a
         query to retrieve the types of the columns in the SQL query. Then these types are compared
@@ -155,8 +155,8 @@ def data_type_code_to_name(cls, type_code: Union[int, str]) -> str:
         """
         return type_code.split("(")[0].split("<")[0].upper()
 
-    @contextmanager
-    def exception_handler(self, sql: str) -> ContextManager:
+    @contextmanager  # type: ignore
+    def exception_handler(self, sql: str) -> ContextManager:  # type: ignore
         try:
             yield
         except Exception as e:
@@ -204,23 +204,23 @@ def open(cls, connection: Connection) -> Connection:
         return connection
 
     @classmethod
-    def get_response(cls, cursor) -> AdapterResponse:
+    def get_response(cls, cursor: AthenaCursor) -> AdapterResponse:
         code = "OK" if cursor.state == AthenaQueryExecution.STATE_SUCCEEDED else "ERROR"
         return AdapterResponse(_message=f"{code} {cursor.rowcount}", rows_affected=cursor.rowcount, code=code)
 
-    def cancel(self, connection: Connection):
+    def cancel(self, connection: Connection) -> None:
         connection.handle.cancel()
 
-    def add_begin_query(self):
+    def add_begin_query(self) -> None:
         pass
 
-    def add_commit_query(self):
+    def add_commit_query(self) -> None:
         pass
 
-    def begin(self):
+    def begin(self) -> None:
         pass
 
-    def commit(self):
+    def commit(self) -> None:
         pass
 
 
diff --git a/dbt/adapters/athena/impl.py b/dbt/adapters/athena/impl.py
index 2c4e47e6..1c0b3d5f 100755
--- a/dbt/adapters/athena/impl.py
+++ b/dbt/adapters/athena/impl.py
@@ -12,6 +12,7 @@
 import agate
 from botocore.exceptions import ClientError
 from mypy_boto3_athena.type_defs import DataCatalogTypeDef
+from mypy_boto3_glue.type_defs import ColumnTypeDef, TableTypeDef, TableVersionTypeDef
 
 from dbt.adapters.athena import AthenaConnectionManager
 from dbt.adapters.athena.column import AthenaColumn
@@ -103,7 +104,7 @@ def apply_lf_grants(self, relation: AthenaRelation, lf_grants_config: Dict[str,
                 lf = client.session.client("lakeformation", region_name=client.region_name, config=get_boto3_config())
             catalog = self._get_data_catalog(relation.database)
             catalog_id = get_catalog_id(catalog)
-            lf_permissions = LfPermissions(catalog_id, relation, lf)
+            lf_permissions = LfPermissions(catalog_id, relation, lf)  # type: ignore
             lf_permissions.process_filters(lf_config)
             lf_permissions.process_permissions(lf_config)
 
@@ -148,7 +149,7 @@ def _s3_table_prefix(self, s3_data_dir: Optional[str]) -> str:
 
         return path.join(creds.s3_staging_dir, "tables")
 
-    def _s3_data_naming(self, s3_data_naming: Optional[str]) -> Optional[S3DataNaming]:
+    def _s3_data_naming(self, s3_data_naming: Optional[str]) -> S3DataNaming:
         """
         Returns the s3 data naming strategy if provided, otherwise the value from the connection.
         """
@@ -177,7 +178,6 @@ def generate_s3_location(
 
         s3_path_table_part = relation.s3_path_table_part or relation.identifier
         schema_name = relation.schema
-        s3_data_naming = self._s3_data_naming(s3_data_naming)
         table_prefix = self._s3_table_prefix(s3_data_dir)
 
         mapping = {
@@ -188,7 +188,7 @@ def generate_s3_location(
             S3DataNaming.SCHEMA_TABLE_UNIQUE: path.join(table_prefix, schema_name, s3_path_table_part, str(uuid4())),
         }
 
-        return mapping[s3_data_naming]
+        return mapping[self._s3_data_naming(s3_data_naming)]
 
     @available
     def get_glue_table_location(self, relation: AthenaRelation) -> Optional[str]:
@@ -218,12 +218,11 @@ def get_glue_table_location(self, relation: AthenaRelation) -> Optional[str]:
                     f"but no location returned by Glue."
                 )
             LOGGER.debug(f"{relation.render()} is stored in {table_location}")
-            return table_location
-
+            return str(table_location)
         return None
 
     @available
-    def clean_up_partitions(self, relation: AthenaRelation, where_condition: str):
+    def clean_up_partitions(self, relation: AthenaRelation, where_condition: str) -> None:
         conn = self.connections.get_thread_connection()
         client = conn.handle
 
@@ -242,17 +241,17 @@ def clean_up_partitions(self, relation: AthenaRelation, where_condition: str):
             self.delete_from_s3(partition["StorageDescriptor"]["Location"])
 
     @available
-    def clean_up_table(self, relation: AthenaRelation):
+    def clean_up_table(self, relation: AthenaRelation) -> None:
         table_location = self.get_glue_table_location(relation)
 
-        # this check avoid issues for when the table location is an empty string
-        # or when the table do not exist and table location is None
+        # this check avoids issues for when the table location is an empty string
+        # or when the table does not exist and table location is None
         if table_location:
             self.delete_from_s3(table_location)
 
     @available
     def quote_seed_column(self, column: str, quote_config: Optional[bool]) -> str:
-        return super().quote_seed_column(column, False)
+        return str(super().quote_seed_column(column, False))
 
     @available
     def upload_seed_to_s3(
@@ -283,10 +282,10 @@ def upload_seed_to_s3(
             s3_client.upload_file(tmpfile, bucket, object_name)
             os.remove(tmpfile)
 
-        return s3_location
+        return str(s3_location)
 
     @available
-    def delete_from_s3(self, s3_path: str):
+    def delete_from_s3(self, s3_path: str) -> None:
         """
         Deletes files from s3 given a s3 path in the format: s3://my_bucket/prefix
         Additionally, parses the response from the s3 delete request and raises
@@ -361,7 +360,7 @@ def _join_catalog_table_owners(self, table: agate.Table, manifest: Manifest) ->
             right_key=join_keys,
         )
 
-    def _get_one_table_for_catalog(self, table: dict, database: str) -> list:
+    def _get_one_table_for_catalog(self, table: TableTypeDef, database: str) -> List[Dict[str, Any]]:
         table_catalog = {
             "table_database": database,
             "table_schema": table["DatabaseName"],
@@ -408,7 +407,7 @@ def _get_one_catalog(
 
             for page in paginator.paginate(**kwargs):
                 for table in page["TableList"]:
-                    if table["Name"] in relations:
+                    if relations and table["Name"] in relations:
                         catalog.extend(self._get_one_table_for_catalog(table, information_schema.path.database))
 
         table = agate.Table.from_object(catalog)
@@ -435,17 +434,17 @@ def _get_data_catalog(self, database: str) -> Optional[DataCatalogTypeDef]:
                     sts = client.session.client("sts", region_name=client.region_name, config=get_boto3_config())
                 catalog_id = sts.get_caller_identity()["Account"]
                 return {"Name": database, "Type": "GLUE", "Parameters": {"catalog-id": catalog_id}}
-            else:
-                with boto3_client_lock:
-                    athena = client.session.client("athena", region_name=client.region_name, config=get_boto3_config())
-                return athena.get_data_catalog(Name=database)["DataCatalog"]
+            with boto3_client_lock:
+                athena = client.session.client("athena", region_name=client.region_name, config=get_boto3_config())
+            return athena.get_data_catalog(Name=database)["DataCatalog"]
+        return None
 
     def list_relations_without_caching(self, schema_relation: AthenaRelation) -> List[BaseRelation]:
         data_catalog = self._get_data_catalog(schema_relation.database)
         catalog_id = get_catalog_id(data_catalog)
         if data_catalog and data_catalog["Type"] != "GLUE":
             # For non-Glue Data Catalogs, use the original Athena query against INFORMATION_SCHEMA approach
-            return super().list_relations_without_caching(schema_relation)
+            return super().list_relations_without_caching(schema_relation)  # type: ignore
 
         conn = self.connections.get_thread_connection()
         client = conn.handle
@@ -494,7 +493,7 @@ def list_relations_without_caching(self, schema_relation: AthenaRelation) -> Lis
         return relations
 
     @available
-    def swap_table(self, src_relation: AthenaRelation, target_relation: AthenaRelation):
+    def swap_table(self, src_relation: AthenaRelation, target_relation: AthenaRelation) -> None:
         conn = self.connections.get_thread_connection()
         client = conn.handle
 
@@ -549,7 +548,7 @@ def swap_table(self, src_relation: AthenaRelation, target_relation: AthenaRelati
                     ],
                 )
 
-    def _get_glue_table_versions_to_expire(self, relation: AthenaRelation, to_keep: int):
+    def _get_glue_table_versions_to_expire(self, relation: AthenaRelation, to_keep: int) -> List[TableVersionTypeDef]:
         """
         Given a table and the amount of its version to keep, it returns the versions to delete
         """
@@ -572,7 +571,9 @@ def _get_glue_table_versions_to_expire(self, relation: AthenaRelation, to_keep:
         return table_versions_ordered[int(to_keep) :]
 
     @available
-    def expire_glue_table_versions(self, relation: AthenaRelation, to_keep: int, delete_s3: bool):
+    def expire_glue_table_versions(
+        self, relation: AthenaRelation, to_keep: int, delete_s3: bool
+    ) -> List[TableVersionTypeDef]:
         conn = self.connections.get_thread_connection()
         client = conn.handle
 
@@ -608,7 +609,7 @@ def persist_docs_to_glue(
         model: Dict[str, Any],
         persist_relation_docs: bool = False,
         persist_column_docs: bool = False,
-    ):
+    ) -> None:
         conn = self.connections.get_thread_connection()
         client = conn.handle
 
@@ -666,9 +667,9 @@ def list_schemas(self, database: str) -> List[str]:
         return result
 
     @staticmethod
-    def _is_current_column(col: dict) -> bool:
+    def _is_current_column(col: ColumnTypeDef) -> bool:
         """
-        Check if a column is explicit set as not current. If not, it is considered as current.
+        Check if a column is explicitly set as not current. If not, it is considered as current.
         """
         if col.get("Parameters", {}).get("iceberg.field.current") == "false":
             return False
@@ -704,7 +705,7 @@ def get_columns_in_relation(self, relation: AthenaRelation) -> List[AthenaColumn
         ]
 
     @available
-    def delete_from_glue_catalog(self, relation: AthenaRelation):
+    def delete_from_glue_catalog(self, relation: AthenaRelation) -> None:
         schema_name = relation.schema
         table_name = relation.identifier
 
@@ -736,16 +737,16 @@ def valid_snapshot_target(self, relation: BaseRelation) -> None:
         if "dbt_unique_key" in names:
             sql = self._generate_snapshot_migration_sql(relation=relation, table_columns=table_columns)
             msg = (
-                f"{'!'*90}\n"
+                f"{'!' * 90}\n"
                 "The snapshot logic of dbt-athena has changed in an incompatible way to be more consistent "
                 "with the dbt-core implementation.\nYou will need to migrate your existing snapshot tables to be "
                 "able to keep using them with the latest dbt-athena version.\nYou can find more information "
                 "in the release notes:\nhttps://github.com/dbt-athena/dbt-athena/releases\n"
-                f"{'!'*90}\n\n"
+                f"{'!' * 90}\n\n"
                 "You can use the example query below as a baseline to perform the migration:\n\n"
-                f"{'-'*90}\n"
+                f"{'-' * 90}\n"
                 f"{sql}\n"
-                f"{'-'*90}\n\n"
+                f"{'-' * 90}\n\n"
             )
             LOGGER.error(msg)
             raise SnapshotMigrationRequired("Look into 1.5 dbt-athena docs for the complete migration procedure")
@@ -760,7 +761,7 @@ def _generate_snapshot_migration_sql(self, relation: AthenaRelation, table_colum
         - Copy the content of the staging table to the final table
         - Delete the staging table
         """
-        col_csv = f",\n{' '*16}".join(table_columns)
+        col_csv = f",\n{' ' * 16}".join(table_columns)
         staging_relation = relation.incorporate(
             path={"identifier": relation.identifier + "__dbt_tmp_migration_staging"}
         )
diff --git a/dbt/adapters/athena/lakeformation.py b/dbt/adapters/athena/lakeformation.py
index 043b26d3..cd29e7e6 100644
--- a/dbt/adapters/athena/lakeformation.py
+++ b/dbt/adapters/athena/lakeformation.py
@@ -74,7 +74,11 @@ def _apply_lf_tags_table(
         logger.debug(f"EXISTING TABLE TAGS: {lf_tags_table}")
         logger.debug(f"CONFIG TAGS: {self.lf_tags}")
 
-        to_remove = {tag["TagKey"]: tag["TagValues"] for tag in lf_tags_table if tag["TagKey"] not in self.lf_tags}
+        to_remove = {
+            tag["TagKey"]: tag["TagValues"]
+            for tag in lf_tags_table
+            if tag["TagKey"] not in self.lf_tags  # type: ignore
+        }
         logger.debug(f"TAGS TO REMOVE: {to_remove}")
         if to_remove:
             response = self.lf_client.remove_lf_tags_from_resource(
@@ -105,7 +109,7 @@ def _parse_lf_response(
         self,
         response: Union[AddLFTagsToResourceResponseTypeDef, RemoveLFTagsFromResourceResponseTypeDef],
         columns: Optional[List[str]] = None,
-        lf_tags: Dict[str, str] = None,
+        lf_tags: Optional[Dict[str, str]] = None,
         verb: str = "add",
     ) -> str:
         failures = response.get("Failures", [])
@@ -195,7 +199,7 @@ def process_filters(self, config: LfGrantsConfig) -> None:
         for f in to_update:
             self.lf_client.update_data_cells_filter(TableData=f)
 
-    def process_permissions(self, config: LfGrantsConfig):
+    def process_permissions(self, config: LfGrantsConfig) -> None:
         for name, f in config.data_cell_filters.filters.items():
             logger.debug(f"Start processing permissions for filter: {name}")
             current_permissions = self.lf_client.list_permissions(
diff --git a/dbt/adapters/athena/relation.py b/dbt/adapters/athena/relation.py
index 2d396ff9..bb07393f 100644
--- a/dbt/adapters/athena/relation.py
+++ b/dbt/adapters/athena/relation.py
@@ -32,9 +32,9 @@ class AthenaRelation(BaseRelation):
     include_policy: Policy = field(default_factory=lambda: AthenaIncludePolicy())
     s3_path_table_part: Optional[str] = None
 
-    def render_hive(self):
+    def render_hive(self) -> str:
         """
-        Render relation with Hive format. Athena uses Hive format for some DDL statements.
+        Render relation with Hive format. Athena uses a Hive format for some DDL statements.
 
         See:
         - https://aws.amazon.com/athena/faqs/ "Q: How do I create tables and schemas for my data on Amazon S3?"
@@ -45,9 +45,9 @@ def render_hive(self):
         object.__setattr__(self, "quote_character", "`")  # Hive quote char
         rendered = self.render()
         object.__setattr__(self, "quote_character", old_value)
-        return rendered
+        return str(rendered)
 
-    def render_pure(self):
+    def render_pure(self) -> str:
         """
         Render relation without quotes characters.
         This is needed for not standard executions like optimize and vacuum
@@ -56,20 +56,19 @@ def render_pure(self):
         object.__setattr__(self, "quote_character", "")
         rendered = self.render()
         object.__setattr__(self, "quote_character", old_value)
-        return rendered
+        return str(rendered)
 
 
 class AthenaSchemaSearchMap(Dict[InformationSchema, Dict[str, Set[Optional[str]]]]):
     """A utility class to keep track of what information_schema tables to
     search for what schemas and relations. The schema and relation values are all
-    lowercased to avoid duplication.
+    lowercase to avoid duplication.
     """
 
-    def add(self, relation: AthenaRelation):
+    def add(self, relation: AthenaRelation) -> None:
         key = relation.information_schema_only()
         if key not in self:
             self[key] = {}
-        schema: Optional[str] = None
         if relation.schema is not None:
             schema = relation.schema.lower()
             relation_name = relation.name.lower()
diff --git a/dbt/adapters/athena/utils.py b/dbt/adapters/athena/utils.py
index ee3b20bc..778fb4c2 100644
--- a/dbt/adapters/athena/utils.py
+++ b/dbt/adapters/athena/utils.py
@@ -1,4 +1,4 @@
-from typing import Collection, List, Optional, TypeVar
+from typing import Generator, List, Optional, TypeVar
 
 from mypy_boto3_athena.type_defs import DataCatalogTypeDef
 
@@ -9,14 +9,13 @@ def clean_sql_comment(comment: str) -> str:
 
 
 def get_catalog_id(catalog: Optional[DataCatalogTypeDef]) -> Optional[str]:
-    if catalog:
-        return catalog["Parameters"]["catalog-id"]
+    return catalog["Parameters"]["catalog-id"] if catalog else None
 
 
 T = TypeVar("T")
 
 
-def get_chunks(lst: Collection[T], n: int) -> Collection[List[T]]:
+def get_chunks(lst: List[T], n: int) -> Generator[List[T], None, None]:
     """Yield successive n-sized chunks from lst."""
     for i in range(0, len(lst), n):
         yield lst[i : i + n]
diff --git a/setup.py b/setup.py
index b4ff1191..dae9a695 100644
--- a/setup.py
+++ b/setup.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 import os
 import re
+from typing import Any, Dict
 
 from setuptools import find_namespace_packages, setup
 
@@ -13,7 +14,7 @@
 
 
 # get version from a separate file
-def _get_plugin_version_dict():
+def _get_plugin_version_dict() -> Dict[str, Any]:
     _version_path = os.path.join(this_directory, "dbt", "adapters", "athena", "__version__.py")
     _semver = r"""(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)"""
     _pre = r"""((?P<prekind>a|b|rc)(?P<pre>\d+))?"""
@@ -25,7 +26,7 @@ def _get_plugin_version_dict():
         return match.groupdict()
 
 
-def _get_package_version():
+def _get_package_version() -> str:
     parts = _get_plugin_version_dict()
     return f'{parts["major"]}.{parts["minor"]}.{parts["patch"]}'
 

From ed56cfeae0a01eae4d2ea86a86da5e77f8e62eee Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Jun 2023 14:24:04 +0200
Subject: [PATCH 52/75] chore: Update dbt-tests-adapter requirement from
 ~=1.5.0 to ~=1.5.1 (#325)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 dev-requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev-requirements.txt b/dev-requirements.txt
index c5074ee1..54ef92f8 100644
--- a/dev-requirements.txt
+++ b/dev-requirements.txt
@@ -1,6 +1,6 @@
 autoflake~=1.7
 black~=23.3
-dbt-tests-adapter~=1.5.0
+dbt-tests-adapter~=1.5.1
 flake8~=5.0
 Flake8-pyproject~=1.2
 isort~=5.11

From c24d65ad13b5f2aa549a5edc17c3b05776f6bbed Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Sat, 10 Jun 2023 21:01:01 -0300
Subject: [PATCH 53/75] Fixed readme. Moved some defaults to constants.

---
 .env.example                              |   1 +
 .python-version                           |   1 -
 README.md                                 | 129 +++++++++++++++-------
 dbt/adapters/athena/config.py             |  68 ++++++++++--
 dbt/adapters/athena/constants.py          |   3 +
 dbt/adapters/athena/python_submissions.py |  42 ++++---
 dbt/adapters/athena/session.py            |  20 ++++
 tests/conftest.py                         |   3 +
 tests/unit/constants.py                   |   1 +
 tests/unit/test_session.py                |  12 +-
 10 files changed, 202 insertions(+), 78 deletions(-)
 delete mode 100644 .python-version

diff --git a/.env.example b/.env.example
index 641f3899..68890982 100644
--- a/.env.example
+++ b/.env.example
@@ -7,3 +7,4 @@ DBT_TEST_ATHENA_SCHEMA=
 DBT_TEST_ATHENA_WORK_GROUP=
 DBT_TEST_ATHENA_AWS_PROFILE_NAME=
 DBT_TEST_ATHENA_SPARK_WORK_GROUP=
+DBT_TEST_ATHENA_SPARK_THREADs=
diff --git a/.python-version b/.python-version
deleted file mode 100644
index 1281604a..00000000
--- a/.python-version
+++ /dev/null
@@ -1 +0,0 @@
-3.10.7
diff --git a/README.md b/README.md
index 50a9592b..2a8c3928 100644
--- a/README.md
+++ b/README.md
@@ -6,13 +6,6 @@
     <a href="https://github.com/python/mypy"><img src="https://www.mypy-lang.org/static/mypy_badge.svg" /></a>
     <a href="https://pepy.tech/project/dbt-athena-community"><img src="https://pepy.tech/badge/dbt-athena-community/month" /></a>
 </p>
-<p align="center">
-    <img src="https://raw.githubusercontent.com/dbt-athena/dbt-athena/main/static/images/dbt-athena-long.png" />
-    <a href="https://pypi.org/project/dbt-athena-community/"><img src="https://badge.fury.io/py/dbt-athena-community.svg" /></a>
-    <a href="https://pycqa.github.io/isort/"><img src="https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336" /></a>
-    <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg" /></a>
-    <a href="https://pepy.tech/project/dbt-athena-community"><img src="https://pepy.tech/badge/dbt-athena-community/month" /></a>
-</p>
 
 ## Features
 
@@ -91,8 +84,8 @@ A dbt profile can be configured to run against AWS Athena using the following co
 | aws_profile_name      | Profile to use from your AWS shared credentials file.                          | Optional  | `my-profile`                               |
 | work_group            | Identifier of Athena workgroup                                                 | Optional  | `my-custom-workgroup`                      |
 | num_retries           | Number of times to retry a failing query                                       | Optional  | `3`                                        |
-| lf_tags               | Default lf tags to apply to any database created by dbt                        | Optional  | `{"origin": "dbt", "team": "analytics"}`   |
-| spark_work_group      | Identifier of athena spark workgroup                                           | Optional  | `my-spark-workgroup`                       |
+| spark_work_group      | Identifier of Athena Spark workgroup                                           | Optional  | `my-spark-workgroup`                       |
+| spark_threads         | Number of spark sessions to create. Recommended to be same as threads.         | Optional  | `4`                                        |
 
 **Example profiles.yml entry:**
 ```yaml
@@ -107,12 +100,11 @@ athena:
       region_name: eu-west-1
       schema: dbt
       database: awsdatacatalog
+      threads: 4
       aws_profile_name: my-profile
       work_group: my-workgroup
       spark_work_group: my-spark-workgroup
-      lf_tags:
-        origin: dbt
-        team: analytics
+      spark_threads: 4
 ```
 
 _Additional information_
@@ -391,6 +383,90 @@ You may find the following links useful to manage that:
 - [terraform aws_lakeformation_permissions](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/lakeformation_permissions)
 - [terraform aws_lakeformation_resource_lf_tags](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/lakeformation_resource_lf_tags)
 
+## Python Models
+
+The adapter supports python models using [`spark`](https://docs.aws.amazon.com/athena/latest/ug/notebooks-spark.html).
+
+#### Prerequisites
+
+* A spark enabled work group created in athena
+* Spark execution role granted access to Athena, Glue and S3
+* The spark work group is added to the ~/.dbt/profiles.yml file and the profile is referenced in dbt_project.yml
+* The spark_threads value is added to ~/.dbt/profiles.yml which determines the maximum number of parallel spark sessions that will be created. It is recommended to keep this same as threads.
+
+### Example models
+
+#### Simple pandas model
+
+```python
+import pandas as pd
+
+
+def model(dbt, session):
+    dbt.config(materialized="table")
+
+    model_df = pd.DataFrame({"A": [1, 2, 3, 4]})
+
+    return model_df
+```
+
+#### Simple spark
+
+```python
+def model(dbt, spark_session):
+    dbt.config(materialized="table")
+
+    data = [(1,), (2,), (3,), (4,)]
+
+    df = spark_session.createDataFrame(data, ["A"])
+
+    return df
+```
+
+#### Spark incremental
+
+```python
+def model(dbt, spark_session):
+    dbt.config(materialized="incremental")
+    df = dbt.ref("model")
+
+    if dbt.is_incremental:
+        max_from_this = (
+            f"select max(run_date) from {dbt.this.schema}.{dbt.this.identifier}"
+        )
+        df = df.filter(df.run_date >= spark_session.sql(max_from_this).collect()[0][0])
+
+    return df
+```
+
+#### Config spark model
+
+```python
+def model(dbt, spark_session):
+    dbt.config(
+        materialized="table",
+        engine_config={
+            "CoordinatorDpuSize": 1,
+            "MaxConcurrentDpus": 3,
+            "DefaultExecutorDpuSize": 1,
+        },
+        polling_interval=15,
+        timeout=120,
+    )
+
+    data = [(1,), (2,), (3,), (4,)]
+
+    df = spark_session.createDataFrame(data, ["A"])
+
+    return df
+```
+
+#### Known issues in python models
+
+* Incremental models do not fully utilize spark capabilities. They depend partially on existing sql based logic.
+* Snapshots materializations are not supported.
+* Spark can only reference tables within the same catalog.
+
 ### Working example
 
 seed file - employent_indicators_november_2022_csv_tables.csv
@@ -498,35 +574,6 @@ The only way, from a dbt perspective, is to do a full-refresh of the incremental
 
 * Snapshot does not support dropping columns from the source table. If you drop a column make sure to drop the column from the snapshot as well. Another workaround is to NULL the column in the snapshot definition to preserve history
 
-### Python Models
-
-The adapter supports python models using [`spark`](https://docs.aws.amazon.com/athena/latest/ug/notebooks-spark.html).
-
-#### Prerequisites
-
-* A spark enabled work group created in athena
-* Spark execution role granted access to Athena, Glue and S3
-* The spark work group is added to the ~/.dbt/profiles.yml file and the profile is referenced in dbt_project.yml
-
-#### Example model
-
-```python
-import pandas as pd
-
-
-def model(dbt, session):
-    dbt.config(materialized="table")
-
-    model_df = pd.DataFrame({"A": [1, 2, 3, 4]})
-
-    return model_df
-```
-
-#### Known issues in python models
-
-* Incremental models do not fully utilize spark capabilities. They depend on existing sql based logic.
-* Snapshots materializations are not supported.
-
 
 ## Contracts
 
diff --git a/dbt/adapters/athena/config.py b/dbt/adapters/athena/config.py
index 8e5aff39..595e9a1f 100644
--- a/dbt/adapters/athena/config.py
+++ b/dbt/adapters/athena/config.py
@@ -3,11 +3,12 @@
 import pkg_resources
 from botocore import config
 
-from dbt.adapters.athena.constants import LOGGER
-
-DEFAULT_POLLING_INTERVAL = 5
-DEFAULT_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
-DEFAULT_TIMEOUT = 60 * 60 * 2
+from dbt.adapters.athena.constants import (
+    DEFAULT_POLLING_INTERVAL,
+    DEFAULT_SPARK_ENGINE_CONFIG,
+    DEFAULT_SPARK_SESSION_TIMEOUT,
+    LOGGER,
+)
 
 
 @lru_cache()
@@ -22,8 +23,13 @@ class AthenaSparkSessionConfig:
     A helper class to manage Athena Spark Session Configuration.
     """
 
+<<<<<<< HEAD
     def __init__(self, config: dict) -> None:
+=======
+    def __init__(self, config: Dict[str, Any], **session_kwargs: Any) -> None:
+>>>>>>> 5f40faf (Fixed readme. Moved some defaults to constants.)
         self.config = config
+        self.session_kwargs = session_kwargs
 
     def set_timeout(self) -> int:
         """
@@ -40,7 +46,7 @@ def set_timeout(self) -> int:
             ValueError: If the timeout value is not a positive integer.
 
         """
-        timeout = self.config.get("timeout", DEFAULT_TIMEOUT)
+        timeout = self.config.get("timeout", DEFAULT_SPARK_SESSION_TIMEOUT)
         if not isinstance(timeout, int):
             raise TypeError("Timeout must be an integer")
         if timeout <= 0:
@@ -48,15 +54,57 @@ def set_timeout(self) -> int:
         LOGGER.debug(f"Setting timeout: {timeout}")
         return timeout
 
+    def get_polling_interval(self) -> Any:
+        """
+        Get the polling interval for the configuration.
+
+        Returns:
+            Any: The polling interval value.
+
+        Raises:
+            KeyError: If the polling interval is not found in either `self.config`
+                or `self.session_kwargs`.
+        """
+        try:
+            return self.config["polling_interval"]
+        except KeyError:
+            try:
+                return self.session_kwargs["polling_interval"]
+            except KeyError:
+                return DEFAULT_POLLING_INTERVAL
+
     def set_polling_interval(self) -> float:
-        polling_interval = self.config.get("polling_interval", DEFAULT_POLLING_INTERVAL)
-        if not isinstance(polling_interval, int) or polling_interval <= 0:
-            raise ValueError("Polling_interval must be a positive integer")
+        """
+        Set the polling interval for the configuration.
+
+        Returns:
+            float: The polling interval value.
+
+        Raises:
+            ValueError: If the polling interval is not a positive integer.
+        """
+        polling_interval = self.get_polling_interval()
+        if not (isinstance(polling_interval, float) or isinstance(polling_interval, int)) or polling_interval <= 0:
+            raise ValueError(f"Polling_interval must be a positive number. Got: {polling_interval}")
         LOGGER.debug(f"Setting polling_interval: {polling_interval}")
-        return polling_interval
+        return float(polling_interval)
 
+<<<<<<< HEAD
     def set_engine_config(self) -> dict:
         engine_config = self.config.get("engine_config", DEFAULT_ENGINE_CONFIG)
+=======
+    def set_engine_config(self) -> Dict[str, Any]:
+        """Set the engine configuration.
+
+        Returns:
+            Dict[str, Any]: The engine configuration.
+
+        Raises:
+            TypeError: If the engine configuration is not of type dict.
+            KeyError: If the keys of the engine configuration dictionary do not match the expected format.
+        """
+        engine_config = self.config.get("engine_config", DEFAULT_SPARK_ENGINE_CONFIG)
+>>>>>>> 5f40faf (Fixed readme. Moved some defaults to constants.)
         if not isinstance(engine_config, dict):
             raise TypeError("Engine configuration has to be of type dict")
 
diff --git a/dbt/adapters/athena/constants.py b/dbt/adapters/athena/constants.py
index df6bd86b..b2d9b7e1 100644
--- a/dbt/adapters/athena/constants.py
+++ b/dbt/adapters/athena/constants.py
@@ -2,5 +2,8 @@
 
 DEFAULT_THREAD_COUNT = 4
 DEFAULT_RETRY_ATTEMPTS = 3
+DEFAULT_POLLING_INTERVAL = 5
+DEFAULT_SPARK_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+DEFAULT_SPARK_SESSION_TIMEOUT = 15 * 60
 
 LOGGER = AdapterLogger(__name__)
diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index e4dc2b2e..4119b7b1 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -16,35 +16,23 @@
 
 class AthenaPythonJobHelper(PythonJobHelper):
     """
-     A helper class for executing Python jobs on AWS Athena.
-
-    This class extends the base `PythonJobHelper` class and provides additional functionality
-    specific to executing jobs on Athena. It takes a parsed model and credentials as inputs
-    during initialization, and provides methods for executing Athena jobs, setting timeout,
-    polling interval, region name, AWS profile name, and Spark work group.
+    Default helper to execute python models with Athena Spark.
 
     Args:
-        parsed_model (Dict): A dictionary representing the parsed model of the Athena job.
-            It should contain keys such as 'alias' for job identifier and 'schema' for
-            job schema.
-        credentials (AthenaCredentials): An instance of the `AthenaCredentials` class
-            containing AWS credentials for accessing Athena.
-
-    Attributes:
-        identifier (str): A string representing the alias or identifier of the Athena job.
-        schema (str): A string representing the schema of the Athena job.
-        parsed_model (Dict): A dictionary representing the parsed model of the Athena job.
-        timeout (int): An integer representing the timeout value in seconds for the Athena job.
-        polling_interval (int): An integer representing the polling interval in seconds for
-            checking the status of the Athena job.
-        region_name (str): A string representing the AWS region name for executing the Athena job.
-        profile_name (str): A string representing the AWS profile name for accessing Athena.
-        spark_work_group (str): A string representing the Spark work group for executing the Athena job.
-
+        PythonJobHelper (PythonJobHelper): The base python helper class
     """
 
+<<<<<<< HEAD
     def __init__(self, parsed_model: Dict, credentials: AthenaCredentials) -> None:
         self.config = AthenaSparkSessionConfig(parsed_model.get("config", {}))
+=======
+    def __init__(self, parsed_model: Dict[Any, Any], credentials: AthenaCredentials) -> None:
+        self.config = AthenaSparkSessionConfig(
+            parsed_model.get("config", {}),
+            polling_interval=credentials.poll_interval,
+            retry_attempts=credentials.num_retries,
+        )
+>>>>>>> 5f40faf (Fixed readme. Moved some defaults to constants.)
         self.spark_connection = AthenaSparkSessionManager(
             credentials, self.timeout, self.polling_interval, self.engine_config
         )
@@ -70,7 +58,15 @@ def polling_interval(self) -> float:
     def engine_config(self) -> Dict[str, int]:
         return self.config.set_engine_config()
 
+<<<<<<< HEAD
     def get_current_session_status(self) -> Dict[str, Any]:
+=======
+    @cached_property
+    def athena_client(self) -> Any:
+        return self.spark_connection.athena_client
+
+    def get_current_session_status(self) -> Any:
+>>>>>>> 5f40faf (Fixed readme. Moved some defaults to constants.)
         """
         Get the current session status.
 
diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index 2068fc42..76e536a9 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -43,7 +43,11 @@ def get_max_session_count(self):
 
     def get_spark_work_group(self):
         if not self.credentials.spark_work_group:
+<<<<<<< HEAD
             raise DbtRuntimeError("Expected spark_work_group in profile")
+=======
+            raise DbtRuntimeError(f"Expected spark_work_group in profile. Got: {self.credentials.spark_work_group}")
+>>>>>>> 5f40faf (Fixed readme. Moved some defaults to constants.)
         return self.credentials.spark_work_group
 
     def get_athena_client(self):
@@ -72,6 +76,17 @@ def get_new_sessions(self) -> List[UUID]:
         sessions = self.list_sessions()
         existing_sessions = set(spark_session_locks.keys())
         new_sessions = [session for session in sessions if session not in existing_sessions]
+<<<<<<< HEAD
+=======
+
+        if len(new_sessions) == 0:
+            if len(spark_session_locks) < self.spark_threads:
+                return [self.start_session()]
+            LOGGER.warning(
+                f"""Maximum spark session count: {self.spark_threads} reached.
+            Cannot start new spark session."""
+            )
+>>>>>>> 5f40faf (Fixed readme. Moved some defaults to constants.)
         LOGGER.debug(f"Setting sessions: {new_sessions}")
         return new_sessions
 
@@ -138,6 +153,7 @@ def list_sessions(self, state: str = "IDLE") -> List[UUID]:
             MaxResults=max_results,
             StateFilter=state,
         )
+<<<<<<< HEAD
         if len(response.get("Sessions")) == 0 or response.get("Sessions") is None:
             if len(spark_session_locks) < max_results:
                 return [self.start_session()]
@@ -145,6 +161,10 @@ def list_sessions(self, state: str = "IDLE") -> List[UUID]:
                 f"""Maximum spark session count: {max_results} reached.
             Cannot start new spark session."""
             )
+=======
+        if response.get("Sessions") is None:
+            return []
+>>>>>>> 5f40faf (Fixed readme. Moved some defaults to constants.)
         return [UUID(session_string["SessionId"]) for session_string in response.get("Sessions")]
 
     def start_session(self) -> UUID:
diff --git a/tests/conftest.py b/tests/conftest.py
index 9fa88df2..3ca4d14a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -17,6 +17,7 @@
     DATA_CATALOG_NAME,
     DATABASE_NAME,
     S3_STAGING_DIR,
+    SPARK_THREADS,
     SPARK_WORKGROUP,
 )
 
@@ -41,6 +42,7 @@ def dbt_profile_target():
         "work_group": os.getenv("DBT_TEST_ATHENA_WORK_GROUP"),
         "aws_profile_name": os.getenv("DBT_TEST_ATHENA_AWS_PROFILE_NAME") or None,
         "spark_work_group": os.getenv("DBT_TEST_ATHENA_SPARK_WORK_GROUP"),
+        "spark_threads": os.getenv("DBT_TEST_ATHENA_SPARK_THREADS"),
     }
 
 
@@ -82,4 +84,5 @@ def athena_credentials():
         region_name=AWS_REGION,
         work_group=ATHENA_WORKGROUP,
         spark_work_group=SPARK_WORKGROUP,
+        spark_threads=SPARK_THREADS,
     )
diff --git a/tests/unit/constants.py b/tests/unit/constants.py
index 21bac432..51deab6f 100644
--- a/tests/unit/constants.py
+++ b/tests/unit/constants.py
@@ -7,3 +7,4 @@
 S3_STAGING_DIR = "s3://my-bucket/test-dbt/"
 ATHENA_WORKGROUP = "dbt-athena-adapter"
 SPARK_WORKGROUP = "spark"
+SPARK_THREADS = 4
diff --git a/tests/unit/test_session.py b/tests/unit/test_session.py
index cd4681fb..49d910c8 100644
--- a/tests/unit/test_session.py
+++ b/tests/unit/test_session.py
@@ -96,7 +96,11 @@ def spark_session_manager(self, athena_credentials, athena_client, monkeypatch):
                 {
                     "Sessions": [],
                 },
-                [UUID("635c1c6d-766c-408b-8bce-fae8ea7006f7")],
+                [],
+            ),
+            (
+                {},
+                [],
             ),
         ],
     )
@@ -238,12 +242,12 @@ def test_get_session_status(self, session_status_response, expected_status, spar
             (
                 [],
                 {},
-                [],
+                [UUID("39cb8fc0-f855-4b67-91f1-81f068499071")],
             ),
             (
                 [UUID("106d7aca-4b3f-468d-a81d-308120e7f73c")],
                 {UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): "lock"},
-                [],
+                [UUID("39cb8fc0-f855-4b67-91f1-81f068499071")],
             ),
         ],
     )
@@ -277,6 +281,8 @@ def test_get_sessions(
         with patch.multiple(
             spark_session_manager,
             list_sessions=Mock(return_value=list_sessions_response),
+            poll_until_session_creation=Mock(return_value="IDLE"),
+            start_session=Mock(return_value=UUID("39cb8fc0-f855-4b67-91f1-81f068499071")),
         ):
             sessions = spark_session_manager.get_new_sessions()
             assert sessions == expected_new_sessions

From 209e02c28c016f594887569c26d759565e4c6bd3 Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Wed, 14 Jun 2023 01:08:06 -0300
Subject: [PATCH 54/75] Add more docs and functional tests.

---
 dbt/adapters/athena/python_submissions.py     | 36 ++++----
 dbt/adapters/athena/session.py                | 64 +++++++++----
 .../models/incremental/incremental.sql        | 50 +++++------
 .../adapter/test_python_submissions.py        | 89 +++++++++++++++++++
 4 files changed, 176 insertions(+), 63 deletions(-)
 create mode 100644 tests/functional/adapter/test_python_submissions.py

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 1f3df90f..8acd2e6a 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -24,11 +24,11 @@ class AthenaPythonJobHelper(PythonJobHelper):
 
     def __init__(self, parsed_model: Dict[Any, Any], credentials: AthenaCredentials) -> None:
         """
-        _summary_
+        Initialize spark config and connection.
 
         Args:
-            parsed_model (Dict[Any, Any]): _description_
-            credentials (AthenaCredentials): _description_
+            parsed_model (Dict[Any, Any]): The parsed python model.
+            credentials (AthenaCredentials): Credentials for Athena connection.
         """
         self.config = AthenaSparkSessionConfig(
             parsed_model.get("config", {}),
@@ -42,50 +42,50 @@ def __init__(self, parsed_model: Dict[Any, Any], credentials: AthenaCredentials)
     @cached_property
     def timeout(self) -> int:
         """
-        _summary_
+        Get the timeout value.
 
         Returns:
-            int: _description_
+            int: The timeout value in seconds.
         """
         return self.config.set_timeout()
 
     @cached_property
     def session_id(self) -> str:
         """
-        _summary_
+        Get the session ID.
 
         Returns:
-            str: _description_
+            str: The session ID as a string.
         """
         return str(self.spark_connection.get_session_id())
 
     @cached_property
     def polling_interval(self) -> float:
         """
-        _summary_
+        Get the polling interval.
 
         Returns:
-            float: _description_
+            float: The polling interval in seconds.
         """
         return self.config.set_polling_interval()
 
     @cached_property
     def engine_config(self) -> Dict[str, int]:
         """
-        _summary_
+        Get the engine configuration.
 
         Returns:
-            Dict[str, int]: _description_
+            Dict[str, int]: A dictionary containing the engine configuration.
         """
         return self.config.set_engine_config()
 
     @cached_property
     def athena_client(self) -> Any:
         """
-        _summary_
+        Get the Athena client.
 
         Returns:
-            Any: _description_
+            Any: The Athena client object.
         """
         return self.spark_connection.athena_client
 
@@ -94,11 +94,17 @@ def get_current_session_status(self) -> Any:
         Get the current session status.
 
         Returns:
-            str: The status of the session
+            Any: The status of the session
         """
         return self.spark_connection.get_session_status(self.session_id)
 
     def poll_until_session_idle(self) -> None:
+        """
+        Polls the session status until it becomes idle or exceeds the timeout.
+
+        Raises:
+            DbtRuntimeError: If the session chosen is not available or if it does not become idle within the timeout.
+        """
         polling_interval = self.polling_interval
         while True:
             session_status = self.get_current_session_status()["State"]
@@ -117,7 +123,7 @@ def submit(self, compiled_code: str) -> Any:
 
         This function submits a calculation to Athena for execution using the provided compiled code.
         It starts a calculation execution with the current session ID and the compiled code as the code block.
-        The function then polls until the calculation execution is completed, and retrieves the result S3 URI.
+        The function then polls until the calculation execution is completed, and retrieves the result.
         If the execution is successful and completed, the result S3 URI is returned. Otherwise, a DbtRuntimeError
         is raised with the execution status.
 
diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index 5754924e..fb5a9fac 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -30,6 +30,16 @@ class AthenaSparkSessionManager:
     """
 
     def __init__(self, credentials: Any, timeout: int, polling_interval: float, engine_config: Dict[str, int]) -> None:
+        """
+        Initialize the AthenaSparkSessionManager instance.
+
+        Args:
+            credentials (Any): The credentials to be used.
+            timeout (int): The timeout value in seconds.
+            polling_interval (float): The polling interval in seconds.
+            engine_config (Dict[str, int]): The engine configuration.
+
+        """
         self.credentials = credentials
         self.timeout = timeout
         self.polling_interval = polling_interval
@@ -37,20 +47,32 @@ def __init__(self, credentials: Any, timeout: int, polling_interval: float, engi
         self.lock = threading.Lock()
 
     @cached_property
-    def spark_threads(self) -> Any:
+    def spark_threads(self) -> int:
+        """
+        Get the number of Spark threads.
+
+        Returns:
+            Any: The number of Spark threads. If not found in the profile, returns the default thread count.
+        """
         if not self.credentials.spark_threads:
             LOGGER.debug(
                 f"""Spark threads not found in profile. Got: {self.credentials.spark_threads}.
                 Using default count: {DEFAULT_THREAD_COUNT}"""
             )
             return DEFAULT_THREAD_COUNT
-        return self.credentials.spark_threads
+        return int(self.credentials.spark_threads)
 
     @cached_property
-    def spark_work_group(self) -> Any:
+    def spark_work_group(self) -> str:
+        """
+        Get the Spark work group.
+
+        Returns:
+            Any: The Spark work group. Raises an exception if not found in the profile.
+        """
         if not self.credentials.spark_work_group:
             raise DbtRuntimeError(f"Expected spark_work_group in profile. Got: {self.credentials.spark_work_group}")
-        return self.credentials.spark_work_group
+        return str(self.credentials.spark_work_group)
 
     @cached_property
     def athena_client(self) -> Any:
@@ -71,6 +93,8 @@ def athena_client(self) -> Any:
     def get_new_sessions(self) -> List[UUID]:
         """
         Retrieves a list of new sessions by subtracting the existing sessions from the complete session list.
+        If no new sessions are found a new session is created provided the number of sessions is less than the
+        number of allowed spark threads.
 
         Returns:
             List[UUID]: A list of new session UUIDs.
@@ -95,8 +119,7 @@ def update_spark_session_locks(self) -> None:
         Update session locks for each session.
 
         This function iterates over the existing sessions and ensures that a session lock is created for each session.
-        If a session lock already exists, it is left unchanged. After updating the session locks,
-        a debug log is generated to display the updated session locks.
+        If a session lock already exists, it is left unchanged.
 
         Args:
             self: The instance of the class.
@@ -110,13 +133,15 @@ def update_spark_session_locks(self) -> None:
 
     def get_session_id(self) -> UUID:
         """
-        Get the session ID.
-
-        This function retrieves the session ID from the stored session information. If session information
-        is not available, a new session is started and its session ID is returned.
+        Get a session ID for the Spark session.
 
         Returns:
-            str: The session ID.
+            UUID: The session ID.
+
+        Notes:
+            This method acquires a lock on an existing available Spark session. If no session is available,
+            it waits for a certain period and retries until a session becomes available or a timeout is reached.
+            The session ID of the acquired session is returned.
 
         """
         polling_interval = self.polling_interval
@@ -136,15 +161,18 @@ def get_session_id(self) -> UUID:
 
     def list_sessions(self, state: str = "IDLE") -> List[UUID]:
         """
-        List athena spark sessions.
+        List the sessions based on the specified state.
 
-        This function sends a request to the Athena service to list the sessions in the specified Spark workgroup.
-        It filters the sessions by state, only returning the first session that is in IDLE state. If no idle sessions
-        are found or if an error occurs, None is returned.
+        Args:
+            state (str, optional): The state to filter the sessions. Defaults to "IDLE".
 
         Returns:
-            List[UUID]: A list of session UUIDs if an idle sessions are found, else start a new session and return
-            the list of the returned session id.
+            List[UUID]: A list of session IDs matching the specified state.
+
+        Notes:
+            This method utilizes the Athena client to list sessions in the Spark work group.
+            The sessions are filtered based on the provided state.
+            If no sessions are found or the response does not contain any sessions, an empty list is returned.
 
         """
         response = self.athena_client.list_sessions(
@@ -232,6 +260,6 @@ def get_session_status(self, session_id: str) -> Any:
         Get the session status.
 
         Returns:
-            str: The status of the session
+            Any: The status of the session
         """
         return self.athena_client.get_session_status(SessionId=session_id)["Status"]
diff --git a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
index b9c2a7e4..7cfc06d4 100644
--- a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
+++ b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
@@ -1,8 +1,8 @@
 {% materialization incremental, adapter='athena', supported_languages=['sql', 'python'] -%}
-  {%- set language = model['language'] -%}
 
   {% set raw_strategy = config.get('incremental_strategy') or 'insert_overwrite' %}
   {% set table_type = config.get('table_type', default='hive') | lower %}
+  {% set model_language = model['language'] %}
   {% set strategy = validate_get_incremental_strategy(raw_strategy, table_type) %}
   {% set on_schema_change = incremental_validate_on_schema_change(config.get('on_schema_change'), default='ignore') %}
 
@@ -13,8 +13,6 @@
   {% set existing_relation = load_relation(this) %}
   {% set tmp_relation = make_temp_relation(this) %}
 
-  {{ log("temporary relation is" ~ tmp_relation.schema ~ tmp_relation.identifier)}}
-
   -- If no partitions are used with insert_overwrite, we fall back to append mode.
   {% if partitioned_by is none and strategy == 'insert_overwrite' %}
     {% set strategy = 'append' %}
@@ -27,26 +25,20 @@
 
   {% set to_drop = [] %}
   {% if existing_relation is none %}
-    {% call statement('save_table', language=language) -%}
-        {{ create_table_as(False, target_relation, compiled_code, language) }}
-    {%- endcall %}
-    {% set build_sql = None %}
+    {% set build_sql = create_table_as(False, target_relation, compiled_code, model_language) -%}
   {% elif existing_relation.is_view or should_full_refresh() %}
     {% do drop_relation(existing_relation) %}
-    {% call statement('save_table', language=language) -%}
-        {{ create_table_as(False, target_relation, compiled_code, language) }}
-    {%- endcall %}
-    {% set build_sql = None %}
+    {% set build_sql = create_table_as(False, target_relation, compiled_code, model_language) -%}
   {% elif partitioned_by is not none and strategy == 'insert_overwrite' %}
     {% set tmp_relation = make_temp_relation(target_relation) %}
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% if language == 'sql' %}
-      {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% if model_language == "sql" %}
+      {% do run_query(create_table_as(True, tmp_relation, compiled_code, model_language)) %}
     {% else %}
-      {% call statement('save_table', language=language) -%}
-          {{ create_table_as(True, tmp_relation, compiled_code, language) }}
+      {% call statement('py_save_table', language=model_language) -%}
+        {{ create_table_as(False, target_relation, compiled_code, model_language) }}
       {%- endcall %}
     {% endif %}
     {% do delete_overlapping_partitions(target_relation, tmp_relation, partitioned_by) %}
@@ -57,11 +49,11 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% if language == 'sql' %}
-      {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% if model_language == "sql" %}
+      {% do run_query(create_table_as(True, tmp_relation, compiled_code, model_language)) %}
     {% else %}
-      {% call statement('save_table', language=language) -%}
-          {{ create_table_as(True, tmp_relation, compiled_code, language) }}
+      {% call statement('py_save_table', language=model_language) -%}
+        {{ create_table_as(False, target_relation, compiled_code, model_language) }}
       {%- endcall %}
     {% endif %}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
@@ -80,30 +72,28 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% if language == 'sql' %}
-      {% do run_query(create_table_as(True, tmp_relation, compiled_code, language)) %}
+    {% if model_language == "sql" %}
+      {% do run_query(create_table_as(True, tmp_relation, compiled_code, model_language)) %}
     {% else %}
-      {% call statement('save_table', language=language) -%}
-          {{ create_table_as(True, tmp_relation, compiled_code, language) }}
+      {% call statement('py_save_table', language=model_language) -%}
+        {{ create_table_as(False, target_relation, compiled_code, model_language) }}
       {%- endcall %}
     {% endif %}
     {% set build_sql = iceberg_merge(on_schema_change, tmp_relation, target_relation, unique_key, existing_relation, delete_condition) %}
     {% do to_drop.append(tmp_relation) %}
   {% endif %}
 
-  {% call statement("main", language=language) %}
-    {% if language == 'sql' %}
+  {% call statement("main", language=model_language) %}
+    {% if model_language == 'sql' %}
       {{ build_sql }}
     {% else %}
-      {% if build_sql %}
-          {{ log(build_sql) }}
-          {% do athena__py_execute_query(query=build_sql) %}
-      {% endif %}
+      {{ log(build_sql) }}
+      {% do athena__py_execute_query(query=build_sql) %}
     {% endif %}
   {% endcall %}
 
   -- set table properties
-  {% if not to_drop and table_type != 'iceberg' %}
+  {% if not to_drop and table_type != 'iceberg' and model_language != 'python' %}
     {{ set_table_classification(target_relation) }}
   {% endif %}
 
diff --git a/tests/functional/adapter/test_python_submissions.py b/tests/functional/adapter/test_python_submissions.py
new file mode 100644
index 00000000..4011bc97
--- /dev/null
+++ b/tests/functional/adapter/test_python_submissions.py
@@ -0,0 +1,89 @@
+import pytest
+import yaml
+
+from dbt.tests.adapter.python_model.test_python_model import (
+    BasePythonIncrementalTests,
+    BasePythonModelTests,
+)
+from dbt.tests.util import run_dbt
+
+basic_sql = """
+{{ config(materialized="table") }}
+select 1 as column_1, 2 as column_2, '{{ run_started_at.strftime("%Y-%m-%d") }}' as run_date
+"""
+
+basic_python = """
+def model(dbt, spark):
+    dbt.config(
+        materialized='table',
+    )
+    df =  dbt.ref("model")
+    return df
+"""
+
+basic_spark_python = """
+def model(dbt, spark_session):
+    dbt.config(materialized="table")
+
+    data = [(1,), (2,), (3,), (4,)]
+
+    df = spark_session.createDataFrame(data, ["A"])
+
+    return df
+"""
+
+second_sql = """
+select * from {{ref('my_python_model')}}
+"""
+
+schema_yml = """version: 2
+models:
+  - name: model
+    versions:
+      - v: 1
+"""
+
+
+class TestBasePythonModelTests(BasePythonModelTests):
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "schema.yml": schema_yml,
+            "model.sql": basic_sql,
+            "my_python_model.py": basic_python,
+            "spark_model.py": basic_spark_python,
+            "second_sql_model.sql": second_sql,
+        }
+
+
+incremental_python = """
+def model(dbt, spark_session):
+    dbt.config(materialized="incremental")
+    df = dbt.ref("model")
+
+    if dbt.is_incremental:
+        max_from_this = (
+            f"select max(run_date) from {dbt.this.schema}.{dbt.this.identifier}"
+        )
+        df = df.filter(df.run_date >= spark_session.sql(max_from_this).collect()[0][0])
+
+    return df
+"""
+
+
+class TestBasePythonIncrementalTests(BasePythonIncrementalTests):
+    @pytest.fixture(scope="class")
+    def project_config_update(self):
+        return {"models": {"+incremental_strategy": "append"}}
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {"model.sql": basic_sql, "incremental.py": incremental_python}
+
+    def test_incremental(self, project):
+        vars_dict = {
+            "test_run_schema": project.test_schema,
+        }
+
+        results = run_dbt(["run", "--vars", yaml.safe_dump(vars_dict)])
+        assert len(results) == 2

From f56c2e84860ea3e6c71665e1cd3cd6a2a8eb6eed Mon Sep 17 00:00:00 2001
From: Personal <personal@1Passwords-MacBook-Pro.local>
Date: Thu, 28 Sep 2023 07:43:13 -0400
Subject: [PATCH 55/75] Used default logger

---
 dbt/adapters/athena/connections.py   |  2 ++
 dbt/adapters/athena/lakeformation.py | 38 +++++++++++++---------------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index c639abf7..4c0b57d1 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -35,6 +35,8 @@
 from dbt.adapters.sql import SQLConnectionManager
 from dbt.contracts.connection import AdapterResponse, Connection, ConnectionState
 from dbt.exceptions import ConnectionError, DbtRuntimeError
+from dbt.events import AdapterLogger
+
 
 logger = AdapterLogger("Athena")
 
diff --git a/dbt/adapters/athena/lakeformation.py b/dbt/adapters/athena/lakeformation.py
index 9fc8047b..bae370cb 100644
--- a/dbt/adapters/athena/lakeformation.py
+++ b/dbt/adapters/athena/lakeformation.py
@@ -14,11 +14,9 @@
 from pydantic import BaseModel
 
 from dbt.adapters.athena.relation import AthenaRelation
-from dbt.events import AdapterLogger
+from dbt.adapters.athena.constants import LOGGER
 from dbt.exceptions import DbtRuntimeError
 
-logger = AdapterLogger("AthenaLakeFormation")
-
 
 class LfTagsConfig(BaseModel):
     enabled: bool = False
@@ -51,7 +49,7 @@ def process_lf_tags(self) -> None:
 
     def _remove_lf_tags_columns(self, existing_lf_tags: GetResourceLFTagsResponseTypeDef) -> None:
         lf_tags_columns = existing_lf_tags.get("LFTagsOnColumns", [])
-        logger.debug(f"COLUMNS: {lf_tags_columns}")
+        LOGGER.debug(f"COLUMNS: {lf_tags_columns}")
         if lf_tags_columns:
             to_remove = {}
             for column in lf_tags_columns:
@@ -64,7 +62,7 @@ def _remove_lf_tags_columns(self, existing_lf_tags: GetResourceLFTagsResponseTyp
                         to_remove[tag_key][tag_value] = [column["Name"]]
                     else:
                         to_remove[tag_key][tag_value].append(column["Name"])
-            logger.debug(f"TO REMOVE: {to_remove}")
+            LOGGER.debug(f"TO REMOVE: {to_remove}")
             for tag_key, tag_config in to_remove.items():
                 for tag_value, columns in tag_config.items():
                     resource = {
@@ -79,15 +77,15 @@ def _apply_lf_tags_table(
         self, table_resource: ResourceTypeDef, existing_lf_tags: GetResourceLFTagsResponseTypeDef
     ) -> None:
         lf_tags_table = existing_lf_tags.get("LFTagsOnTable", [])
-        logger.debug(f"EXISTING TABLE TAGS: {lf_tags_table}")
-        logger.debug(f"CONFIG TAGS: {self.lf_tags}")
+        LOGGER.debug(f"EXISTING TABLE TAGS: {lf_tags_table}")
+        LOGGER.debug(f"CONFIG TAGS: {self.lf_tags}")
 
         to_remove = {
             tag["TagKey"]: tag["TagValues"]
             for tag in lf_tags_table
             if tag["TagKey"] not in self.lf_tags  # type: ignore
         }
-        logger.debug(f"TAGS TO REMOVE: {to_remove}")
+        LOGGER.debug(f"TAGS TO REMOVE: {to_remove}")
         if to_remove:
             response = self.lf_client.remove_lf_tags_from_resource(
                 Resource=table_resource, LFTags=[{"TagKey": k, "TagValues": v} for k, v in to_remove.items()]
@@ -128,9 +126,9 @@ def _parse_and_log_lf_response(
             for failure in failures:
                 tag = failure.get("LFTag", {}).get("TagKey")
                 error = failure.get("Error", {}).get("ErrorMessage")
-                logger.error(f"Failed to {verb} {tag} for " + resource_msg + f" - {error}")
+                LOGGER.error(f"Failed to {verb} {tag} for " + resource_msg + f" - {error}")
             raise DbtRuntimeError(base_msg)
-        logger.debug(f"Success: {verb} LF tags {lf_tags} to " + resource_msg)
+        LOGGER.debug(f"Success: {verb} LF tags {lf_tags} to " + resource_msg)
 
 
 class FilterConfig(BaseModel):
@@ -178,10 +176,10 @@ def get_filters(self) -> Dict[str, DataCellsFilterTypeDef]:
 
     def process_filters(self, config: LfGrantsConfig) -> None:
         current_filters = self.get_filters()
-        logger.debug(f"CURRENT FILTERS: {current_filters}")
+        LOGGER.debug(f"CURRENT FILTERS: {current_filters}")
 
         to_drop = [f for name, f in current_filters.items() if name not in config.data_cell_filters.filters]
-        logger.debug(f"FILTERS TO DROP: {to_drop}")
+        LOGGER.debug(f"FILTERS TO DROP: {to_drop}")
         for f in to_drop:
             self.lf_client.delete_data_cells_filter(
                 TableCatalogId=f["TableCatalogId"],
@@ -195,7 +193,7 @@ def process_filters(self, config: LfGrantsConfig) -> None:
             for name, f in config.data_cell_filters.filters.items()
             if name not in current_filters
         ]
-        logger.debug(f"FILTERS TO ADD: {to_add}")
+        LOGGER.debug(f"FILTERS TO ADD: {to_add}")
         for f in to_add:
             self.lf_client.create_data_cells_filter(TableData=f)
 
@@ -204,13 +202,13 @@ def process_filters(self, config: LfGrantsConfig) -> None:
             for name, f in config.data_cell_filters.filters.items()
             if name in current_filters and f.to_update(current_filters[name])
         ]
-        logger.debug(f"FILTERS TO UPDATE: {to_update}")
+        LOGGER.debug(f"FILTERS TO UPDATE: {to_update}")
         for f in to_update:
             self.lf_client.update_data_cells_filter(TableData=f)
 
     def process_permissions(self, config: LfGrantsConfig) -> None:
         for name, f in config.data_cell_filters.filters.items():
-            logger.debug(f"Start processing permissions for filter: {name}")
+            LOGGER.debug(f"Start processing permissions for filter: {name}")
             current_permissions = self.lf_client.list_permissions(
                 Resource={
                     "DataCellsFilter": {
@@ -231,9 +229,9 @@ def process_permissions(self, config: LfGrantsConfig) -> None:
                     Entries=[self._permission_entry(name, principal, idx) for idx, principal in enumerate(to_revoke)],
                 )
                 revoke_principals_msg = "\n".join(to_revoke)
-                logger.debug(f"Revoked permissions for filter {name} from principals:\n{revoke_principals_msg}")
+                LOGGER.debug(f"Revoked permissions for filter {name} from principals:\n{revoke_principals_msg}")
             else:
-                logger.debug(f"No redundant permissions found for filter: {name}")
+                LOGGER.debug(f"No redundant permissions found for filter: {name}")
 
             to_add = {p for p in f.principals if p not in current_principals}
             if to_add:
@@ -242,11 +240,11 @@ def process_permissions(self, config: LfGrantsConfig) -> None:
                     Entries=[self._permission_entry(name, principal, idx) for idx, principal in enumerate(to_add)],
                 )
                 add_principals_msg = "\n".join(to_add)
-                logger.debug(f"Granted permissions for filter {name} to principals:\n{add_principals_msg}")
+                LOGGER.debug(f"Granted permissions for filter {name} to principals:\n{add_principals_msg}")
             else:
-                logger.debug(f"No new permissions added for filter {name}")
+                LOGGER.debug(f"No new permissions added for filter {name}")
 
-            logger.debug(f"Permissions are set to be consistent with config for filter: {name}")
+            LOGGER.debug(f"Permissions are set to be consistent with config for filter: {name}")
 
     def _permission_entry(self, filter_name: str, principal: str, idx: int) -> BatchPermissionsRequestEntryTypeDef:
         return {

From 81d499a1f9f1c717bcba1717f0a59bb5b2357872 Mon Sep 17 00:00:00 2001
From: Personal <personal@1Passwords-MacBook-Pro.local>
Date: Thu, 28 Sep 2023 07:44:03 -0400
Subject: [PATCH 56/75] Used default logger

---
 dbt/adapters/athena/connections.py | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index 4c0b57d1..cf506011 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -35,10 +35,6 @@
 from dbt.adapters.sql import SQLConnectionManager
 from dbt.contracts.connection import AdapterResponse, Connection, ConnectionState
 from dbt.exceptions import ConnectionError, DbtRuntimeError
-from dbt.events import AdapterLogger
-
-
-logger = AdapterLogger("Athena")
 
 
 @dataclass
@@ -118,7 +114,7 @@ def _poll(self, query_id: str) -> AthenaQueryExecution:
             query_execution = self.__poll(query_id)
         except KeyboardInterrupt as e:
             if self._kill_on_interrupt:
-                logger.warning("Query canceled by user.")
+                LOGGER.warning("Query canceled by user.")
                 self._cancel(query_id)
                 query_execution = self.__poll(query_id)
             else:
@@ -136,7 +132,7 @@ def __poll(self, query_id: str) -> AthenaQueryExecution:
                 return query_execution
             else:
                 if self.connection.cursor_kwargs.get("debug_query_state", False):
-                    logger.debug(f"Query state is: {query_execution.state}. Sleeping for {self._poll_interval}...")
+                    LOGGER.debug(f"Query state is: {query_execution.state}. Sleeping for {self._poll_interval}...")
                 time.sleep(self._poll_interval)
 
     def execute(  # type: ignore
@@ -279,7 +275,7 @@ def process_query_stats(cursor: AthenaCursor) -> Tuple[int, int]:
                     stats = json.loads("{" + query_stats.group(1) + "}")
                     return stats.get("rowcount", -1), stats.get("data_scanned_in_bytes", 0)
             except Exception as err:
-                logger.debug(f"There was an error parsing query stats {err}")
+                LOGGER.debug(f"There was an error parsing query stats {err}")
                 return -1, 0
         return cursor.rowcount, cursor.data_scanned_in_bytes
 

From 213ee656930fb1a93e8468be465ff4052e06b984 Mon Sep 17 00:00:00 2001
From: Personal <personal@1Passwords-MacBook-Pro.local>
Date: Thu, 28 Sep 2023 07:47:54 -0400
Subject: [PATCH 57/75] Fix isort

---
 dbt/adapters/athena/lakeformation.py | 2 +-
 tests/unit/test_config.py            | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbt/adapters/athena/lakeformation.py b/dbt/adapters/athena/lakeformation.py
index bae370cb..d0ffbc5d 100644
--- a/dbt/adapters/athena/lakeformation.py
+++ b/dbt/adapters/athena/lakeformation.py
@@ -13,8 +13,8 @@
 )
 from pydantic import BaseModel
 
-from dbt.adapters.athena.relation import AthenaRelation
 from dbt.adapters.athena.constants import LOGGER
+from dbt.adapters.athena.relation import AthenaRelation
 from dbt.exceptions import DbtRuntimeError
 
 
diff --git a/tests/unit/test_config.py b/tests/unit/test_config.py
index 54775d10..00c374a6 100644
--- a/tests/unit/test_config.py
+++ b/tests/unit/test_config.py
@@ -1,5 +1,6 @@
 import importlib.metadata
 from unittest.mock import Mock
+
 import pytest
 
 from dbt.adapters.athena.config import AthenaSparkSessionConfig, get_boto3_config

From ea38eeef3d0e7d755803df5d4c60b3f9bf0ebdbf Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Tue, 10 Oct 2023 09:54:53 -0400
Subject: [PATCH 58/75] Support additional arguments for create_table_as with
 dispatch. Call python code only from main call due to core restriction.

---
 .../macros/adapters/python_submissions.sql    | 58 ++++++-------
 .../models/incremental/incremental.sql        | 25 ++++++
 .../models/table/create_table_as.sql          | 86 ++++++++++---------
 .../materializations/models/table/table.sql   | 12 ++-
 4 files changed, 104 insertions(+), 77 deletions(-)

diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index bf389e4a..fbf1633b 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -16,33 +16,30 @@ import pyspark
 {{ compiled_code }}
 def materialize(spark_session, df, target_relation):
     import pandas
-    try:
-        if isinstance(df, pyspark.sql.dataframe.DataFrame):
-            pass
-        elif isinstance(df, pandas.core.frame.DataFrame):
-            df = spark_session.createDataFrame(df)
-        else:
-            msg = f"{type(df)} is not a supported type for dbt Python materialization"
-            raise Exception(msg)
-        writer = df.write \
-        .format("{{ format }}") \
-        .mode("{{ mode }}") \
-        .option("path", "{{ location }}") \
-        .option("compression", "{{ write_compression }}") \
-        .option("mergeSchema", "{{ merge_schema }}") \
-        .option("delimiter", "{{ field_delimiter }}")
-        if {{ partitioned_by }} is not None:
-            writer = writer.partitionBy({{ partitioned_by }})
-        if {{ bucketed_by }} is not None:
-            writer = writer.bucketBy({{ bucket_count }},{{ bucketed_by }})
-        if {{ sorted_by }} is not None:
-            writer = writer.sortBy({{ sorted_by }})
-        writer.saveAsTable(
-            name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
-        )
-        return "OK"
-    except Exception:
-        raise
+    if isinstance(df, pyspark.sql.dataframe.DataFrame):
+        pass
+    elif isinstance(df, pandas.core.frame.DataFrame):
+        df = spark_session.createDataFrame(df)
+    else:
+        msg = f"{type(df)} is not a supported type for dbt Python materialization"
+        raise Exception(msg)
+    writer = df.write \
+    .format("{{ format }}") \
+    .mode("{{ mode }}") \
+    .option("path", "{{ location }}") \
+    .option("compression", "{{ write_compression }}") \
+    .option("mergeSchema", "{{ merge_schema }}") \
+    .option("delimiter", "{{ field_delimiter }}")
+    if {{ partitioned_by }} is not None:
+        writer = writer.partitionBy({{ partitioned_by }})
+    if {{ bucketed_by }} is not None:
+        writer = writer.bucketBy({{ bucket_count }},{{ bucketed_by }})
+    if {{ sorted_by }} is not None:
+        writer = writer.sortBy({{ sorted_by }})
+    writer.saveAsTable(
+        name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
+    )
+    return "OK"
 
 {{ athena__py_get_spark_dbt_object() }}
 
@@ -55,11 +52,8 @@ materialize(spark, df, dbt.this)
 {{ athena__py_get_spark_dbt_object() }}
 
 def execute_query(spark_session):
-    try:
-        spark_session.sql("""{{ query }}""")
-        return "OK"
-    except Exception:
-        raise
+    spark_session.sql("""{{ query }}""")
+    return "OK"
 
 dbt = SparkdbtObj()
 execute_query(spark)
diff --git a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
index f3c1d793..0d0335ad 100644
--- a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
+++ b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
@@ -26,10 +26,20 @@
   {% set to_drop = [] %}
   {% if existing_relation is none %}
     {% set query_result = safe_create_table_as(False, target_relation, compiled_code, language=model_language) -%}
+    {%- if model_language == 'python' -%}
+      {% call statement('create_table', language=model_language) %}
+        {{ query_result }}
+      {% endcall %}
+    {%- endif -%}
     {% set build_sql = "select '" ~ query_result ~ "'" -%}
   {% elif existing_relation.is_view or should_full_refresh() %}
     {% do drop_relation(existing_relation) %}
     {% set query_result = safe_create_table_as(False, target_relation, compiled_code, language=model_language) -%}
+    {%- if model_language == 'python' -%}
+      {% call statement('create_table', language=model_language) %}
+        {{ query_result }}
+      {% endcall %}
+    {%- endif -%}
     {% set build_sql = "select '" ~ query_result ~ "'" -%}
   {% elif partitioned_by is not none and strategy == 'insert_overwrite' %}
     {% set tmp_relation = make_temp_relation(target_relation) %}
@@ -37,6 +47,11 @@
       {% do drop_relation(tmp_relation) %}
     {% endif %}
     {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, language=model_language) -%}
+    {%- if model_language == 'python' -%}
+      {% call statement('create_table', language=model_language) %}
+        {{ query_result }}
+      {% endcall %}
+    {%- endif -%}
     {% do delete_overlapping_partitions(target_relation, tmp_relation, partitioned_by) %}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
@@ -46,6 +61,11 @@
       {% do drop_relation(tmp_relation) %}
     {% endif %}
     {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, language=model_language) -%}
+    {%- if model_language == 'python' -%}
+      {% call statement('create_table', language=model_language) %}
+        {{ query_result }}
+      {% endcall %}
+    {%- endif -%}
     {% set build_sql = incremental_insert(on_schema_change, tmp_relation, target_relation, existing_relation) %}
     {% do to_drop.append(tmp_relation) %}
   {% elif strategy == 'merge' and table_type == 'iceberg' %}
@@ -72,6 +92,11 @@
       {% do drop_relation(tmp_relation) %}
     {% endif %}
     {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, language=model_language) -%}
+    {%- if model_language == 'python' -%}
+      {% call statement('create_table', language=model_language) %}
+        {{ query_result }}
+      {% endcall %}
+    {%- endif -%}
     {% set build_sql = iceberg_merge(
         on_schema_change=on_schema_change,
         tmp_relation=tmp_relation,
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index d1b305e4..f5d0e4ce 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -1,6 +1,12 @@
-{% macro athena__create_table_as(temporary, relation, compiled_code, skip_partitioning=False, language='sql') -%}
+{% macro create_table_as(temporary, relation, compiled_code, language='sql', skip_partitioning=false) -%}
+  {{ adapter.dispatch('create_table_as', 'athena')(temporary, relation, compiled_code, language, skip_partitioning) }}
+{%- endmacro %}
+
+
+{% macro athena__create_table_as(temporary, relation, compiled_code, language='sql', skip_partitioning=false) -%}
   {%- set materialized = config.get('materialized', default='table') -%}
   {%- set external_location = config.get('external_location', default=none) -%}
+  {%- do log("Skip partitioning: " ~ skip_partitioning) -%}
   {%- set partitioned_by = config.get('partitioned_by', default=none) if not skip_partitioning else none -%}
   {%- set bucketed_by = config.get('bucketed_by', default=none) -%}
   {%- set bucket_count = config.get('bucket_count', default=none) -%}
@@ -53,19 +59,36 @@
   {%- else -%}
     {% do adapter.delete_from_s3(location) %}
   {%- endif -%}
-  {%- if language == 'sql' -%}
+  {%- if language == 'python' -%}
+    {% do log('Creating table with spark and compiled code: ' ~ compiled_code) %}
+    {{ athena__py_save_table_as(
+        compiled_code,
+        relation,
+        optional_args={
+          'location': location,
+          'format': format,
+          'mode': 'overwrite',
+          'partitioned_by': partitioned_by,
+          'bucketed_by': bucketed_by,
+          'write_compression': write_compression,
+          'bucket_count': bucket_count,
+          'field_delimiter': field_delimiter
+        }
+      )
+    }}
+  {%- else -%}
     create table {{ relation }}
     with (
       table_type='{{ table_type }}',
       is_external={%- if table_type == 'iceberg' -%}false{%- else -%}true{%- endif %},
-      {%- if not work_group_output_location_enforced or table_type == 'iceberg' -%}
-        {{ location_property }}='{{ location }}',
-      {%- endif %}
+    {%- if not work_group_output_location_enforced or table_type == 'iceberg' -%}
+      {{ location_property }}='{{ location }}',
+    {%- endif %}
     {%- if partitioned_by is not none %}
-      {{ partition_property }}=ARRAY{{ partitioned_by | join("', '") | replace('"', "'") | prepend("'") | append("'") }},
+      {{ partition_property }}=ARRAY{{ partitioned_by | tojson | replace('\"', '\'') }},
     {%- endif %}
     {%- if bucketed_by is not none %}
-      bucketed_by=ARRAY{{ bucketed_by | join("', '") | replace('"', "'") | prepend("'") | append("'") }},
+      bucketed_by=ARRAY{{ bucketed_by | tojson | replace('\"', '\'') }},
     {%- endif %}
     {%- if bucket_count is not none %}
       bucket_count={{ bucket_count }},
@@ -86,24 +109,6 @@
     )
     as
       {{ compiled_code }}
-  {%- elif language == 'python' -%}
-    {{ athena__py_save_table_as(
-        compiled_code,
-        relation,
-        optional_args={
-          'location': location,
-          'format': format,
-          'mode': 'overwrite',
-          'partitioned_by': partitioned_by,
-          'bucketed_by': bucketed_by,
-          'write_compression': write_compression,
-          'bucket_count': bucket_count,
-          'field_delimiter': field_delimiter
-        }
-      )
-    }}
-  {%- else -%}
-    {% do exceptions.raise_compiler_error("athena__create_table_as macro doesn't support the provided language, it got %s" % language) %}
   {%- endif -%}
 {%- endmacro -%}
 
@@ -123,7 +128,7 @@
     {%- endif -%}
 
     {%- do log('CREATE NON-PARTIONED STAGING TABLE: ' ~ tmp_relation) -%}
-    {%- do run_query(create_table_as(temporary, tmp_relation, compiled_code, True, language=language)) -%}
+    {%- do run_query(create_table_as(temporary, tmp_relation, compiled_code, language, true)) -%}
 
     {% set partitions_batches = get_partition_batches(sql=tmp_relation, as_subquery=False) %}
     {% do log('BATCHES TO PROCESS: ' ~ partitions_batches | length) %}
@@ -140,7 +145,7 @@
                 from {{ tmp_relation }}
                 where {{ batch }}
             {%- endset -%}
-            {%- do run_query(create_table_as(temporary, relation, create_target_relation_sql, language=language)) -%}
+            {%- do run_query(create_table_as(temporary, relation, create_target_relation_sql, language)) -%}
         {%- else -%}
             {%- set insert_batch_partitions_sql -%}
                 insert into {{ relation }} ({{ dest_cols_csv }})
@@ -163,22 +168,19 @@
 
 {% macro safe_create_table_as(temporary, relation, compiled_code, language='sql') -%}
     {%- if language != 'sql' -%}
-        {% call statement('py_save_table', language=language) -%}
-            {{ create_table_as(temporary, relation, compiled_code, language=language) }}
-        {%- endcall %}
-        {%- set compiled_code_result = relation ~ ' created with spark' -%}
-    {%- endif -%}
-    {%- if temporary -%}
-      {%- do run_query(create_table_as(temporary, relation, compiled_code, True, language=language)) -%}
-      {%- set compiled_code_result = relation ~ ' as temporary relation without partitioning created' -%}
+        {{ return(create_table_as(temporary, relation, compiled_code, language)) }}
     {%- else -%}
-      {%- set compiled_code_result = adapter.run_query_with_partitions_limit_catching(create_table_as(temporary, relation, compiled_code, language=language)) -%}
-      {%- do log('COMPILED CODE RESULT: ' ~ compiled_code_result) -%}
-      {%- if compiled_code_result == 'TOO_MANY_OPEN_PARTITIONS' -%}
-        {%- do create_table_as_with_partitions(temporary, relation, compiled_code, language=language) -%}
-        {%- set compiled_code_result = relation ~ ' with many partitions created' -%}
-      {%- endif -%}
+        {%- if temporary -%}
+          {%- do run_query(create_table_as(temporary, relation, compiled_code, language, true)) -%}
+          {%- set compiled_code_result = relation ~ ' as temporary relation without partitioning created' -%}
+        {%- else -%}
+          {%- set compiled_code_result = adapter.run_query_with_partitions_limit_catching(create_table_as(temporary, relation, compiled_code)) -%}
+          {%- do log('COMPILED CODE RESULT: ' ~ compiled_code_result) -%}
+          {%- if compiled_code_result == 'TOO_MANY_OPEN_PARTITIONS' -%}
+            {%- do create_table_as_with_partitions(temporary, relation, compiled_code, language) -%}
+            {%- set compiled_code_result = relation ~ ' with many partitions created' -%}
+          {%- endif -%}
+        {%- endif -%}
     {%- endif -%}
-
     {{ return(compiled_code_result) }}
 {%- endmacro %}
diff --git a/dbt/include/athena/macros/materializations/models/table/table.sql b/dbt/include/athena/macros/materializations/models/table/table.sql
index 8471a33e..03e7beaa 100644
--- a/dbt/include/athena/macros/materializations/models/table/table.sql
+++ b/dbt/include/athena/macros/materializations/models/table/table.sql
@@ -68,7 +68,9 @@
       {%- set query_result = safe_create_table_as(False, target_relation, compiled_code, language=language) -%}
     {%- endif -%}
 
-    {{ set_table_classification(target_relation) }}
+    {%- if language != 'python' -%}
+      {{ set_table_classification(target_relation) }}
+    {%- endif -%}
 
   {%- else -%}
 
@@ -105,8 +107,12 @@
 
   {%- endif -%}
 
-  {% call statement("main") %}
-    SELECT '{{ query_result }}';
+  {% call statement("main", language=language) %}
+    {%- if language=='sql' -%}
+      SELECT '{{ query_result }}';
+    {%- else -%}
+      {{ query_result }}
+    {%- endif -%}
   {% endcall %}
 
   {{ run_hooks(post_hooks) }}

From 5060ae5c8cbad27ce67f912841b2076e96906512 Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Tue, 10 Oct 2023 10:55:27 -0400
Subject: [PATCH 59/75] Provide language as argument instead of kwarg. Reduce
 diff in connections aftr merge

---
 dbt/adapters/athena/connections.py                     |  7 +++----
 .../models/incremental/incremental.sql                 | 10 +++++-----
 .../macros/materializations/models/table/table.sql     |  8 ++++----
 3 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index 1d46acb8..16d893f8 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -132,10 +132,9 @@ def __poll(self, query_id: str) -> AthenaQueryExecution:
                 AthenaQueryExecution.STATE_CANCELLED,
             ]:
                 return query_execution
-            else:
-                if self.connection.cursor_kwargs.get("debug_query_state", False):
-                    LOGGER.debug(f"Query state is: {query_execution.state}. Sleeping for {self._poll_interval}...")
-                time.sleep(self._poll_interval)
+            if self.connection.cursor_kwargs.get("debug_query_state", False):
+                LOGGER.debug(f"Query state is: {query_execution.state}. Sleeping for {self._poll_interval}...")
+            time.sleep(self._poll_interval)
 
     def execute(  # type: ignore
         self,
diff --git a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
index 0d0335ad..4a057ba2 100644
--- a/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
+++ b/dbt/include/athena/macros/materializations/models/incremental/incremental.sql
@@ -25,7 +25,7 @@
 
   {% set to_drop = [] %}
   {% if existing_relation is none %}
-    {% set query_result = safe_create_table_as(False, target_relation, compiled_code, language=model_language) -%}
+    {% set query_result = safe_create_table_as(False, target_relation, compiled_code, model_language) -%}
     {%- if model_language == 'python' -%}
       {% call statement('create_table', language=model_language) %}
         {{ query_result }}
@@ -34,7 +34,7 @@
     {% set build_sql = "select '" ~ query_result ~ "'" -%}
   {% elif existing_relation.is_view or should_full_refresh() %}
     {% do drop_relation(existing_relation) %}
-    {% set query_result = safe_create_table_as(False, target_relation, compiled_code, language=model_language) -%}
+    {% set query_result = safe_create_table_as(False, target_relation, compiled_code, model_language) -%}
     {%- if model_language == 'python' -%}
       {% call statement('create_table', language=model_language) %}
         {{ query_result }}
@@ -46,7 +46,7 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, language=model_language) -%}
+    {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, model_language) -%}
     {%- if model_language == 'python' -%}
       {% call statement('create_table', language=model_language) %}
         {{ query_result }}
@@ -60,7 +60,7 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, language=model_language) -%}
+    {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, model_language) -%}
     {%- if model_language == 'python' -%}
       {% call statement('create_table', language=model_language) %}
         {{ query_result }}
@@ -91,7 +91,7 @@
     {% if tmp_relation is not none %}
       {% do drop_relation(tmp_relation) %}
     {% endif %}
-    {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, language=model_language) -%}
+    {% set query_result = safe_create_table_as(True, tmp_relation, compiled_code, model_language) -%}
     {%- if model_language == 'python' -%}
       {% call statement('create_table', language=model_language) %}
         {{ query_result }}
diff --git a/dbt/include/athena/macros/materializations/models/table/table.sql b/dbt/include/athena/macros/materializations/models/table/table.sql
index 03e7beaa..cda3822f 100644
--- a/dbt/include/athena/macros/materializations/models/table/table.sql
+++ b/dbt/include/athena/macros/materializations/models/table/table.sql
@@ -65,7 +65,7 @@
       {%- if old_relation is not none -%}
         {{ drop_relation(old_relation) }}
       {%- endif -%}
-      {%- set query_result = safe_create_table_as(False, target_relation, compiled_code, language=language) -%}
+      {%- set query_result = safe_create_table_as(False, target_relation, compiled_code, language) -%}
     {%- endif -%}
 
     {%- if language != 'python' -%}
@@ -75,10 +75,10 @@
   {%- else -%}
 
     {%- if old_relation is none -%}
-      {%- set query_result = safe_create_table_as(False, target_relation, compiled_code, language=language) -%}
+      {%- set query_result = safe_create_table_as(False, target_relation, compiled_code, language) -%}
     {%- else -%}
       {%- if old_relation.is_view -%}
-        {%- set query_result = safe_create_table_as(False, tmp_relation, compiled_code, language=language) -%}
+        {%- set query_result = safe_create_table_as(False, tmp_relation, compiled_code, language) -%}
         {%- do drop_relation(old_relation) -%}
         {%- do rename_relation(tmp_relation, target_relation) -%}
       {%- else -%}
@@ -96,7 +96,7 @@
           {%- do drop_relation(old_relation_bkp) -%}
         {%- endif -%}
 
-        {% set query_result = safe_create_table_as(False, tmp_relation, compiled_code, language=language) %}
+        {% set query_result = safe_create_table_as(False, tmp_relation, compiled_code, language) %}
 
         {{ rename_relation(old_relation, old_relation_bkp) }}
         {{ rename_relation(tmp_relation, target_relation) }}

From 88e8e441d59e96e62a921b3ef6cfe51f705d53f8 Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Tue, 10 Oct 2023 11:41:51 -0400
Subject: [PATCH 60/75] Restore diff in connections and fix functional test for
 constraint

---
 dbt/adapters/athena/connections.py           | 7 ++++---
 tests/functional/adapter/test_constraints.py | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index 16d893f8..1d46acb8 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -132,9 +132,10 @@ def __poll(self, query_id: str) -> AthenaQueryExecution:
                 AthenaQueryExecution.STATE_CANCELLED,
             ]:
                 return query_execution
-            if self.connection.cursor_kwargs.get("debug_query_state", False):
-                LOGGER.debug(f"Query state is: {query_execution.state}. Sleeping for {self._poll_interval}...")
-            time.sleep(self._poll_interval)
+            else:
+                if self.connection.cursor_kwargs.get("debug_query_state", False):
+                    LOGGER.debug(f"Query state is: {query_execution.state}. Sleeping for {self._poll_interval}...")
+                time.sleep(self._poll_interval)
 
     def execute(  # type: ignore
         self,
diff --git a/tests/functional/adapter/test_constraints.py b/tests/functional/adapter/test_constraints.py
index 9295f681..71a7d3a3 100644
--- a/tests/functional/adapter/test_constraints.py
+++ b/tests/functional/adapter/test_constraints.py
@@ -23,4 +23,4 @@ def expected_sql(self):
 
         # NOTE: by the above reason, this test just checks the query can be executed without errors.
         #       The query itself is not checked.
-        return 'SELECT \'{"rowcount":1,"data_scanned_in_bytes":0}\';'
+        return 'SELECT \'{"rowcount":-1,"data_scanned_in_bytes":0}\';'

From 855bd6ddeb50029096466766fd1dcef712fdec80 Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Tue, 10 Oct 2023 12:33:45 -0400
Subject: [PATCH 61/75] Restore test_constraint

---
 tests/functional/adapter/test_constraints.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/functional/adapter/test_constraints.py b/tests/functional/adapter/test_constraints.py
index 71a7d3a3..9295f681 100644
--- a/tests/functional/adapter/test_constraints.py
+++ b/tests/functional/adapter/test_constraints.py
@@ -23,4 +23,4 @@ def expected_sql(self):
 
         # NOTE: by the above reason, this test just checks the query can be executed without errors.
         #       The query itself is not checked.
-        return 'SELECT \'{"rowcount":-1,"data_scanned_in_bytes":0}\';'
+        return 'SELECT \'{"rowcount":1,"data_scanned_in_bytes":0}\';'

From 8153d20ea329896287b1fe411c01d4f81d92620d Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Tue, 10 Oct 2023 12:37:43 -0400
Subject: [PATCH 62/75] Disable python functional test until spark work group
 is added and IAM is modified

---
 .../adapter/test_python_submissions.py        | 178 +++++++++---------
 1 file changed, 89 insertions(+), 89 deletions(-)

diff --git a/tests/functional/adapter/test_python_submissions.py b/tests/functional/adapter/test_python_submissions.py
index 4011bc97..671f587f 100644
--- a/tests/functional/adapter/test_python_submissions.py
+++ b/tests/functional/adapter/test_python_submissions.py
@@ -1,89 +1,89 @@
-import pytest
-import yaml
-
-from dbt.tests.adapter.python_model.test_python_model import (
-    BasePythonIncrementalTests,
-    BasePythonModelTests,
-)
-from dbt.tests.util import run_dbt
-
-basic_sql = """
-{{ config(materialized="table") }}
-select 1 as column_1, 2 as column_2, '{{ run_started_at.strftime("%Y-%m-%d") }}' as run_date
-"""
-
-basic_python = """
-def model(dbt, spark):
-    dbt.config(
-        materialized='table',
-    )
-    df =  dbt.ref("model")
-    return df
-"""
-
-basic_spark_python = """
-def model(dbt, spark_session):
-    dbt.config(materialized="table")
-
-    data = [(1,), (2,), (3,), (4,)]
-
-    df = spark_session.createDataFrame(data, ["A"])
-
-    return df
-"""
-
-second_sql = """
-select * from {{ref('my_python_model')}}
-"""
-
-schema_yml = """version: 2
-models:
-  - name: model
-    versions:
-      - v: 1
-"""
-
-
-class TestBasePythonModelTests(BasePythonModelTests):
-    @pytest.fixture(scope="class")
-    def models(self):
-        return {
-            "schema.yml": schema_yml,
-            "model.sql": basic_sql,
-            "my_python_model.py": basic_python,
-            "spark_model.py": basic_spark_python,
-            "second_sql_model.sql": second_sql,
-        }
-
-
-incremental_python = """
-def model(dbt, spark_session):
-    dbt.config(materialized="incremental")
-    df = dbt.ref("model")
-
-    if dbt.is_incremental:
-        max_from_this = (
-            f"select max(run_date) from {dbt.this.schema}.{dbt.this.identifier}"
-        )
-        df = df.filter(df.run_date >= spark_session.sql(max_from_this).collect()[0][0])
-
-    return df
-"""
-
-
-class TestBasePythonIncrementalTests(BasePythonIncrementalTests):
-    @pytest.fixture(scope="class")
-    def project_config_update(self):
-        return {"models": {"+incremental_strategy": "append"}}
-
-    @pytest.fixture(scope="class")
-    def models(self):
-        return {"model.sql": basic_sql, "incremental.py": incremental_python}
-
-    def test_incremental(self, project):
-        vars_dict = {
-            "test_run_schema": project.test_schema,
-        }
-
-        results = run_dbt(["run", "--vars", yaml.safe_dump(vars_dict)])
-        assert len(results) == 2
+# import pytest
+# import yaml
+
+# from dbt.tests.adapter.python_model.test_python_model import (
+#     BasePythonIncrementalTests,
+#     BasePythonModelTests,
+# )
+# from dbt.tests.util import run_dbt
+
+# basic_sql = """
+# {{ config(materialized="table") }}
+# select 1 as column_1, 2 as column_2, '{{ run_started_at.strftime("%Y-%m-%d") }}' as run_date
+# """
+
+# basic_python = """
+# def model(dbt, spark):
+#     dbt.config(
+#         materialized='table',
+#     )
+#     df =  dbt.ref("model")
+#     return df
+# """
+
+# basic_spark_python = """
+# def model(dbt, spark_session):
+#     dbt.config(materialized="table")
+
+#     data = [(1,), (2,), (3,), (4,)]
+
+#     df = spark_session.createDataFrame(data, ["A"])
+
+#     return df
+# """
+
+# second_sql = """
+# select * from {{ref('my_python_model')}}
+# """
+
+# schema_yml = """version: 2
+# models:
+#   - name: model
+#     versions:
+#       - v: 1
+# """
+
+
+# class TestBasePythonModelTests(BasePythonModelTests):
+#     @pytest.fixture(scope="class")
+#     def models(self):
+#         return {
+#             "schema.yml": schema_yml,
+#             "model.sql": basic_sql,
+#             "my_python_model.py": basic_python,
+#             "spark_model.py": basic_spark_python,
+#             "second_sql_model.sql": second_sql,
+#         }
+
+
+# incremental_python = """
+# def model(dbt, spark_session):
+#     dbt.config(materialized="incremental")
+#     df = dbt.ref("model")
+
+#     if dbt.is_incremental:
+#         max_from_this = (
+#             f"select max(run_date) from {dbt.this.schema}.{dbt.this.identifier}"
+#         )
+#         df = df.filter(df.run_date >= spark_session.sql(max_from_this).collect()[0][0])
+
+#     return df
+# """
+
+
+# class TestBasePythonIncrementalTests(BasePythonIncrementalTests):
+#     @pytest.fixture(scope="class")
+#     def project_config_update(self):
+#         return {"models": {"+incremental_strategy": "append"}}
+
+#     @pytest.fixture(scope="class")
+#     def models(self):
+#         return {"model.sql": basic_sql, "incremental.py": incremental_python}
+
+#     def test_incremental(self, project):
+#         vars_dict = {
+#             "test_run_schema": project.test_schema,
+#         }
+
+#         results = run_dbt(["run", "--vars", yaml.safe_dump(vars_dict)])
+#         assert len(results) == 2

From 1effdbcd53a92abe6b1b2a7b1f6143ce2caf1c50 Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Tue, 10 Oct 2023 13:39:49 -0400
Subject: [PATCH 63/75] Reduce diff in connections

---
 dbt/adapters/athena/connections.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index 1d46acb8..158a4adc 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -132,10 +132,10 @@ def __poll(self, query_id: str) -> AthenaQueryExecution:
                 AthenaQueryExecution.STATE_CANCELLED,
             ]:
                 return query_execution
-            else:
-                if self.connection.cursor_kwargs.get("debug_query_state", False):
-                    LOGGER.debug(f"Query state is: {query_execution.state}. Sleeping for {self._poll_interval}...")
-                time.sleep(self._poll_interval)
+
+            if self.connection.cursor_kwargs.get("debug_query_state", False):
+                LOGGER.debug(f"Query state is: {query_execution.state}. Sleeping for {self._poll_interval}...")
+            time.sleep(self._poll_interval)
 
     def execute(  # type: ignore
         self,

From 9edb519c3a5c09061ade34467cdb862f2a9c828d Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Thu, 23 Nov 2023 08:57:51 -0500
Subject: [PATCH 64/75] Break engine config into three variables

---
 dbt/adapters/athena/config.py    | 13 +++++++++++--
 dbt/adapters/athena/constants.py |  4 +++-
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/dbt/adapters/athena/config.py b/dbt/adapters/athena/config.py
index b3d8f984..456afe3b 100644
--- a/dbt/adapters/athena/config.py
+++ b/dbt/adapters/athena/config.py
@@ -6,7 +6,9 @@
 
 from dbt.adapters.athena.constants import (
     DEFAULT_POLLING_INTERVAL,
-    DEFAULT_SPARK_ENGINE_CONFIG,
+    DEFAULT_SPARK_COORDINATOR_DPU_SIZE,
+    DEFAULT_SPARK_EXECUTOR_DPU_SIZE,
+    DEFAULT_SPARK_MAX_CONCURRENT_DPUS,
     DEFAULT_SPARK_SESSION_TIMEOUT,
     LOGGER,
 )
@@ -97,7 +99,14 @@ def set_engine_config(self) -> Dict[str, Any]:
             TypeError: If the engine configuration is not of type dict.
             KeyError: If the keys of the engine configuration dictionary do not match the expected format.
         """
-        engine_config = self.config.get("engine_config", DEFAULT_SPARK_ENGINE_CONFIG)
+        engine_config = self.config.get(
+            "engine_config",
+            {
+                "CoordinatorDpuSize": DEFAULT_SPARK_COORDINATOR_DPU_SIZE,
+                "MaxConcurrentDpus": DEFAULT_SPARK_MAX_CONCURRENT_DPUS,
+                "DefaultExecutorDpuSize": DEFAULT_SPARK_EXECUTOR_DPU_SIZE,
+            },
+        )
         if not isinstance(engine_config, dict):
             raise TypeError("Engine configuration has to be of type dict")
 
diff --git a/dbt/adapters/athena/constants.py b/dbt/adapters/athena/constants.py
index b2d9b7e1..2b7e9ddd 100644
--- a/dbt/adapters/athena/constants.py
+++ b/dbt/adapters/athena/constants.py
@@ -3,7 +3,9 @@
 DEFAULT_THREAD_COUNT = 4
 DEFAULT_RETRY_ATTEMPTS = 3
 DEFAULT_POLLING_INTERVAL = 5
-DEFAULT_SPARK_ENGINE_CONFIG = {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
+DEFAULT_SPARK_COORDINATOR_DPU_SIZE = 1
+DEFAULT_SPARK_MAX_CONCURRENT_DPUS = 2
+DEFAULT_SPARK_EXECUTOR_DPU_SIZE = 1
 DEFAULT_SPARK_SESSION_TIMEOUT = 15 * 60
 
 LOGGER = AdapterLogger(__name__)

From eb2d92d4fface9c1346c33f7de5d44fb6e996214 Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Thu, 23 Nov 2023 12:04:19 -0500
Subject: [PATCH 65/75] Add method to create session from credentials. Supply
 boto3 config to athena client

---
 dbt/adapters/athena/session.py | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index 263b31ae..fa68cb00 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -8,6 +8,7 @@
 import boto3
 import boto3.session
 
+from dbt.adapters.athena.config import get_boto3_config
 from dbt.adapters.athena.constants import DEFAULT_THREAD_COUNT, LOGGER
 from dbt.contracts.connection import Connection
 from dbt.exceptions import DbtRuntimeError
@@ -25,6 +26,16 @@ def get_boto3_session(connection: Connection) -> boto3.session.Session:
     )
 
 
+def get_boto3_session_from_credentials(credentials: Any) -> boto3.session.Session:
+    return boto3.session.Session(
+        aws_access_key_id=credentials.aws_access_key_id,
+        aws_secret_access_key=credentials.aws_secret_access_key,
+        aws_session_token=credentials.aws_session_token,
+        region_name=credentials.region_name,
+        profile_name=credentials.aws_profile_name,
+    )
+
+
 class AthenaSparkSessionManager:
     """
     A helper class to manage Athena Spark Sessions.
@@ -53,7 +64,7 @@ def spark_threads(self) -> int:
         Get the number of Spark threads.
 
         Returns:
-            Any: The number of Spark threads. If not found in the profile, returns the default thread count.
+            int: The number of Spark threads. If not found in the profile, returns the default thread count.
         """
         if not self.credentials.spark_threads:
             LOGGER.debug(
@@ -69,7 +80,7 @@ def spark_work_group(self) -> str:
         Get the Spark work group.
 
         Returns:
-            Any: The Spark work group. Raises an exception if not found in the profile.
+            str: The Spark work group. Raises an exception if not found in the profile.
         """
         if not self.credentials.spark_work_group:
             raise DbtRuntimeError(f"Expected spark_work_group in profile. Got: {self.credentials.spark_work_group}")
@@ -87,9 +98,9 @@ def athena_client(self) -> Any:
             Any: The Athena client object.
 
         """
-        return boto3.session.Session(
-            region_name=self.credentials.region_name, profile_name=self.credentials.aws_profile_name
-        ).client("athena")
+        return get_boto3_session_from_credentials(self.credentials).client(
+            "athena", config=get_boto3_config(num_retries=self.credentials.effective_num_retries)
+        )
 
     def get_new_sessions(self) -> List[UUID]:
         """

From 4dd9f94b04af6ec81d84af0b50f22c7e4247abda Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Sat, 30 Dec 2023 10:51:59 -0500
Subject: [PATCH 66/75] feat: enable iceberg table format for athena spark

---
 README.md                                     |  58 ++++-
 dbt/adapters/athena/config.py                 |  66 ++++--
 dbt/adapters/athena/constants.py              |  32 ++-
 dbt/adapters/athena/python_submissions.py     | 127 +++++++----
 dbt/adapters/athena/session.py                | 199 ++++++++----------
 .../macros/adapters/python_submissions.sql    |  16 +-
 .../models/table/create_table_as.sql          |  79 ++++---
 .../materializations/models/table/table.sql   |  34 ++-
 dev-requirements.txt                          |   2 +-
 setup.py                                      |   4 +-
 tests/unit/test_session.py                    |   8 +-
 11 files changed, 412 insertions(+), 213 deletions(-)

diff --git a/README.md b/README.md
index 0f051420..bf384267 100644
--- a/README.md
+++ b/README.md
@@ -133,7 +133,6 @@ A dbt profile can be configured to run against AWS Athena using the following co
 | work_group            | Identifier of Athena workgroup                                                           | Optional  | `my-custom-workgroup`                      |
 | num_retries           | Number of times to retry a failing query                                                 | Optional  | `3`                                        |
 | spark_work_group      | Identifier of Athena Spark workgroup                                           | Optional  | `my-spark-workgroup`                       |
-| spark_threads         | Number of spark sessions to create. Recommended to be same as threads.         | Optional  | `4`                                        |
 | num_boto3_retries     | Number of times to retry boto3 requests (e.g. deleting S3 files for materialized tables) | Optional  | `5`                                        |
 | seed_s3_upload_args   | Dictionary containing boto3 ExtraArgs when uploading to S3                               | Optional  | `{"ACL": "bucket-owner-full-control"}`     |
 | lf_tags_database      | Default LF tags for new database if it's created by dbt                                  | Optional  | `tag_key: tag_value`                       |
@@ -157,7 +156,6 @@ athena:
       aws_profile_name: my-profile
       work_group: my-workgroup
       spark_work_group: my-spark-workgroup
-      spark_threads: 4
       seed_s3_upload_args:
         ACL: bucket-owner-full-control
 ```
@@ -559,9 +557,28 @@ The adapter supports python models using [`spark`](https://docs.aws.amazon.com/a
 - A spark enabled work group created in athena
 - Spark execution role granted access to Athena, Glue and S3
 - The spark work group is added to the ~/.dbt/profiles.yml file and the profile is referenced in dbt_project.yml
-- The spark_threads value is added to ~/.dbt/profiles.yml which determines the maximum number of parallel spark sessions
   that will be created. It is recommended to keep this same as threads.
 
+
+### Spark specific table configuration
+
+- `timeout` (`default=43200`)
+  - Time out in seconds for each python model execution. Defaults to 12 hours/43200 seconds.
+- `spark_encryption` (`default=false`)
+  - If this flag is set to true, encrypts data in transit between Spark nodes and also encrypts data at rest stored locally by Spark.
+- `spark_cross_account_catalog` (`default=false`)
+  - In spark, you can query the external account catalog and for that the consumer account has to be configured to access the producer catalog.
+  - If this flag is set to true, "/" can be used as the glue catalog separator. Ex: 999999999999/mydatabase.cloudfront_logs (*where *999999999999* is the external catalog id*)
+- `spark_requester_pays` (`default=false`)
+  - When an Amazon S3 bucket is configured as requester pays, the account of the user running the query is charged for data access and data transfer fees associated with the query.
+  - If this flag is set to true, requester pays S3 buckets are enabled in Athena for Spark.
+
+### Spark notes
+- A session is created for each unique engine configuration defined in the models that are part of the invocation.
+- A session's idle timeout is set to 10 minutes. Within the timeout period, if there is a new calculation (spark python model) ready for execution and the engine configuration matches, the process will reuse the same session.
+- Number of python models running at a time depends on the `threads`.  Number of sessions created for the entire run depends on number of unique engine configurations and availability of session to maintain threads concurrency.
+- For iceberg table, it is recommended to use table_properties configuration to set the format_version to 2. This is to maintain compatability between iceberg tables created by Trino with those created by Spark.
+
 ### Example models
 
 #### Simple pandas model
@@ -617,6 +634,9 @@ def model(dbt, spark_session):
             "CoordinatorDpuSize": 1,
             "MaxConcurrentDpus": 3,
             "DefaultExecutorDpuSize": 1,
+            "spark_encryption": True,
+            "spark_cross_account_catalog": True,
+            "spark_requester_pays": True
         },
         polling_interval=15,
         timeout=120,
@@ -629,9 +649,39 @@ def model(dbt, spark_session):
     return df
 ```
 
+#### Create pySpark udf using imported external python files
+
+```python
+def model(dbt, spark_session):
+    dbt.config(
+        materialized="incremental",
+        incremental_strategy="merge",
+        unique_key="num",
+    )
+    sc = spark_session.sparkContext
+    sc.addPyFile("s3://athena-dbt/test/file1.py")
+    sc.addPyFile("s3://athena-dbt/test/file2.py")
+
+    def func(iterator):
+        from file2 import transform
+
+        return [transform(i) for i in iterator]
+
+    from pyspark.sql.functions import udf
+    from pyspark.sql.functions import col
+
+    udf_with_import = udf(func)
+
+    data = [(1, "a"), (2, "b"), (3, "c")]
+    cols = ["num", "alpha"]
+    df = spark_session.createDataFrame(data, cols)
+
+    return df.withColumn("udf_test_col", udf_with_import(col("alpha")))
+```
+
 #### Known issues in python models
 
-- Incremental models do not fully utilize spark capabilities. They depend partially on existing sql based logic.
+- Incremental models do not fully utilize spark capabilities. They depend partially on existing sql based logic which runs on trino.
 - Snapshots materializations are not supported.
 - Spark can only reference tables within the same catalog.
 
diff --git a/dbt/adapters/athena/config.py b/dbt/adapters/athena/config.py
index 456afe3b..fbdddc6b 100644
--- a/dbt/adapters/athena/config.py
+++ b/dbt/adapters/athena/config.py
@@ -9,7 +9,8 @@
     DEFAULT_SPARK_COORDINATOR_DPU_SIZE,
     DEFAULT_SPARK_EXECUTOR_DPU_SIZE,
     DEFAULT_SPARK_MAX_CONCURRENT_DPUS,
-    DEFAULT_SPARK_SESSION_TIMEOUT,
+    DEFAULT_CALCULATION_TIMEOUT,
+    DEFAULT_SPARK_PROPERTIES,
     LOGGER,
 )
 
@@ -46,7 +47,7 @@ def set_timeout(self) -> int:
             ValueError: If the timeout value is not a positive integer.
 
         """
-        timeout = self.config.get("timeout", DEFAULT_SPARK_SESSION_TIMEOUT)
+        timeout = self.config.get("timeout", DEFAULT_CALCULATION_TIMEOUT)
         if not isinstance(timeout, int):
             raise TypeError("Timeout must be an integer")
         if timeout <= 0:
@@ -99,20 +100,59 @@ def set_engine_config(self) -> Dict[str, Any]:
             TypeError: If the engine configuration is not of type dict.
             KeyError: If the keys of the engine configuration dictionary do not match the expected format.
         """
-        engine_config = self.config.get(
-            "engine_config",
-            {
-                "CoordinatorDpuSize": DEFAULT_SPARK_COORDINATOR_DPU_SIZE,
-                "MaxConcurrentDpus": DEFAULT_SPARK_MAX_CONCURRENT_DPUS,
-                "DefaultExecutorDpuSize": DEFAULT_SPARK_EXECUTOR_DPU_SIZE,
-            },
-        )
+        table_type = self.config.get("table_type", "hive")
+        spark_encryption = self.config.get("spark_encryption", False)
+        spark_cross_account_catalog = self.config.get("spark_cross_account_catalog", False)
+        spark_requester_pays = self.config.get("spark_requester_pays", False)
+
+        default_spark_properties = {}
+        if table_type.lower() in ["iceberg", "hudi", "delta_lake"]:
+            default_spark_properties = default_spark_properties | DEFAULT_SPARK_PROPERTIES.get(table_type)
+        if spark_encryption:
+            default_spark_properties = default_spark_properties | DEFAULT_SPARK_PROPERTIES.get("spark_encryption")
+        if spark_cross_account_catalog:
+            default_spark_properties = default_spark_properties | DEFAULT_SPARK_PROPERTIES.get("spark_cross_account_catalog")
+        if spark_requester_pays:
+            default_spark_properties = default_spark_properties | DEFAULT_SPARK_PROPERTIES.get("spark_requester_pays")
+
+        default_engine_config = {
+            "CoordinatorDpuSize": DEFAULT_SPARK_COORDINATOR_DPU_SIZE,
+            "MaxConcurrentDpus": DEFAULT_SPARK_MAX_CONCURRENT_DPUS,
+            "DefaultExecutorDpuSize": DEFAULT_SPARK_EXECUTOR_DPU_SIZE,
+            "SparkProperties": default_spark_properties,
+        }
+        engine_config = self.config.get("engine_config", None)
+
+        if engine_config:
+            provided_spark_properties = engine_config.get("SparkProperties", None)
+            if provided_spark_properties:
+                default_spark_properties.update(provided_spark_properties)
+                default_engine_config["SparkProperties"] = default_spark_properties
+                engine_config.pop("SparkProperties")
+            default_engine_config.update(engine_config)
+        engine_config = default_engine_config
+
         if not isinstance(engine_config, dict):
             raise TypeError("Engine configuration has to be of type dict")
 
-        expected_keys = {"CoordinatorDpuSize", "MaxConcurrentDpus", "DefaultExecutorDpuSize"}
-        if set(engine_config.keys()) != expected_keys:
-            raise KeyError(f"The keys of the dictionary entered do not match the expected format: {expected_keys}")
+        expected_keys = {
+            "CoordinatorDpuSize",
+            "MaxConcurrentDpus",
+            "DefaultExecutorDpuSize",
+            "SparkProperties",
+            "AdditionalConfigs",
+        }
+
+        if set(engine_config.keys()) - {
+            "CoordinatorDpuSize",
+            "MaxConcurrentDpus",
+            "DefaultExecutorDpuSize",
+            "SparkProperties",
+            "AdditionalConfigs",
+        }:
+            raise KeyError(
+                f"The engine configuration keys provided do not match the expected athena engine keys: {expected_keys}"
+            )
 
         if engine_config["MaxConcurrentDpus"] == 1:
             raise KeyError("The lowest value supported for MaxConcurrentDpus is 2")
diff --git a/dbt/adapters/athena/constants.py b/dbt/adapters/athena/constants.py
index 2b7e9ddd..aa1dd5e4 100644
--- a/dbt/adapters/athena/constants.py
+++ b/dbt/adapters/athena/constants.py
@@ -6,6 +6,36 @@
 DEFAULT_SPARK_COORDINATOR_DPU_SIZE = 1
 DEFAULT_SPARK_MAX_CONCURRENT_DPUS = 2
 DEFAULT_SPARK_EXECUTOR_DPU_SIZE = 1
-DEFAULT_SPARK_SESSION_TIMEOUT = 15 * 60
+DEFAULT_CALCULATION_TIMEOUT = 43200  # seconds = 12 hours
+SESSION_IDLE_TIMEOUT_MIN = 10  # minutes
+
+DEFAULT_SPARK_PROPERTIES = {
+    # https://docs.aws.amazon.com/athena/latest/ug/notebooks-spark-table-formats.html
+    "iceberg": {
+        "spark.sql.catalog.spark_catalog": "org.apache.iceberg.spark.SparkSessionCatalog",
+        "spark.sql.catalog.spark_catalog.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
+        "spark.sql.catalog.spark_catalog.io-impl": "org.apache.iceberg.aws.s3.S3FileIO",
+        "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
+    },
+    "hudi": {
+        "spark.sql.catalog.spark_catalog": "org.apache.spark.sql.hudi.catalog.HoodieCatalog",
+        "spark.serializer": "org.apache.spark.serializer.KryoSerializer",
+        "spark.sql.extensions": "org.apache.spark.sql.hudi.HoodieSparkSessionExtension",
+    },
+    "delta_lake": {
+        "spark.sql.catalog.spark_catalog": "org.apache.spark.sql.delta.catalog.DeltaCatalog",
+        "spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension",
+    },
+    # https://docs.aws.amazon.com/athena/latest/ug/notebooks-spark-encryption.html
+    "spark_encryption": {
+        "spark.authenticate": "true",
+        "spark.io.encryption.enabled": "true",
+        "spark.network.crypto.enabled": "true",
+    },
+    # https://docs.aws.amazon.com/athena/latest/ug/spark-notebooks-cross-account-glue.html
+    "spark_cross_account_catalog": {"spark.hadoop.aws.glue.catalog.separator": "/"},
+    # https://docs.aws.amazon.com/athena/latest/ug/notebooks-spark-requester-pays.html
+    "spark_requester_pays": {"spark.hadoop.fs.s3.useRequesterPaysHeader": "true"},
+}
 
 LOGGER = AdapterLogger(__name__)
diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 8acd2e6a..90b4e9b5 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -30,13 +30,14 @@ def __init__(self, parsed_model: Dict[Any, Any], credentials: AthenaCredentials)
             parsed_model (Dict[Any, Any]): The parsed python model.
             credentials (AthenaCredentials): Credentials for Athena connection.
         """
+        self.relation_name = parsed_model.get("relation_name", None)
         self.config = AthenaSparkSessionConfig(
             parsed_model.get("config", {}),
             polling_interval=credentials.poll_interval,
             retry_attempts=credentials.num_retries,
         )
         self.spark_connection = AthenaSparkSessionManager(
-            credentials, self.timeout, self.polling_interval, self.engine_config
+            credentials, self.timeout, self.polling_interval, self.engine_config, self.relation_name
         )
 
     @cached_property
@@ -98,25 +99,6 @@ def get_current_session_status(self) -> Any:
         """
         return self.spark_connection.get_session_status(self.session_id)
 
-    def poll_until_session_idle(self) -> None:
-        """
-        Polls the session status until it becomes idle or exceeds the timeout.
-
-        Raises:
-            DbtRuntimeError: If the session chosen is not available or if it does not become idle within the timeout.
-        """
-        polling_interval = self.polling_interval
-        while True:
-            session_status = self.get_current_session_status()["State"]
-            if session_status in ["FAILED", "TERMINATED", "DEGRADED"]:
-                raise DbtRuntimeError(f"The session chosen was not available. Got status: {session_status}")
-            if session_status == "IDLE":
-                break
-            time.sleep(polling_interval)
-            polling_interval *= 2
-            if polling_interval > self.timeout:
-                raise DbtRuntimeError(f"Session {self.session_id} did not become free within {self.timeout} seconds.")
-
     def submit(self, compiled_code: str) -> Any:
         """
         Submit a calculation to Athena.
@@ -139,6 +121,7 @@ def submit(self, compiled_code: str) -> Any:
         """
         while True:
             try:
+                LOGGER.debug(f"Model {self.relation_name} - Using session: {self.session_id} to start calculation execution.")
                 calculation_execution_id = self.athena_client.start_calculation_execution(
                     SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
                 )["CalculationExecutionId"]
@@ -153,27 +136,57 @@ def submit(self, compiled_code: str) -> Any:
                     LOGGER.exception("Going to poll until session is IDLE")
                     self.poll_until_session_idle()
             except Exception as e:
-                raise DbtRuntimeError(f"Unable to complete python execution. Got: {e}")
+                raise DbtRuntimeError(f"Unable to start spark python code execution. Got: {e}")
         execution_status = self.poll_until_execution_completion(calculation_execution_id)
-        LOGGER.debug(f"Received execution status {execution_status}")
+        LOGGER.debug(f"Model {self.relation_name} - Received execution status {execution_status}")
         if execution_status == "COMPLETED":
             try:
                 result = self.athena_client.get_calculation_execution(CalculationExecutionId=calculation_execution_id)[
                     "Result"
                 ]
             except Exception as e:
-                LOGGER.error(f"Unable to poll execution status: Got: {e}")
+                LOGGER.error(f"Unable to retrieve results: Got: {e}")
                 result = {}
-        self.spark_connection.release_session_lock(self.session_id)
         return result
 
+    def poll_until_session_idle(self) -> None:
+        """
+        Polls the session status until it becomes idle or exceeds the timeout.
+
+        Raises:
+            DbtRuntimeError: If the session chosen is not available or if it does not become idle within the timeout.
+        """
+        polling_interval = self.polling_interval
+        while True:
+            timer = 0
+            session_status = self.get_current_session_status()["State"]
+            if session_status in ["TERMINATING", "TERMINATED", "DEGRADED", "FAILED"]:
+                LOGGER.debug(
+                    f"Model {self.relation_name} - The session: {self.session_id} was not available. Got status: {session_status}. Will try with a different session."
+                )
+                self.spark_connection.remove_terminated_session(self.session_id)
+                if "session_id" in self.__dict__:
+                    del self.__dict__["session_id"]
+                break
+            if session_status == "IDLE":
+                break
+            time.sleep(polling_interval)
+            timer += polling_interval
+            if timer > self.timeout:
+                LOGGER.debug(
+                    f"Model {self.relation_name} - Session {self.session_id} did not become free within {self.timeout} seconds. Will try with a different session."
+                )
+                if "session_id" in self.__dict__:
+                    del self.__dict__["session_id"]
+                break
+
     def poll_until_execution_completion(self, calculation_execution_id: str) -> Any:
         """
-        Poll the status of a calculation execution until it is completed, failed, or cancelled.
+        Poll the status of a calculation execution until it is completed, failed, or canceled.
 
         This function polls the status of a calculation execution identified by the given `calculation_execution_id`
-        until it is completed, failed, or cancelled. It uses the Athena client to retrieve the status of the execution
-        and checks if the state is one of "COMPLETED", "FAILED", or "CANCELLED". If the execution is not yet completed,
+        until it is completed, failed, or canceled. It uses the Athena client to retrieve the status of the execution
+        and checks if the state is one of "COMPLETED", "FAILED", or "CANCELED". If the execution is not yet completed,
         the function sleeps for a certain polling interval, which starts with the value of `self.polling_interval` and
         doubles after each iteration until it reaches the `self.timeout` period. If the execution does not complete
         within the timeout period, a `DbtRuntimeError` is raised.
@@ -182,27 +195,51 @@ def poll_until_execution_completion(self, calculation_execution_id: str) -> Any:
             calculation_execution_id (str): The ID of the calculation execution to poll.
 
         Returns:
-            str: The final state of the calculation execution, which can be one of "COMPLETED", "FAILED" or "CANCELLED".
+            str: The final state of the calculation execution, which can be one of "COMPLETED", "FAILED" or "CANCELED".
 
         Raises:
             DbtRuntimeError: If the calculation execution does not complete within the timeout period.
 
         """
-        polling_interval = self.polling_interval
-        while True:
-            execution_status = self.athena_client.get_calculation_execution_status(
-                CalculationExecutionId=calculation_execution_id
-            )["Status"]["State"]
-            if execution_status in ["FAILED", "CANCELLED"]:
-                raise DbtRuntimeError(
-                    f"""Execution {calculation_execution_id} did not complete successfully.
-                    Got: {execution_status} status."""
-                )
-            if execution_status == "COMPLETED":
-                return execution_status
-            time.sleep(polling_interval)
-            polling_interval *= 2
-            if polling_interval > self.timeout:
-                raise DbtRuntimeError(
-                    f"Execution {calculation_execution_id} did not complete within {self.timeout} seconds."
+        try:
+            polling_interval = self.polling_interval
+            while True:
+                timer = 0
+                execution_response = self.athena_client.get_calculation_execution(
+                    CalculationExecutionId=calculation_execution_id
                 )
+                execution_session = execution_response.get("SessionId", None)
+                execution_status = execution_response.get("Status", None)
+                execution_result = execution_response.get("Result", None)
+                execution_stderr_s3_path = ""
+                if execution_result:
+                    execution_stderr_s3_path = execution_result.get("StdErrorS3Uri", None)
+
+                execution_status_state = ""
+                execution_status_reason = ""
+                if execution_status:
+                    execution_status_state = execution_status.get("State", None)
+                    execution_status_reason = execution_status.get("StateChangeReason", None)
+
+                if execution_status_state in ["FAILED", "CANCELED"]:
+                    raise DbtRuntimeError(
+                        f"""Calculation Id:   {calculation_execution_id}
+Session Id:     {execution_session}
+Status:         {execution_status_state}
+Reason:         {execution_status_reason}
+Stderr s3 path: {execution_stderr_s3_path}
+"""
+                    )
+
+                if execution_status_state == "COMPLETED":
+                    return execution_status_state
+
+                time.sleep(polling_interval)
+                timer += polling_interval
+                if timer > self.timeout:
+                    self.athena_client.stop_calculation_execution(CalculationExecutionId=calculation_execution_id)
+                    raise DbtRuntimeError(
+                        f"Execution {calculation_execution_id} did not complete within {self.timeout} seconds."
+                    )
+        finally:
+            self.spark_connection.set_spark_session_load(self.session_id, -1)
diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index fa68cb00..dd9fbf23 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -2,18 +2,22 @@
 import time
 from datetime import datetime, timedelta, timezone
 from functools import cached_property
+from hashlib import md5
 from typing import Any, Dict, List
 from uuid import UUID
-
 import boto3
 import boto3.session
+import json
 
 from dbt.adapters.athena.config import get_boto3_config
-from dbt.adapters.athena.constants import DEFAULT_THREAD_COUNT, LOGGER
+from dbt.adapters.athena.constants import DEFAULT_THREAD_COUNT, LOGGER, SESSION_IDLE_TIMEOUT_MIN
 from dbt.contracts.connection import Connection
+from dbt.events.functions import get_invocation_id
 from dbt.exceptions import DbtRuntimeError
 
-spark_session_locks: Dict[UUID, threading.Lock] = {}
+invocation_id = get_invocation_id()
+spark_session_list: Dict[UUID, str] = {}
+spark_session_load: Dict[UUID, int] = {}
 
 
 def get_boto3_session(connection: Connection) -> boto3.session.Session:
@@ -41,7 +45,7 @@ class AthenaSparkSessionManager:
     A helper class to manage Athena Spark Sessions.
     """
 
-    def __init__(self, credentials: Any, timeout: int, polling_interval: float, engine_config: Dict[str, int]) -> None:
+    def __init__(self, credentials: Any, timeout: int, polling_interval: float, engine_config: Dict[str, int], relation_name: str = None) -> None:
         """
         Initialize the AthenaSparkSessionManager instance.
 
@@ -57,6 +61,7 @@ def __init__(self, credentials: Any, timeout: int, polling_interval: float, engi
         self.polling_interval = polling_interval
         self.engine_config = engine_config
         self.lock = threading.Lock()
+        self.relation_name = relation_name
 
     @cached_property
     def spark_threads(self) -> int:
@@ -102,99 +107,56 @@ def athena_client(self) -> Any:
             "athena", config=get_boto3_config(num_retries=self.credentials.effective_num_retries)
         )
 
-    def get_new_sessions(self) -> List[UUID]:
-        """
-        Retrieves a list of new sessions by subtracting the existing sessions from the complete session list.
-        If no new sessions are found a new session is created provided the number of sessions is less than the
-        number of allowed spark threads.
-
-        Returns:
-            List[UUID]: A list of new session UUIDs.
-
-        """
-        sessions = self.list_sessions()
-        existing_sessions = set(spark_session_locks.keys())
-        new_sessions = [session for session in sessions if session not in existing_sessions]
-
-        if len(new_sessions) == 0:
-            if len(spark_session_locks) < self.spark_threads:
-                return [self.start_session()]
-            LOGGER.warning(
-                f"""Maximum spark session count: {self.spark_threads} reached.
-            Cannot start new spark session."""
-            )
-        LOGGER.debug(f"Setting sessions: {new_sessions}")
-        return new_sessions
-
-    def update_spark_session_locks(self) -> None:
+    @cached_property
+    def session_description(self) -> str:
         """
-        Update session locks for each session.
-
-        This function iterates over the existing sessions and ensures that a session lock is created for each session.
-        If a session lock already exists, it is left unchanged.
-
-        Args:
-            self: The instance of the class.
+        Converts the engine configuration to md5 hash value
 
         Returns:
-            None
+            str: A concatenated text of dbt invocation_id and engine configuration's md5 hash
         """
-        for session_uuid in self.get_new_sessions():
-            spark_session_locks.setdefault(session_uuid, threading.Lock())
-        LOGGER.debug(f"Updated session locks: {spark_session_locks}")
+        hash_desc = md5(json.dumps(self.engine_config, sort_keys=True, ensure_ascii=True).encode("utf-8")).hexdigest()
+        return f"dbt: {invocation_id} - {hash_desc}"
 
-    def get_session_id(self) -> UUID:
+    def get_session_id(self, session_query_capacity: int = 1) -> UUID:
         """
         Get a session ID for the Spark session.
+        When does a new session get created:
+        - When thread limit not reached
+        - When thread limit reached but same engine configuration session is not available
+        - When thread limit reached and same engine configuration session exist and it is busy running a python model and has one python model in queue (determined by session_query_capacity).
 
         Returns:
             UUID: The session ID.
-
-        Notes:
-            This method acquires a lock on an existing available Spark session. If no session is available,
-            it waits for a certain period and retries until a session becomes available or a timeout is reached.
-            The session ID of the acquired session is returned.
-
         """
-        polling_interval = self.polling_interval
-        self.update_spark_session_locks()
-        while True:
-            for session_uuid, lock in spark_session_locks.items():
-                if not lock.locked():
-                    LOGGER.debug(f"Locking existing session: {session_uuid}")
-                    lock.acquire(blocking=False)
-                    return session_uuid
+        session_list = list(spark_session_list.items())
+
+        if len(session_list) < self.spark_threads:
             LOGGER.debug(
-                f"""All available spark sessions: {spark_session_locks.keys()} are locked.
-                Going to sleep: {polling_interval} seconds."""
+                f"Within thread limit, creating new session for model: {self.relation_name} with session description: {self.session_description}."
             )
-            time.sleep(polling_interval)
-            polling_interval *= 2
-
-    def list_sessions(self, state: str = "IDLE") -> List[UUID]:
-        """
-        List the sessions based on the specified state.
-
-        Args:
-            state (str, optional): The state to filter the sessions. Defaults to "IDLE".
-
-        Returns:
-            List[UUID]: A list of session IDs matching the specified state.
-
-        Notes:
-            This method utilizes the Athena client to list sessions in the Spark work group.
-            The sessions are filtered based on the provided state.
-            If no sessions are found or the response does not contain any sessions, an empty list is returned.
-
-        """
-        response = self.athena_client.list_sessions(
-            WorkGroup=self.spark_work_group,
-            MaxResults=self.spark_threads,
-            StateFilter=state,
-        )
-        if response.get("Sessions") is None:
-            return []
-        return [UUID(session_string["SessionId"]) for session_string in response.get("Sessions")]
+            return self.start_session()
+        else:
+            matching_session_id = next(
+                (
+                    session_id
+                    for session_id, description in session_list
+                    if description == self.session_description
+                    and spark_session_load.get(session_id, 0) <= session_query_capacity
+                ),
+                None,
+            )
+            if matching_session_id:
+                LOGGER.debug(
+                    f"Over thread limit, matching session found for model: {self.relation_name} with session description: {self.session_description} and has capacity."
+                )
+                self.set_spark_session_load(str(matching_session_id), 1)
+                return matching_session_id
+            else:
+                LOGGER.debug(
+                    f"Over thread limit, matching session not found or found with over capacity. Creating new session for model: {self.relation_name} with session description: {self.session_description}."
+                )
+                return self.start_session()
 
     def start_session(self) -> UUID:
         """
@@ -208,13 +170,22 @@ def start_session(self) -> UUID:
             dict: The session information dictionary.
 
         """
+        description = self.session_description
         response = self.athena_client.start_session(
+            Description=description,
             WorkGroup=self.credentials.spark_work_group,
             EngineConfiguration=self.engine_config,
+            SessionIdleTimeoutInMinutes=SESSION_IDLE_TIMEOUT_MIN,
         )
+        session_id = response["SessionId"]
         if response["State"] != "IDLE":
-            self.poll_until_session_creation(response["SessionId"])
-        return UUID(response["SessionId"])
+            self.poll_until_session_creation(session_id)
+
+        with self.lock:
+            spark_session_list[UUID(session_id)] = self.session_description
+            spark_session_load[UUID(session_id)] = 1
+
+        return UUID(session_id)
 
     def poll_until_session_creation(self, session_id: str) -> None:
         """
@@ -233,45 +204,47 @@ def poll_until_session_creation(self, session_id: str) -> None:
         """
         polling_interval = self.polling_interval
         while True:
-            creation_status = self.get_session_status(session_id)["State"]
-            if creation_status in ["FAILED", "TERMINATED", "DEGRADED"]:
-                raise DbtRuntimeError(f"Unable to create session: {session_id}. Got status: {creation_status}.")
-            elif creation_status == "IDLE":
+            timer = 0
+            creation_status_response = self.get_session_status(session_id)
+            creation_status_state = creation_status_response.get("State", "")
+            creation_status_reason = creation_status_response.get("StateChangeReason", "")
+            if creation_status_state in ["FAILED", "TERMINATED", "DEGRADED"]:
+                raise DbtRuntimeError(
+                    f"Unable to create session: {session_id}. Got status: {creation_status_state} with reason: {creation_status_reason}."
+                )
+            elif creation_status_state == "IDLE":
                 LOGGER.debug(f"Session: {session_id} created")
                 break
             time.sleep(polling_interval)
-            polling_interval *= 2
-            if polling_interval > self.timeout:
+            timer += polling_interval
+            if timer > self.timeout:
+                self.remove_terminated_session(session_id)
                 raise DbtRuntimeError(f"Session {session_id} did not create within {self.timeout} seconds.")
 
-    def release_session_lock(self, session_id: str) -> None:
+    def get_session_status(self, session_id: str) -> Any:
         """
-        Terminate the current Athena session.
-
-        This function terminates the current Athena session if it is in IDLE or BUSY state and has exceeded the
-        configured timeout period. It retrieves the session status, and if the session state is IDLE or BUSY and the
-        duration since the session start time exceeds the timeout period, the session is terminated. The session ID is
-        used to terminate the session via the Athena client.
+        Get the session status.
 
         Returns:
-            None
+            Any: The status of the session
+        """
+        return self.athena_client.get_session_status(SessionId=session_id)["Status"]
 
+    def remove_terminated_session(self, session_id: str) -> None:
+        """
+        Removes session uuid from session list variable
+
+        Returns: None
         """
-        session_status = self.get_session_status(session_id)
-        if session_status["State"] in ["IDLE", "BUSY"] and (
-            session_status["StartDateTime"] - datetime.now(tz=timezone.utc) > timedelta(seconds=self.timeout)
-        ):
-            LOGGER.debug(f"Terminating session: {session_id}")
-            self.athena_client.terminate_session(SessionId=session_id)
         with self.lock:
-            LOGGER.debug(f"Releasing lock for session: {session_id}")
-            spark_session_locks[UUID(session_id)].release()
+            spark_session_list.pop(UUID(session_id), "Session id not found")
+            spark_session_load.pop(UUID(session_id), "Session id not found")
 
-    def get_session_status(self, session_id: str) -> Any:
+    def set_spark_session_load(self, session_id: str, change: int) -> None:
         """
-        Get the session status.
+        Increase or decrease the session load variable
 
-        Returns:
-            Any: The status of the session
+        Returns: None
         """
-        return self.athena_client.get_session_status(SessionId=session_id)["Status"]
+        with self.lock:
+            spark_session_load[UUID(session_id)] = spark_session_load.get(UUID(session_id), 0) + change
diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index fbf1633b..137b117c 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -9,7 +9,8 @@
     {% set merge_schema = optional_args.get("merge_schema", true) %}
     {% set bucket_count = optional_args.get("bucket_count") %}
     {% set field_delimiter = optional_args.get("field_delimiter") %}
-
+    {% set spark_ctas = optional_args.get("spark_ctas", "") %}
+    
 import pyspark
 
 
@@ -23,6 +24,14 @@ def materialize(spark_session, df, target_relation):
     else:
         msg = f"{type(df)} is not a supported type for dbt Python materialization"
         raise Exception(msg)
+
+{% if spark_ctas|length > 0 %}
+    df.createOrReplaceTempView("{{ target_relation.schema}}_{{ target_relation.identifier }}_tmpvw")
+    spark_session.sql("""
+    {{ spark_ctas }}
+    select * from {{ target_relation.schema}}_{{ target_relation.identifier }}_tmpvw
+    """)
+{% else %}
     writer = df.write \
     .format("{{ format }}") \
     .mode("{{ mode }}") \
@@ -36,10 +45,13 @@ def materialize(spark_session, df, target_relation):
         writer = writer.bucketBy({{ bucket_count }},{{ bucketed_by }})
     if {{ sorted_by }} is not None:
         writer = writer.sortBy({{ sorted_by }})
+
     writer.saveAsTable(
         name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
     )
-    return "OK"
+{% endif %}
+    
+    return "Success: {{ target_relation.schema}}.{{ target_relation.identifier }}"
 
 {{ athena__py_get_spark_dbt_object() }}
 
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index 1541b234..5b9b9b94 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -36,34 +36,43 @@
     {{ get_assert_columns_equivalent(compiled_code) }}
   {%- endif -%}
 
-  {%- if table_type == 'iceberg' -%}
-    {%- set location_property = 'location' -%}
-    {%- set partition_property = 'partitioning' -%}
-    {%- if bucketed_by is not none or bucket_count is not none -%}
-      {%- set ignored_bucket_iceberg -%}
-      bucketed_by or bucket_count cannot be used with Iceberg tables. You have to use the bucket function
-      when partitioning. Will be ignored
-      {%- endset -%}
-      {%- set bucketed_by = none -%}
-      {%- set bucket_count = none -%}
-      {% do log(ignored_bucket_iceberg) %}
-    {%- endif -%}
-    {%- if 'unique' not in s3_data_naming or external_location is not none -%}
-      {%- set error_unique_location_iceberg -%}
-        You need to have an unique table location when creating Iceberg table since we use the RENAME feature
-        to have near-zero downtime.
-      {%- endset -%}
-      {% do exceptions.raise_compiler_error(error_unique_location_iceberg) %}
-    {%- endif -%}
-  {%- endif %}
-
   {%- if native_drop and table_type == 'iceberg' -%}
     {% do log('Config native_drop enabled, skipping direct S3 delete') %}
   {%- else -%}
     {% do adapter.delete_from_s3(location) %}
   {%- endif -%}
+
   {%- if language == 'python' -%}
-    {% do log('Creating table with spark and compiled code: ' ~ compiled_code) %}
+    {%- set spark_ctas = '' -%}
+    {%- if table_type == 'iceberg' -%}
+      {%- set spark_ctas -%}
+          create table {{ relation.schema | replace('\"', '`') }}.{{ relation.identifier | replace('\"', '`') }}
+          using iceberg
+          location '{{ location }}/'
+
+          {%- if partitioned_by is not none %}
+          partitioned by (
+              {%- for prop_value in partitioned_by -%}
+              {{ prop_value }}
+              {%- if not loop.last %},{% endif -%}
+              {%- endfor -%}
+          )
+          {%- endif %}
+
+          {%- if extra_table_properties is not none %}
+          tblproperties(
+              {%- for prop_name, prop_value in extra_table_properties.items() -%}
+              '{{ prop_name }}'='{{ prop_value }}'
+              {%- if not loop.last %},{% endif -%}
+              {%- endfor -%}
+          )
+          {% endif %}
+
+          as
+      {%- endset -%}
+    {%- endif -%} 
+
+    {# {% do log('Creating table with spark and compiled code: ' ~ compiled_code) %} #}
     {{ athena__py_save_table_as(
         compiled_code,
         relation,
@@ -75,12 +84,34 @@
           'bucketed_by': bucketed_by,
           'write_compression': write_compression,
           'bucket_count': bucket_count,
-          'field_delimiter': field_delimiter
+          'field_delimiter': field_delimiter,
+          'spark_ctas': spark_ctas
         }
       )
     }}
   {%- else -%}
-    create table {{ relation }}
+    {%- if table_type == 'iceberg' -%}
+      {%- set location_property = 'location' -%}
+      {%- set partition_property = 'partitioning' -%}
+      {%- if bucketed_by is not none or bucket_count is not none -%}
+        {%- set ignored_bucket_iceberg -%}
+        bucketed_by or bucket_count cannot be used with Iceberg tables. You have to use the bucket function
+        when partitioning. Will be ignored
+        {%- endset -%}
+        {%- set bucketed_by = none -%}
+        {%- set bucket_count = none -%}
+        {% do log(ignored_bucket_iceberg) %}
+      {%- endif -%}
+      {%- if 'unique' not in s3_data_naming or external_location is not none -%}
+        {%- set error_unique_location_iceberg -%}
+          You need to have an unique table location when creating Iceberg table since we use the RENAME feature
+          to have near-zero downtime.
+        {%- endset -%}
+        {% do exceptions.raise_compiler_error(error_unique_location_iceberg) %}
+      {%- endif -%}
+    {%- endif %}
+
+    create table {{ relation }} 
     with (
       table_type='{{ table_type }}',
       is_external={%- if table_type == 'iceberg' -%}false{%- else -%}true{%- endif %},
diff --git a/dbt/include/athena/macros/materializations/models/table/table.sql b/dbt/include/athena/macros/materializations/models/table/table.sql
index 2f727d0a..214fe5ae 100644
--- a/dbt/include/athena/macros/materializations/models/table/table.sql
+++ b/dbt/include/athena/macros/materializations/models/table/table.sql
@@ -52,7 +52,12 @@
 
       -- create tmp table
       {%- set query_result = safe_create_table_as(False, tmp_relation, compiled_code, language, force_batch) -%}
-
+      -- Execute python code that is available in query result object
+      {%- if language == 'python' -%}
+        {% call statement('create_table', language=language) %}
+          {{ query_result }}
+        {% endcall %}
+      {%- endif -%}
       -- swap table
       {%- set swap_table = adapter.swap_table(tmp_relation, target_relation) -%}
 
@@ -67,6 +72,12 @@
         {{ drop_relation(old_relation) }}
       {%- endif -%}
       {%- set query_result = safe_create_table_as(False, target_relation, compiled_code, language, force_batch) -%}
+      -- Execute python code that is available in query result object
+      {%- if language == 'python' -%}
+        {% call statement('create_table', language=language) %}
+          {{ query_result }}
+        {% endcall %}
+      {%- endif -%}
     {%- endif -%}
 
     {%- if language != 'python' -%}
@@ -77,9 +88,21 @@
 
     {%- if old_relation is none -%}
       {%- set query_result = safe_create_table_as(False, target_relation, compiled_code, language, force_batch) -%}
+      -- Execute python code that is available in query result object
+      {%- if language == 'python' -%}
+        {% call statement('create_table', language=language) %}
+          {{ query_result }}
+        {% endcall %}
+      {%- endif -%}
     {%- else -%}
       {%- if old_relation.is_view -%}
         {%- set query_result = safe_create_table_as(False, tmp_relation, compiled_code, language, force_batch) -%}
+        -- Execute python code that is available in query result object
+        {%- if language == 'python' -%}
+          {% call statement('create_table', language=language) %}
+            {{ query_result }}
+          {% endcall %}
+        {%- endif -%}
         {%- do drop_relation(old_relation) -%}
         {%- do rename_relation(tmp_relation, target_relation) -%}
       {%- else -%}
@@ -98,7 +121,12 @@
         {%- endif -%}
 
         {% set query_result = safe_create_table_as(False, tmp_relation, compiled_code, language, force_batch) %}
-
+        -- Execute python code that is available in query result object
+        {%- if language == 'python' -%}
+          {% call statement('create_table', language=language) %}
+            {{ query_result }}
+          {% endcall %}
+        {%- endif -%}
         {{ rename_relation(old_relation, old_relation_bkp) }}
         {{ rename_relation(tmp_relation, target_relation) }}
 
@@ -111,8 +139,6 @@
   {% call statement("main", language=language) %}
     {%- if language=='sql' -%}
       SELECT '{{ query_result }}';
-    {%- else -%}
-      {{ query_result }}
     {%- endif -%}
   {% endcall %}
 
diff --git a/dev-requirements.txt b/dev-requirements.txt
index 5ff9f57b..c6c3bdb1 100644
--- a/dev-requirements.txt
+++ b/dev-requirements.txt
@@ -1,6 +1,6 @@
 autoflake~=1.7
 black~=23.11
-boto3-stubs[s3]~=1.29
+boto3-stubs[s3]~=1.34
 dbt-tests-adapter~=1.7.2
 flake8~=6.1
 Flake8-pyproject~=1.2
diff --git a/setup.py b/setup.py
index a2509409..1831e6d4 100644
--- a/setup.py
+++ b/setup.py
@@ -53,8 +53,8 @@ def _get_package_version() -> str:
     include_package_data=True,
     install_requires=[
         # In order to control dbt-core version and package version
-        "boto3~=1.26",
-        "boto3-stubs[athena,glue,lakeformation,sts]~=1.26",
+        "boto3~=1.34",
+        "boto3-stubs[athena,glue,lakeformation,sts]~=1.34",
         "dbt-core~=1.7.0",
         "pyathena>=2.25,<4.0",
         "pydantic>=1.10,<3.0",
diff --git a/tests/unit/test_session.py b/tests/unit/test_session.py
index 49d910c8..539b6f25 100644
--- a/tests/unit/test_session.py
+++ b/tests/unit/test_session.py
@@ -314,8 +314,8 @@ def test_update_spark_session_locks(
         ):
             spark_session_manager.update_spark_session_locks()
             for each_session in get_session_response:
-                assert each_session in session.spark_session_locks.keys()
-                assert type(session.spark_session_locks[each_session]) is not None
+                assert each_session in session.spark_session_list.keys()
+                assert type(session.spark_session_list[each_session]) is not None
 
     def test_get_session_id(self):
         pass
@@ -376,5 +376,5 @@ def test_release_session_lock(
             terminate_session=Mock(return_value=terminate_session_response),
         ):
             spark_session_manager.release_session_lock(test_session_id)
-            assert UUID(test_session_id) in session.spark_session_locks.keys()
-            assert type(session.spark_session_locks[UUID(test_session_id)]) is not None
+            assert UUID(test_session_id) in session.spark_session_list.keys()
+            assert type(session.spark_session_list[UUID(test_session_id)]) is not None

From 200a8fe133f103733d6be9a6614432cf52a37174 Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Tue, 2 Jan 2024 23:50:30 -0500
Subject: [PATCH 67/75] fix: empty code submissions I am seeing an empty
 calculation along with main python model code calculation is submitted for
 almost every model Also, if not returning the result json, we are getting
 green ERROR messages instead of OK messages. And with this handling, I am not
 seeing the run model code in target folder every model under run folder seems
 to be empty. Need to address this work around solution in order to have the
 target folder show the run model content.

---
 dbt/adapters/athena/python_submissions.py | 67 +++++++++++++----------
 1 file changed, 38 insertions(+), 29 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index 90b4e9b5..ffc2845d 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -119,35 +119,44 @@ def submit(self, compiled_code: str) -> Any:
             DbtRuntimeError: If the execution ends in a state other than "COMPLETED".
 
         """
-        while True:
-            try:
-                LOGGER.debug(f"Model {self.relation_name} - Using session: {self.session_id} to start calculation execution.")
-                calculation_execution_id = self.athena_client.start_calculation_execution(
-                    SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
-                )["CalculationExecutionId"]
-                break
-            except botocore.exceptions.ClientError as ce:
-                LOGGER.exception(f"Encountered client error: {ce}")
-                if (
-                    ce.response["Error"]["Code"] == "InvalidRequestException"
-                    and "Session is in the BUSY state; needs to be IDLE to accept Calculations."
-                    in ce.response["Error"]["Message"]
-                ):
-                    LOGGER.exception("Going to poll until session is IDLE")
-                    self.poll_until_session_idle()
-            except Exception as e:
-                raise DbtRuntimeError(f"Unable to start spark python code execution. Got: {e}")
-        execution_status = self.poll_until_execution_completion(calculation_execution_id)
-        LOGGER.debug(f"Model {self.relation_name} - Received execution status {execution_status}")
-        if execution_status == "COMPLETED":
-            try:
-                result = self.athena_client.get_calculation_execution(CalculationExecutionId=calculation_execution_id)[
-                    "Result"
-                ]
-            except Exception as e:
-                LOGGER.error(f"Unable to retrieve results: Got: {e}")
-                result = {}
-        return result
+        # I am seeing an empty calculation along with main python model code calculation is submitted for almost every model
+        # Also, if not returning the result json, we are getting green ERROR messages instead of OK messages.
+        # And with this handling, I am not seeing the run model code in target folder every model under run folder seems to be empty. 
+        # Need to fix this work around solution
+        if compiled_code.strip():
+            while True:
+                try:
+                    LOGGER.debug(
+                        f"Model {self.relation_name} - Using session: {self.session_id} to start calculation execution."
+                    )
+                    calculation_execution_id = self.athena_client.start_calculation_execution(
+                        SessionId=self.session_id, CodeBlock=compiled_code.lstrip()
+                    )["CalculationExecutionId"]
+                    break
+                except botocore.exceptions.ClientError as ce:
+                    LOGGER.exception(f"Encountered client error: {ce}")
+                    if (
+                        ce.response["Error"]["Code"] == "InvalidRequestException"
+                        and "Session is in the BUSY state; needs to be IDLE to accept Calculations."
+                        in ce.response["Error"]["Message"]
+                    ):
+                        LOGGER.exception("Going to poll until session is IDLE")
+                        self.poll_until_session_idle()
+                except Exception as e:
+                    raise DbtRuntimeError(f"Unable to start spark python code execution. Got: {e}")
+            execution_status = self.poll_until_execution_completion(calculation_execution_id)
+            LOGGER.debug(f"Model {self.relation_name} - Received execution status {execution_status}")
+            if execution_status == "COMPLETED":
+                try:
+                    result = self.athena_client.get_calculation_execution(
+                        CalculationExecutionId=calculation_execution_id
+                    )["Result"]
+                except Exception as e:
+                    LOGGER.error(f"Unable to retrieve results: Got: {e}")
+                    result = {}
+            return result
+        else: 
+            return {"ResultS3Uri": "string", "ResultType": "string", "StdErrorS3Uri": "string", "StdOutS3Uri": "string"}
 
     def poll_until_session_idle(self) -> None:
         """

From 89d2d92f62b11350ef1a52d44732991dc92b6bd0 Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Tue, 9 Jan 2024 22:07:14 -0500
Subject: [PATCH 68/75] fix: remove references to obsolete config -
 spark_threads

---
 .env.example                                  |   1 -
 dbt/adapters/athena/connections.py            |   2 -
 dbt/adapters/athena/session.py                |   9 +-
 tests/conftest.py                             |   3 -
 .../adapter/test_python_submissions.py        | 178 +++++++++---------
 tests/unit/constants.py                       |   3 +-
 6 files changed, 94 insertions(+), 102 deletions(-)

diff --git a/.env.example b/.env.example
index 20a4ace8..7182e9c0 100644
--- a/.env.example
+++ b/.env.example
@@ -8,4 +8,3 @@ DBT_TEST_ATHENA_SCHEMA=
 DBT_TEST_ATHENA_WORK_GROUP=
 DBT_TEST_ATHENA_AWS_PROFILE_NAME=
 DBT_TEST_ATHENA_SPARK_WORK_GROUP=
-DBT_TEST_ATHENA_SPARK_THREADs=
diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index ab272bcf..259dad7a 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -60,7 +60,6 @@ class AthenaCredentials(Credentials):
     s3_data_dir: Optional[str] = None
     s3_data_naming: Optional[str] = "schema_table_unique"
     spark_work_group: Optional[str] = None
-    spark_threads: Optional[int] = DEFAULT_THREAD_COUNT
     s3_tmp_table_dir: Optional[str] = None
     # Unfortunately we can not just use dict, must be Dict because we'll get the following error:
     # Credentials in profile "athena", target "athena" invalid: Unable to create schema for 'dict'
@@ -99,7 +98,6 @@ def _connection_keys(self) -> Tuple[str, ...]:
             "seed_s3_upload_args",
             "lf_tags_database",
             "spark_work_group",
-            "spark_threads",
         )
 
 
diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index dd9fbf23..0cfdfd1f 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -71,13 +71,12 @@ def spark_threads(self) -> int:
         Returns:
             int: The number of Spark threads. If not found in the profile, returns the default thread count.
         """
-        if not self.credentials.spark_threads:
+        if not DEFAULT_THREAD_COUNT:
             LOGGER.debug(
-                f"""Spark threads not found in profile. Got: {self.credentials.spark_threads}.
-                Using default count: {DEFAULT_THREAD_COUNT}"""
+                f"""Threads not found in profile. Got: {DEFAULT_THREAD_COUNT}"""
             )
-            return DEFAULT_THREAD_COUNT
-        return int(self.credentials.spark_threads)
+            return 1
+        return int(DEFAULT_THREAD_COUNT)
 
     @cached_property
     def spark_work_group(self) -> str:
diff --git a/tests/conftest.py b/tests/conftest.py
index ae37166c..3701479c 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -18,7 +18,6 @@
     DATA_CATALOG_NAME,
     DATABASE_NAME,
     S3_STAGING_DIR,
-    SPARK_THREADS,
     SPARK_WORKGROUP,
 )
 
@@ -44,7 +43,6 @@ def dbt_profile_target():
         "work_group": os.getenv("DBT_TEST_ATHENA_WORK_GROUP"),
         "aws_profile_name": os.getenv("DBT_TEST_ATHENA_AWS_PROFILE_NAME") or None,
         "spark_work_group": os.getenv("DBT_TEST_ATHENA_SPARK_WORK_GROUP"),
-        "spark_threads": os.getenv("DBT_TEST_ATHENA_SPARK_THREADS"),
     }
 
 
@@ -89,5 +87,4 @@ def athena_credentials():
         region_name=AWS_REGION,
         work_group=ATHENA_WORKGROUP,
         spark_work_group=SPARK_WORKGROUP,
-        spark_threads=SPARK_THREADS,
     )
diff --git a/tests/functional/adapter/test_python_submissions.py b/tests/functional/adapter/test_python_submissions.py
index 671f587f..4011bc97 100644
--- a/tests/functional/adapter/test_python_submissions.py
+++ b/tests/functional/adapter/test_python_submissions.py
@@ -1,89 +1,89 @@
-# import pytest
-# import yaml
-
-# from dbt.tests.adapter.python_model.test_python_model import (
-#     BasePythonIncrementalTests,
-#     BasePythonModelTests,
-# )
-# from dbt.tests.util import run_dbt
-
-# basic_sql = """
-# {{ config(materialized="table") }}
-# select 1 as column_1, 2 as column_2, '{{ run_started_at.strftime("%Y-%m-%d") }}' as run_date
-# """
-
-# basic_python = """
-# def model(dbt, spark):
-#     dbt.config(
-#         materialized='table',
-#     )
-#     df =  dbt.ref("model")
-#     return df
-# """
-
-# basic_spark_python = """
-# def model(dbt, spark_session):
-#     dbt.config(materialized="table")
-
-#     data = [(1,), (2,), (3,), (4,)]
-
-#     df = spark_session.createDataFrame(data, ["A"])
-
-#     return df
-# """
-
-# second_sql = """
-# select * from {{ref('my_python_model')}}
-# """
-
-# schema_yml = """version: 2
-# models:
-#   - name: model
-#     versions:
-#       - v: 1
-# """
-
-
-# class TestBasePythonModelTests(BasePythonModelTests):
-#     @pytest.fixture(scope="class")
-#     def models(self):
-#         return {
-#             "schema.yml": schema_yml,
-#             "model.sql": basic_sql,
-#             "my_python_model.py": basic_python,
-#             "spark_model.py": basic_spark_python,
-#             "second_sql_model.sql": second_sql,
-#         }
-
-
-# incremental_python = """
-# def model(dbt, spark_session):
-#     dbt.config(materialized="incremental")
-#     df = dbt.ref("model")
-
-#     if dbt.is_incremental:
-#         max_from_this = (
-#             f"select max(run_date) from {dbt.this.schema}.{dbt.this.identifier}"
-#         )
-#         df = df.filter(df.run_date >= spark_session.sql(max_from_this).collect()[0][0])
-
-#     return df
-# """
-
-
-# class TestBasePythonIncrementalTests(BasePythonIncrementalTests):
-#     @pytest.fixture(scope="class")
-#     def project_config_update(self):
-#         return {"models": {"+incremental_strategy": "append"}}
-
-#     @pytest.fixture(scope="class")
-#     def models(self):
-#         return {"model.sql": basic_sql, "incremental.py": incremental_python}
-
-#     def test_incremental(self, project):
-#         vars_dict = {
-#             "test_run_schema": project.test_schema,
-#         }
-
-#         results = run_dbt(["run", "--vars", yaml.safe_dump(vars_dict)])
-#         assert len(results) == 2
+import pytest
+import yaml
+
+from dbt.tests.adapter.python_model.test_python_model import (
+    BasePythonIncrementalTests,
+    BasePythonModelTests,
+)
+from dbt.tests.util import run_dbt
+
+basic_sql = """
+{{ config(materialized="table") }}
+select 1 as column_1, 2 as column_2, '{{ run_started_at.strftime("%Y-%m-%d") }}' as run_date
+"""
+
+basic_python = """
+def model(dbt, spark):
+    dbt.config(
+        materialized='table',
+    )
+    df =  dbt.ref("model")
+    return df
+"""
+
+basic_spark_python = """
+def model(dbt, spark_session):
+    dbt.config(materialized="table")
+
+    data = [(1,), (2,), (3,), (4,)]
+
+    df = spark_session.createDataFrame(data, ["A"])
+
+    return df
+"""
+
+second_sql = """
+select * from {{ref('my_python_model')}}
+"""
+
+schema_yml = """version: 2
+models:
+  - name: model
+    versions:
+      - v: 1
+"""
+
+
+class TestBasePythonModelTests(BasePythonModelTests):
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "schema.yml": schema_yml,
+            "model.sql": basic_sql,
+            "my_python_model.py": basic_python,
+            "spark_model.py": basic_spark_python,
+            "second_sql_model.sql": second_sql,
+        }
+
+
+incremental_python = """
+def model(dbt, spark_session):
+    dbt.config(materialized="incremental")
+    df = dbt.ref("model")
+
+    if dbt.is_incremental:
+        max_from_this = (
+            f"select max(run_date) from {dbt.this.schema}.{dbt.this.identifier}"
+        )
+        df = df.filter(df.run_date >= spark_session.sql(max_from_this).collect()[0][0])
+
+    return df
+"""
+
+
+class TestBasePythonIncrementalTests(BasePythonIncrementalTests):
+    @pytest.fixture(scope="class")
+    def project_config_update(self):
+        return {"models": {"+incremental_strategy": "append"}}
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {"model.sql": basic_sql, "incremental.py": incremental_python}
+
+    def test_incremental(self, project):
+        vars_dict = {
+            "test_run_schema": project.test_schema,
+        }
+
+        results = run_dbt(["run", "--vars", yaml.safe_dump(vars_dict)])
+        assert len(results) == 2
diff --git a/tests/unit/constants.py b/tests/unit/constants.py
index f86571ed..fc2a505f 100644
--- a/tests/unit/constants.py
+++ b/tests/unit/constants.py
@@ -8,5 +8,4 @@
 S3_STAGING_DIR = "s3://my-bucket/test-dbt/"
 S3_TMP_TABLE_DIR = "s3://my-bucket/test-dbt-temp/"
 ATHENA_WORKGROUP = "dbt-athena-adapter"
-SPARK_WORKGROUP = "spark"
-SPARK_THREADS = 4
+SPARK_WORKGROUP = "spark"
\ No newline at end of file

From 217d751ee0ad2c59b33093684582a8e1a13e75cd Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Thu, 11 Jan 2024 14:33:24 -0500
Subject: [PATCH 69/75] fix: precommit

---
 README.md                                     | 26 +++++++----
 dbt/adapters/athena/config.py                 | 19 ++++----
 dbt/adapters/athena/connections.py            |  2 +-
 dbt/adapters/athena/python_submissions.py     | 16 ++++---
 dbt/adapters/athena/session.py                | 46 ++++++++++++-------
 .../macros/adapters/python_submissions.sql    |  4 +-
 .../models/table/create_table_as.sql          |  4 +-
 tests/unit/constants.py                       |  2 +-
 8 files changed, 71 insertions(+), 48 deletions(-)

diff --git a/README.md b/README.md
index bf384267..36aa7242 100644
--- a/README.md
+++ b/README.md
@@ -559,25 +559,32 @@ The adapter supports python models using [`spark`](https://docs.aws.amazon.com/a
 - The spark work group is added to the ~/.dbt/profiles.yml file and the profile is referenced in dbt_project.yml
   that will be created. It is recommended to keep this same as threads.
 
-
 ### Spark specific table configuration
 
 - `timeout` (`default=43200`)
   - Time out in seconds for each python model execution. Defaults to 12 hours/43200 seconds.
 - `spark_encryption` (`default=false`)
-  - If this flag is set to true, encrypts data in transit between Spark nodes and also encrypts data at rest stored locally by Spark.
+  - If this flag is set to true, encrypts data in transit between Spark nodes and also encrypts data at rest stored
+   locally by Spark.
 - `spark_cross_account_catalog` (`default=false`)
-  - In spark, you can query the external account catalog and for that the consumer account has to be configured to access the producer catalog.
-  - If this flag is set to true, "/" can be used as the glue catalog separator. Ex: 999999999999/mydatabase.cloudfront_logs (*where *999999999999* is the external catalog id*)
+  - In spark, you can query the external account catalog and for that the consumer account has to be configured to
+   access the producer catalog.
+  - If this flag is set to true, "/" can be used as the glue catalog separator.
+   Ex: 999999999999/mydatabase.cloudfront_logs (*where *999999999999* is the external catalog id*)
 - `spark_requester_pays` (`default=false`)
-  - When an Amazon S3 bucket is configured as requester pays, the account of the user running the query is charged for data access and data transfer fees associated with the query.
+  - When an Amazon S3 bucket is configured as requester pays, the account of the user running the query is charged for
+   data access and data transfer fees associated with the query.
   - If this flag is set to true, requester pays S3 buckets are enabled in Athena for Spark.
 
 ### Spark notes
+
 - A session is created for each unique engine configuration defined in the models that are part of the invocation.
-- A session's idle timeout is set to 10 minutes. Within the timeout period, if there is a new calculation (spark python model) ready for execution and the engine configuration matches, the process will reuse the same session.
-- Number of python models running at a time depends on the `threads`.  Number of sessions created for the entire run depends on number of unique engine configurations and availability of session to maintain threads concurrency.
-- For iceberg table, it is recommended to use table_properties configuration to set the format_version to 2. This is to maintain compatability between iceberg tables created by Trino with those created by Spark.
+- A session's idle timeout is set to 10 minutes. Within the timeout period, if there is a new calculation
+ (spark python model) ready for execution and the engine configuration matches, the process will reuse the same session.
+- Number of python models running at a time depends on the `threads`.  Number of sessions created for the entire run
+ depends on number of unique engine configurations and availability of session to maintain threads concurrency.
+- For iceberg table, it is recommended to use table_properties configuration to set the format_version to 2. This is to
+ maintain compatability between iceberg tables created by Trino with those created by Spark.
 
 ### Example models
 
@@ -681,7 +688,8 @@ def model(dbt, spark_session):
 
 #### Known issues in python models
 
-- Incremental models do not fully utilize spark capabilities. They depend partially on existing sql based logic which runs on trino.
+- Incremental models do not fully utilize spark capabilities. They depend partially on existing sql based logic which
+ runs on trino.
 - Snapshots materializations are not supported.
 - Spark can only reference tables within the same catalog.
 
diff --git a/dbt/adapters/athena/config.py b/dbt/adapters/athena/config.py
index fbdddc6b..52d9ed31 100644
--- a/dbt/adapters/athena/config.py
+++ b/dbt/adapters/athena/config.py
@@ -5,11 +5,11 @@
 from botocore import config
 
 from dbt.adapters.athena.constants import (
+    DEFAULT_CALCULATION_TIMEOUT,
     DEFAULT_POLLING_INTERVAL,
     DEFAULT_SPARK_COORDINATOR_DPU_SIZE,
     DEFAULT_SPARK_EXECUTOR_DPU_SIZE,
     DEFAULT_SPARK_MAX_CONCURRENT_DPUS,
-    DEFAULT_CALCULATION_TIMEOUT,
     DEFAULT_SPARK_PROPERTIES,
     LOGGER,
 )
@@ -105,15 +105,14 @@ def set_engine_config(self) -> Dict[str, Any]:
         spark_cross_account_catalog = self.config.get("spark_cross_account_catalog", False)
         spark_requester_pays = self.config.get("spark_requester_pays", False)
 
-        default_spark_properties = {}
-        if table_type.lower() in ["iceberg", "hudi", "delta_lake"]:
-            default_spark_properties = default_spark_properties | DEFAULT_SPARK_PROPERTIES.get(table_type)
-        if spark_encryption:
-            default_spark_properties = default_spark_properties | DEFAULT_SPARK_PROPERTIES.get("spark_encryption")
-        if spark_cross_account_catalog:
-            default_spark_properties = default_spark_properties | DEFAULT_SPARK_PROPERTIES.get("spark_cross_account_catalog")
-        if spark_requester_pays:
-            default_spark_properties = default_spark_properties | DEFAULT_SPARK_PROPERTIES.get("spark_requester_pays")
+        default_spark_properties: Dict[str, str] = dict(
+            **DEFAULT_SPARK_PROPERTIES.get(table_type)
+            if table_type.lower() in ["iceberg", "hudi", "delta_lake"]
+            else {},
+            **DEFAULT_SPARK_PROPERTIES.get("spark_encryption") if spark_encryption else {},
+            **DEFAULT_SPARK_PROPERTIES.get("spark_cross_account_catalog") if spark_cross_account_catalog else {},
+            **DEFAULT_SPARK_PROPERTIES.get("spark_requester_pays") if spark_requester_pays else {},
+        )
 
         default_engine_config = {
             "CoordinatorDpuSize": DEFAULT_SPARK_COORDINATOR_DPU_SIZE,
diff --git a/dbt/adapters/athena/connections.py b/dbt/adapters/athena/connections.py
index a21c5384..a39ba345 100644
--- a/dbt/adapters/athena/connections.py
+++ b/dbt/adapters/athena/connections.py
@@ -29,7 +29,7 @@
 from tenacity.wait import wait_exponential
 
 from dbt.adapters.athena.config import get_boto3_config
-from dbt.adapters.athena.constants import DEFAULT_THREAD_COUNT, LOGGER
+from dbt.adapters.athena.constants import LOGGER
 from dbt.adapters.athena.session import get_boto3_session
 from dbt.adapters.base import Credentials
 from dbt.adapters.sql import SQLConnectionManager
diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index ffc2845d..fa79bd21 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -119,9 +119,9 @@ def submit(self, compiled_code: str) -> Any:
             DbtRuntimeError: If the execution ends in a state other than "COMPLETED".
 
         """
-        # I am seeing an empty calculation along with main python model code calculation is submitted for almost every model
+        # Seeing an empty calculation along with main python model code calculation is submitted for almost every model
         # Also, if not returning the result json, we are getting green ERROR messages instead of OK messages.
-        # And with this handling, I am not seeing the run model code in target folder every model under run folder seems to be empty. 
+        # And with this handling, the run model code in target folder every model under run folder seems to be empty
         # Need to fix this work around solution
         if compiled_code.strip():
             while True:
@@ -155,7 +155,7 @@ def submit(self, compiled_code: str) -> Any:
                     LOGGER.error(f"Unable to retrieve results: Got: {e}")
                     result = {}
             return result
-        else: 
+        else:
             return {"ResultS3Uri": "string", "ResultType": "string", "StdErrorS3Uri": "string", "StdOutS3Uri": "string"}
 
     def poll_until_session_idle(self) -> None:
@@ -167,11 +167,12 @@ def poll_until_session_idle(self) -> None:
         """
         polling_interval = self.polling_interval
         while True:
-            timer = 0
+            timer: float = 0
             session_status = self.get_current_session_status()["State"]
             if session_status in ["TERMINATING", "TERMINATED", "DEGRADED", "FAILED"]:
                 LOGGER.debug(
-                    f"Model {self.relation_name} - The session: {self.session_id} was not available. Got status: {session_status}. Will try with a different session."
+                    f"Model {self.relation_name} - The session: {self.session_id} was not available. "
+                    f"Got status: {session_status}. Will try with a different session."
                 )
                 self.spark_connection.remove_terminated_session(self.session_id)
                 if "session_id" in self.__dict__:
@@ -183,7 +184,8 @@ def poll_until_session_idle(self) -> None:
             timer += polling_interval
             if timer > self.timeout:
                 LOGGER.debug(
-                    f"Model {self.relation_name} - Session {self.session_id} did not become free within {self.timeout} seconds. Will try with a different session."
+                    f"Model {self.relation_name} - Session {self.session_id} did not become free within {self.timeout}"
+                    " seconds. Will try with a different session."
                 )
                 if "session_id" in self.__dict__:
                     del self.__dict__["session_id"]
@@ -213,7 +215,7 @@ def poll_until_execution_completion(self, calculation_execution_id: str) -> Any:
         try:
             polling_interval = self.polling_interval
             while True:
-                timer = 0
+                timer: float = 0
                 execution_response = self.athena_client.get_calculation_execution(
                     CalculationExecutionId=calculation_execution_id
                 )
diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index 0cfdfd1f..fb19905d 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -1,16 +1,20 @@
+import json
 import threading
 import time
-from datetime import datetime, timedelta, timezone
 from functools import cached_property
 from hashlib import md5
-from typing import Any, Dict, List
+from typing import Any, Dict
 from uuid import UUID
+
 import boto3
 import boto3.session
-import json
 
 from dbt.adapters.athena.config import get_boto3_config
-from dbt.adapters.athena.constants import DEFAULT_THREAD_COUNT, LOGGER, SESSION_IDLE_TIMEOUT_MIN
+from dbt.adapters.athena.constants import (
+    DEFAULT_THREAD_COUNT,
+    LOGGER,
+    SESSION_IDLE_TIMEOUT_MIN,
+)
 from dbt.contracts.connection import Connection
 from dbt.events.functions import get_invocation_id
 from dbt.exceptions import DbtRuntimeError
@@ -45,7 +49,14 @@ class AthenaSparkSessionManager:
     A helper class to manage Athena Spark Sessions.
     """
 
-    def __init__(self, credentials: Any, timeout: int, polling_interval: float, engine_config: Dict[str, int], relation_name: str = None) -> None:
+    def __init__(
+        self,
+        credentials: Any,
+        timeout: int,
+        polling_interval: float,
+        engine_config: Dict[str, int],
+        relation_name: str | None = None,
+    ) -> None:
         """
         Initialize the AthenaSparkSessionManager instance.
 
@@ -72,9 +83,7 @@ def spark_threads(self) -> int:
             int: The number of Spark threads. If not found in the profile, returns the default thread count.
         """
         if not DEFAULT_THREAD_COUNT:
-            LOGGER.debug(
-                f"""Threads not found in profile. Got: {DEFAULT_THREAD_COUNT}"""
-            )
+            LOGGER.debug(f"""Threads not found in profile. Got: {DEFAULT_THREAD_COUNT}""")
             return 1
         return int(DEFAULT_THREAD_COUNT)
 
@@ -121,9 +130,10 @@ def get_session_id(self, session_query_capacity: int = 1) -> UUID:
         """
         Get a session ID for the Spark session.
         When does a new session get created:
-        - When thread limit not reached
-        - When thread limit reached but same engine configuration session is not available
-        - When thread limit reached and same engine configuration session exist and it is busy running a python model and has one python model in queue (determined by session_query_capacity).
+        -   When thread limit not reached
+        -   When thread limit reached but same engine configuration session is not available
+        -   When thread limit reached and same engine configuration session exist and it is busy running a python model
+            and has one python model in queue (determined by session_query_capacity).
 
         Returns:
             UUID: The session ID.
@@ -132,7 +142,8 @@ def get_session_id(self, session_query_capacity: int = 1) -> UUID:
 
         if len(session_list) < self.spark_threads:
             LOGGER.debug(
-                f"Within thread limit, creating new session for model: {self.relation_name} with session description: {self.session_description}."
+                f"Within thread limit, creating new session for model: {self.relation_name}"
+                f" with session description: {self.session_description}."
             )
             return self.start_session()
         else:
@@ -147,13 +158,15 @@ def get_session_id(self, session_query_capacity: int = 1) -> UUID:
             )
             if matching_session_id:
                 LOGGER.debug(
-                    f"Over thread limit, matching session found for model: {self.relation_name} with session description: {self.session_description} and has capacity."
+                    f"Over thread limit, matching session found for model: {self.relation_name}"
+                    f" with session description: {self.session_description} and has capacity."
                 )
                 self.set_spark_session_load(str(matching_session_id), 1)
                 return matching_session_id
             else:
                 LOGGER.debug(
-                    f"Over thread limit, matching session not found or found with over capacity. Creating new session for model: {self.relation_name} with session description: {self.session_description}."
+                    f"Over thread limit, matching session not found or found with over capacity. Creating new session"
+                    f" for model: {self.relation_name} with session description: {self.session_description}."
                 )
                 return self.start_session()
 
@@ -203,13 +216,14 @@ def poll_until_session_creation(self, session_id: str) -> None:
         """
         polling_interval = self.polling_interval
         while True:
-            timer = 0
+            timer: float = 0
             creation_status_response = self.get_session_status(session_id)
             creation_status_state = creation_status_response.get("State", "")
             creation_status_reason = creation_status_response.get("StateChangeReason", "")
             if creation_status_state in ["FAILED", "TERMINATED", "DEGRADED"]:
                 raise DbtRuntimeError(
-                    f"Unable to create session: {session_id}. Got status: {creation_status_state} with reason: {creation_status_reason}."
+                    f"Unable to create session: {session_id}. Got status: {creation_status_state}"
+                    f" with reason: {creation_status_reason}."
                 )
             elif creation_status_state == "IDLE":
                 LOGGER.debug(f"Session: {session_id} created")
diff --git a/dbt/include/athena/macros/adapters/python_submissions.sql b/dbt/include/athena/macros/adapters/python_submissions.sql
index 137b117c..f668acf7 100644
--- a/dbt/include/athena/macros/adapters/python_submissions.sql
+++ b/dbt/include/athena/macros/adapters/python_submissions.sql
@@ -10,7 +10,7 @@
     {% set bucket_count = optional_args.get("bucket_count") %}
     {% set field_delimiter = optional_args.get("field_delimiter") %}
     {% set spark_ctas = optional_args.get("spark_ctas", "") %}
-    
+
 import pyspark
 
 
@@ -50,7 +50,7 @@ def materialize(spark_session, df, target_relation):
         name="{{ target_relation.schema}}.{{ target_relation.identifier }}",
     )
 {% endif %}
-    
+
     return "Success: {{ target_relation.schema}}.{{ target_relation.identifier }}"
 
 {{ athena__py_get_spark_dbt_object() }}
diff --git a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
index 5b9b9b94..64a8a31b 100644
--- a/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
+++ b/dbt/include/athena/macros/materializations/models/table/create_table_as.sql
@@ -70,7 +70,7 @@
 
           as
       {%- endset -%}
-    {%- endif -%} 
+    {%- endif -%}
 
     {# {% do log('Creating table with spark and compiled code: ' ~ compiled_code) %} #}
     {{ athena__py_save_table_as(
@@ -111,7 +111,7 @@
       {%- endif -%}
     {%- endif %}
 
-    create table {{ relation }} 
+    create table {{ relation }}
     with (
       table_type='{{ table_type }}',
       is_external={%- if table_type == 'iceberg' -%}false{%- else -%}true{%- endif %},
diff --git a/tests/unit/constants.py b/tests/unit/constants.py
index fc2a505f..f549ad64 100644
--- a/tests/unit/constants.py
+++ b/tests/unit/constants.py
@@ -8,4 +8,4 @@
 S3_STAGING_DIR = "s3://my-bucket/test-dbt/"
 S3_TMP_TABLE_DIR = "s3://my-bucket/test-dbt-temp/"
 ATHENA_WORKGROUP = "dbt-athena-adapter"
-SPARK_WORKGROUP = "spark"
\ No newline at end of file
+SPARK_WORKGROUP = "spark"

From 53689812d4b1ce2521afdcce90c5b9fbe72edd58 Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Fri, 12 Jan 2024 20:07:22 -0500
Subject: [PATCH 70/75] fix: 3.9 compatability

---
 dbt/adapters/athena/session.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index fb19905d..3feaa0f5 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -55,7 +55,7 @@ def __init__(
         timeout: int,
         polling_interval: float,
         engine_config: Dict[str, int],
-        relation_name: str | None = None,
+        relation_name: str = "N/A",
     ) -> None:
         """
         Initialize the AthenaSparkSessionManager instance.

From e1e80dc80a9709f920bab4a2cc8a4390c613ffad Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Fri, 12 Jan 2024 21:08:03 -0500
Subject: [PATCH 71/75] chore: readme update config for spark iceberg model
 example

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 36aa7242..72dfcbdd 100644
--- a/README.md
+++ b/README.md
@@ -640,11 +640,11 @@ def model(dbt, spark_session):
         engine_config={
             "CoordinatorDpuSize": 1,
             "MaxConcurrentDpus": 3,
-            "DefaultExecutorDpuSize": 1,
-            "spark_encryption": True,
-            "spark_cross_account_catalog": True,
-            "spark_requester_pays": True
+            "DefaultExecutorDpuSize": 1
         },
+        spark_encryption=True,
+        spark_cross_account_catalog=True,
+        spark_requester_pays=True
         polling_interval=15,
         timeout=120,
     )

From e3eb14948f8561337c2134fd26182d7c83412ecd Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Sun, 14 Jan 2024 19:01:09 -0500
Subject: [PATCH 72/75] fix: test config and remove obselete functions' tests

---
 tests/unit/test_config.py  |  11 +-
 tests/unit/test_session.py | 204 -------------------------------------
 2 files changed, 8 insertions(+), 207 deletions(-)

diff --git a/tests/unit/test_config.py b/tests/unit/test_config.py
index 61005a8f..1e66b906 100644
--- a/tests/unit/test_config.py
+++ b/tests/unit/test_config.py
@@ -104,6 +104,11 @@ def test_set_polling_interval(self, spark_config_helper):
     )
     def test_set_engine_config(self, spark_config_helper):
         engine_config = spark_config_helper.set_engine_config()
-        assert engine_config == spark_config_helper.config.get(
-            "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
-        )
+        diff = set(engine_config.keys()) - {
+            "CoordinatorDpuSize",
+            "MaxConcurrentDpus",
+            "DefaultExecutorDpuSize",
+            "SparkProperties",
+            "AdditionalConfigs",
+        }
+        assert len(diff) == 0
diff --git a/tests/unit/test_session.py b/tests/unit/test_session.py
index 539b6f25..c5c6fb61 100644
--- a/tests/unit/test_session.py
+++ b/tests/unit/test_session.py
@@ -75,59 +75,6 @@ def spark_session_manager(self, athena_credentials, athena_client, monkeypatch):
         monkeypatch.setattr(mock_session_manager, "athena_client", athena_client)
         return mock_session_manager
 
-    @pytest.mark.parametrize(
-        "session_status_response, expected_response",
-        [
-            pytest.param(
-                {
-                    "Sessions": [
-                        {
-                            "SessionId": "635c1c6d-766c-408b-8bce-fae8ea7006f7",
-                            "Status": {
-                                "StartDateTime": "number",
-                                "State": "IDLE",
-                            },
-                        }
-                    ],
-                },
-                [UUID("635c1c6d-766c-408b-8bce-fae8ea7006f7")],
-            ),
-            (
-                {
-                    "Sessions": [],
-                },
-                [],
-            ),
-            (
-                {},
-                [],
-            ),
-        ],
-    )
-    def test_list_sessions(
-        self, session_status_response, expected_response, spark_session_manager, athena_client
-    ) -> None:
-        """
-        Test the _list_sessions method of the AthenaJobHelper class.
-
-        Args:
-            session_status_response (dict): The response object to be returned by the mock Athena client.
-            expected_response (dict): The expected output of the _list_sessions method.
-            athena_job_helper (AthenaPythonJobHelper): An instance of the AthenaPythonJobHelper class.
-            athena_client (Mock): A mock instance of the Athena client.
-
-        Returns:
-            None: This function only asserts the output of the _list_sessions method.
-
-        Raises:
-            AssertionError: If the output of the _list_sessions method does not match the expected output.
-        """
-        with patch.object(athena_client, "list_sessions", return_value=session_status_response), patch.object(
-            AthenaSparkSessionManager, "start_session", return_value=UUID("635c1c6d-766c-408b-8bce-fae8ea7006f7")
-        ):
-            response = spark_session_manager.list_sessions()
-            assert response == expected_response
-
     @pytest.mark.parametrize(
         "session_status_response, expected_response",
         [
@@ -225,156 +172,5 @@ def test_get_session_status(self, session_status_response, expected_status, spar
             response = spark_session_manager.get_session_status("test_session_id")
             assert response == expected_status
 
-    @pytest.mark.parametrize(
-        "list_sessions_response, spark_session_locks, expected_new_sessions",
-        [
-            (
-                [
-                    UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"),
-                    UUID("39cb8fc0-f855-4b67-91f1-81f068499071"),
-                ],
-                {"test_session_id": None},
-                [
-                    UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"),
-                    UUID("39cb8fc0-f855-4b67-91f1-81f068499071"),
-                ],
-            ),
-            (
-                [],
-                {},
-                [UUID("39cb8fc0-f855-4b67-91f1-81f068499071")],
-            ),
-            (
-                [UUID("106d7aca-4b3f-468d-a81d-308120e7f73c")],
-                {UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): "lock"},
-                [UUID("39cb8fc0-f855-4b67-91f1-81f068499071")],
-            ),
-        ],
-    )
-    def test_get_sessions(
-        self,
-        list_sessions_response,
-        spark_session_locks,
-        expected_new_sessions,
-        spark_session_manager,
-        athena_client,
-        monkeypatch,
-    ):
-        """
-        Test the get_sessions function.
-
-        Args:
-            self: The test class instance.
-            list_sessions_response (list): The response from list_sessions.
-            spark_session_locks (dict): The session locks.
-            spark_session_manager: The Spark session manager object.
-            athena_client: The Athena client object.
-            monkeypatch: The monkeypatch object for mocking.
-
-        Returns:
-            None
-
-        Raises:
-            AssertionError: If the retrieved sessions are not correct.
-        """
-        monkeypatch.setattr(session, "spark_session_locks", spark_session_locks)
-        with patch.multiple(
-            spark_session_manager,
-            list_sessions=Mock(return_value=list_sessions_response),
-            poll_until_session_creation=Mock(return_value="IDLE"),
-            start_session=Mock(return_value=UUID("39cb8fc0-f855-4b67-91f1-81f068499071")),
-        ):
-            sessions = spark_session_manager.get_new_sessions()
-            assert sessions == expected_new_sessions
-
-    @pytest.mark.parametrize(
-        "get_session_response, current_spark_session_locks",
-        [([], {}), ([UUID("106d7aca-4b3f-468d-a81d-308120e7f73c")], {})],
-    )
-    def test_update_spark_session_locks(
-        self, get_session_response, current_spark_session_locks, spark_session_manager, monkeypatch
-    ):
-        """
-        Test the update_spark_session_locks function.
-
-        Args:
-            self: The test class instance.
-            get_session_response (list): The response from get_sessions.
-            current_spark_session_locks (dict): The current session locks.
-            spark_session_manager: The Spark session manager object.
-            monkeypatch: The monkeypatch object for mocking.
-
-        Raises:
-            AssertionError: If the session locks are not updated correctly.
-        """
-        monkeypatch.setattr(session, "spark_session_locks", current_spark_session_locks)
-        with patch.multiple(
-            spark_session_manager,
-            get_new_sessions=Mock(return_value=get_session_response),
-        ):
-            spark_session_manager.update_spark_session_locks()
-            for each_session in get_session_response:
-                assert each_session in session.spark_session_list.keys()
-                assert type(session.spark_session_list[each_session]) is not None
-
     def test_get_session_id(self):
         pass
-
-    @pytest.mark.parametrize(
-        "test_session_id, get_session_status_response, current_spark_session_locks, terminate_session_response",
-        [
-            (
-                "106d7aca-4b3f-468d-a81d-308120e7f73c",
-                {
-                    "State": "string",
-                },
-                {UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): Mock()},
-                {"State": "TERMINATED"},
-            ),
-            (
-                "106d7aca-4b3f-468d-a81d-308120e7f73c",
-                {
-                    "State": "string",
-                },
-                {UUID("106d7aca-4b3f-468d-a81d-308120e7f73c"): Mock()},
-                {"State": "CREATED"},
-            ),
-        ],
-    )
-    def test_release_session_lock(
-        self,
-        test_session_id,
-        get_session_status_response,
-        current_spark_session_locks,
-        terminate_session_response,
-        spark_session_manager,
-        athena_client,
-        monkeypatch,
-    ):
-        """
-        Test the release_session_lock function.
-
-        Args:
-            self: The test class instance.
-            test_session_id (str): The ID of the test session.
-            get_session_status_response (dict): The response from get_session_status.
-            current_spark_session_locks (dict): The current session locks.
-            terminate_session_response (dict): The response from terminate_session.
-            spark_session_manager: The Spark session manager object.
-            athena_client: The Athena client object.
-            monkeypatch: The monkeypatch object for mocking.
-
-        Raises:
-            AssertionError: If the session lock is not released correctly.
-        """
-        monkeypatch.setattr(session, "spark_session_locks", current_spark_session_locks)
-        with patch.multiple(
-            spark_session_manager,
-            get_session_status=Mock(return_value=get_session_status_response),
-        ), patch.multiple(
-            athena_client,
-            terminate_session=Mock(return_value=terminate_session_response),
-        ):
-            spark_session_manager.release_session_lock(test_session_id)
-            assert UUID(test_session_id) in session.spark_session_list.keys()
-            assert type(session.spark_session_list[UUID(test_session_id)]) is not None

From 7c458444928c5213e307b732827f1d36e1070a4e Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Mon, 15 Jan 2024 09:33:21 -0500
Subject: [PATCH 73/75] fix: precommit

---
 tests/unit/test_session.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/unit/test_session.py b/tests/unit/test_session.py
index c5c6fb61..6638d605 100644
--- a/tests/unit/test_session.py
+++ b/tests/unit/test_session.py
@@ -4,7 +4,7 @@
 import botocore.session
 import pytest
 
-from dbt.adapters.athena import AthenaCredentials, session
+from dbt.adapters.athena import AthenaCredentials
 from dbt.adapters.athena.session import AthenaSparkSessionManager, get_boto3_session
 from dbt.contracts.connection import Connection
 from dbt.exceptions import DbtRuntimeError

From e571f6aa9d91f84d48c8de31e3adb2efa442e52b Mon Sep 17 00:00:00 2001
From: snagapuri <sankeerth.kumarnagapuri@modernatx.com>
Date: Tue, 16 Jan 2024 22:21:17 -0500
Subject: [PATCH 74/75] fix: unit tests

---
 dbt/adapters/athena/python_submissions.py |  4 +--
 dbt/adapters/athena/session.py            |  2 +-
 tests/unit/test_python_submissions.py     | 31 +++++++++++------------
 3 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/dbt/adapters/athena/python_submissions.py b/dbt/adapters/athena/python_submissions.py
index fa79bd21..4fe8fa0f 100644
--- a/dbt/adapters/athena/python_submissions.py
+++ b/dbt/adapters/athena/python_submissions.py
@@ -166,8 +166,8 @@ def poll_until_session_idle(self) -> None:
             DbtRuntimeError: If the session chosen is not available or if it does not become idle within the timeout.
         """
         polling_interval = self.polling_interval
+        timer: float = 0
         while True:
-            timer: float = 0
             session_status = self.get_current_session_status()["State"]
             if session_status in ["TERMINATING", "TERMINATED", "DEGRADED", "FAILED"]:
                 LOGGER.debug(
@@ -214,8 +214,8 @@ def poll_until_execution_completion(self, calculation_execution_id: str) -> Any:
         """
         try:
             polling_interval = self.polling_interval
+            timer: float = 0
             while True:
-                timer: float = 0
                 execution_response = self.athena_client.get_calculation_execution(
                     CalculationExecutionId=calculation_execution_id
                 )
diff --git a/dbt/adapters/athena/session.py b/dbt/adapters/athena/session.py
index 3feaa0f5..39594938 100644
--- a/dbt/adapters/athena/session.py
+++ b/dbt/adapters/athena/session.py
@@ -215,8 +215,8 @@ def poll_until_session_creation(self, session_id: str) -> None:
 
         """
         polling_interval = self.polling_interval
+        timer: float = 0
         while True:
-            timer: float = 0
             creation_status_response = self.get_session_status(session_id)
             creation_status_state = creation_status_response.get("State", "")
             creation_status_reason = creation_status_response.get("StateChangeReason", "")
diff --git a/tests/unit/test_python_submissions.py b/tests/unit/test_python_submissions.py
index 73189943..65961d60 100644
--- a/tests/unit/test_python_submissions.py
+++ b/tests/unit/test_python_submissions.py
@@ -1,4 +1,5 @@
 import time
+import uuid
 from unittest.mock import Mock, patch
 
 import pytest
@@ -17,12 +18,14 @@ class TestAthenaPythonJobHelper:
 
     @pytest.fixture
     def parsed_model(self, request):
+        config: dict[str, int] = request.param.get("config", {"timeout": 1, "polling_interval": 5})
+
         return {
             "alias": "test_model",
             "schema": DATABASE_NAME,
             "config": {
-                "timeout": request.param.get("timeout", 7200),
-                "polling_interval": request.param.get("polling_interval", 5),
+                "timeout": config["timeout"],
+                "polling_interval": config["polling_interval"],
                 "engine_config": request.param.get(
                     "engine_config", {"CoordinatorDpuSize": 1, "MaxConcurrentDpus": 2, "DefaultExecutorDpuSize": 1}
                 ),
@@ -146,10 +149,10 @@ def test_poll_execution(
     ):
         with patch.multiple(
             athena_spark_session_manager,
-            get_session_id=Mock(return_value="test_session_id"),
+            get_session_id=Mock(return_value=uuid.uuid4()),
         ), patch.multiple(
             athena_client,
-            get_calculation_execution_status=Mock(return_value=execution_status),
+            get_calculation_execution=Mock(return_value=execution_status),
         ):
 
             def mock_sleep(_):
@@ -160,26 +163,26 @@ def mock_sleep(_):
             assert poll_response == expected_response
 
     @pytest.mark.parametrize(
-        "parsed_model, test_calculation_execution_id, test_calculation_execution, test_calculation_execution_status",
+        "parsed_model, test_calculation_execution_id, test_calculation_execution",
         [
             pytest.param(
                 {"config": {"timeout": 1, "polling_interval": 5}},
                 {"CalculationExecutionId": "test_execution_id"},
-                {"Result": {"ResultS3Uri": "test_results_s3_uri"}},
-                {"Status": {"State": "COMPLETED"}},
+                {
+                    "Result": {"ResultS3Uri": "test_results_s3_uri"},
+                    "Status": {"State": "COMPLETED"},
+                },
             ),
             pytest.param(
                 {"config": {"timeout": 1, "polling_interval": 5}},
                 {"CalculationExecutionId": "test_execution_id"},
-                {"Result": {}},
-                {"Status": {"State": "FAILED"}},
+                {"Result": {}, "Status": {"State": "FAILED"}},
                 marks=pytest.mark.xfail,
             ),
             pytest.param(
                 {"config": {"timeout": 1, "polling_interval": 5}},
                 {},
-                {"Result": {}},
-                {"Status": {"State": "FAILED"}},
+                {"Result": {}, "Status": {"State": "FAILED"}},
                 marks=pytest.mark.xfail,
             ),
         ],
@@ -189,20 +192,16 @@ def test_submission(
         self,
         test_calculation_execution_id,
         test_calculation_execution,
-        test_calculation_execution_status,
         athena_job_helper,
         athena_spark_session_manager,
         athena_client,
     ):
         with patch.multiple(
-            athena_spark_session_manager,
-            get_session_id=Mock(return_value="test_session_id"),
-            release_session_lock=Mock(),
+            athena_spark_session_manager, get_session_id=Mock(return_value=uuid.uuid4())
         ), patch.multiple(
             athena_client,
             start_calculation_execution=Mock(return_value=test_calculation_execution_id),
             get_calculation_execution=Mock(return_value=test_calculation_execution),
-            get_calculation_execution_status=Mock(return_value=test_calculation_execution_status),
         ), patch.multiple(
             athena_job_helper, poll_until_session_idle=Mock(return_value="IDLE")
         ):

From cb4a999d2f506cf5ef19f452af0b4ba809428d99 Mon Sep 17 00:00:00 2001
From: Avinash Santhanagopalan <43074786+Avinash-1394@users.noreply.github.com>
Date: Fri, 19 Jan 2024 22:27:28 -0500
Subject: [PATCH 75/75] Comment out python submissions functional test

---
 .../adapter/test_python_submissions.py        | 178 +++++++++---------
 1 file changed, 89 insertions(+), 89 deletions(-)

diff --git a/tests/functional/adapter/test_python_submissions.py b/tests/functional/adapter/test_python_submissions.py
index 4011bc97..671f587f 100644
--- a/tests/functional/adapter/test_python_submissions.py
+++ b/tests/functional/adapter/test_python_submissions.py
@@ -1,89 +1,89 @@
-import pytest
-import yaml
-
-from dbt.tests.adapter.python_model.test_python_model import (
-    BasePythonIncrementalTests,
-    BasePythonModelTests,
-)
-from dbt.tests.util import run_dbt
-
-basic_sql = """
-{{ config(materialized="table") }}
-select 1 as column_1, 2 as column_2, '{{ run_started_at.strftime("%Y-%m-%d") }}' as run_date
-"""
-
-basic_python = """
-def model(dbt, spark):
-    dbt.config(
-        materialized='table',
-    )
-    df =  dbt.ref("model")
-    return df
-"""
-
-basic_spark_python = """
-def model(dbt, spark_session):
-    dbt.config(materialized="table")
-
-    data = [(1,), (2,), (3,), (4,)]
-
-    df = spark_session.createDataFrame(data, ["A"])
-
-    return df
-"""
-
-second_sql = """
-select * from {{ref('my_python_model')}}
-"""
-
-schema_yml = """version: 2
-models:
-  - name: model
-    versions:
-      - v: 1
-"""
-
-
-class TestBasePythonModelTests(BasePythonModelTests):
-    @pytest.fixture(scope="class")
-    def models(self):
-        return {
-            "schema.yml": schema_yml,
-            "model.sql": basic_sql,
-            "my_python_model.py": basic_python,
-            "spark_model.py": basic_spark_python,
-            "second_sql_model.sql": second_sql,
-        }
-
-
-incremental_python = """
-def model(dbt, spark_session):
-    dbt.config(materialized="incremental")
-    df = dbt.ref("model")
-
-    if dbt.is_incremental:
-        max_from_this = (
-            f"select max(run_date) from {dbt.this.schema}.{dbt.this.identifier}"
-        )
-        df = df.filter(df.run_date >= spark_session.sql(max_from_this).collect()[0][0])
-
-    return df
-"""
-
-
-class TestBasePythonIncrementalTests(BasePythonIncrementalTests):
-    @pytest.fixture(scope="class")
-    def project_config_update(self):
-        return {"models": {"+incremental_strategy": "append"}}
-
-    @pytest.fixture(scope="class")
-    def models(self):
-        return {"model.sql": basic_sql, "incremental.py": incremental_python}
-
-    def test_incremental(self, project):
-        vars_dict = {
-            "test_run_schema": project.test_schema,
-        }
-
-        results = run_dbt(["run", "--vars", yaml.safe_dump(vars_dict)])
-        assert len(results) == 2
+# import pytest
+# import yaml
+
+# from dbt.tests.adapter.python_model.test_python_model import (
+#     BasePythonIncrementalTests,
+#     BasePythonModelTests,
+# )
+# from dbt.tests.util import run_dbt
+
+# basic_sql = """
+# {{ config(materialized="table") }}
+# select 1 as column_1, 2 as column_2, '{{ run_started_at.strftime("%Y-%m-%d") }}' as run_date
+# """
+
+# basic_python = """
+# def model(dbt, spark):
+#     dbt.config(
+#         materialized='table',
+#     )
+#     df =  dbt.ref("model")
+#     return df
+# """
+
+# basic_spark_python = """
+# def model(dbt, spark_session):
+#     dbt.config(materialized="table")
+
+#     data = [(1,), (2,), (3,), (4,)]
+
+#     df = spark_session.createDataFrame(data, ["A"])
+
+#     return df
+# """
+
+# second_sql = """
+# select * from {{ref('my_python_model')}}
+# """
+
+# schema_yml = """version: 2
+# models:
+#   - name: model
+#     versions:
+#       - v: 1
+# """
+
+
+# class TestBasePythonModelTests(BasePythonModelTests):
+#     @pytest.fixture(scope="class")
+#     def models(self):
+#         return {
+#             "schema.yml": schema_yml,
+#             "model.sql": basic_sql,
+#             "my_python_model.py": basic_python,
+#             "spark_model.py": basic_spark_python,
+#             "second_sql_model.sql": second_sql,
+#         }
+
+
+# incremental_python = """
+# def model(dbt, spark_session):
+#     dbt.config(materialized="incremental")
+#     df = dbt.ref("model")
+
+#     if dbt.is_incremental:
+#         max_from_this = (
+#             f"select max(run_date) from {dbt.this.schema}.{dbt.this.identifier}"
+#         )
+#         df = df.filter(df.run_date >= spark_session.sql(max_from_this).collect()[0][0])
+
+#     return df
+# """
+
+
+# class TestBasePythonIncrementalTests(BasePythonIncrementalTests):
+#     @pytest.fixture(scope="class")
+#     def project_config_update(self):
+#         return {"models": {"+incremental_strategy": "append"}}
+
+#     @pytest.fixture(scope="class")
+#     def models(self):
+#         return {"model.sql": basic_sql, "incremental.py": incremental_python}
+
+#     def test_incremental(self, project):
+#         vars_dict = {
+#             "test_run_schema": project.test_schema,
+#         }
+
+#         results = run_dbt(["run", "--vars", yaml.safe_dump(vars_dict)])
+#         assert len(results) == 2