mage-ai 0.8.37__py3-none-any.whl → 0.8.39__py3-none-any.whl

mage_ai/api/logging.py

@@ -1,7 +1,7 @@
 from datetime import datetime
-import logging
+from mage_ai.server.logger import Logger
 
-LOGGER = logging.getLogger(__name__)
+LOGGER = Logger().new_server_logger(__name__)
 
 
 def debug(text):

mage_ai/api/resources/PipelineRunResource.py

@@ -6,7 +6,7 @@ from mage_ai.data_preparation.models.constants import PipelineType
 from mage_ai.data_preparation.models.pipeline import Pipeline
 from mage_ai.orchestration.db import safe_db_query
 from mage_ai.orchestration.db.models.schedules import BlockRun, PipelineRun
-from mage_ai.orchestration.pipeline_scheduler import get_variables
+from mage_ai.orchestration.pipeline_scheduler import get_variables, stop_pipeline_run
 from sqlalchemy.orm import selectinload
 
 
@@ -219,8 +219,11 @@ class PipelineRunResource(DatabaseResource):
 
             return super().update(dict(status=PipelineRun.PipelineRunStatus.RUNNING))
         elif PipelineRun.PipelineRunStatus.CANCELLED == payload.get('status'):
-            from mage_ai.orchestration.pipeline_scheduler import PipelineScheduler
+            pipeline = Pipeline.get(
+                self.model.pipeline_uuid,
+                check_if_exists=True,
+            )
 
-            PipelineScheduler(self.model).stop()
+            stop_pipeline_run(self.model, pipeline)
 
         return self

mage_ai/data_integrations/sources/constants.py

@@ -23,6 +23,7 @@ SOURCES = sorted([
     dict(name='Facebook Ads'),
     dict(name='Freshdesk'),
     dict(name='Front'),
+    dict(name='Google Ads'),
     dict(name='Google Analytics'),
     dict(name='Google Search Console'),
     dict(name='Google Sheets'),

mage_ai/data_preparation/models/block/dbt/__init__.py

@@ -4,6 +4,7 @@ from mage_ai.data_preparation.models.block.dbt.utils import (
     create_upstream_tables,
     fetch_model_data,
     load_profiles_async,
+    load_profiles_file,
     parse_attributes,
     query_from_compiled_sql,
     run_dbt_tests,
@@ -15,7 +16,9 @@ from mage_ai.shared.hash import merge_dict
 from typing import Any, Dict, List
 import json
 import os
+import shutil
 import subprocess
+import yaml
 
 
 class DBTBlock(Block):
@@ -120,8 +123,20 @@ class DBTBlock(Block):
             test_execution=test_execution,
         )
         project_full_path = command_line_dict['project_full_path']
+        profiles_dir = command_line_dict['profiles_dir']
         dbt_profile_target = command_line_dict['profile_target']
 
+        # Create a temporary profiles file with variables and secrets interpolated
+        attributes_dict = parse_attributes(self)
+        profiles_full_path = attributes_dict['profiles_full_path']
+        profile = load_profiles_file(profiles_full_path)
+
+        temp_profile_full_path = f'{profiles_dir}/profiles.yml'
+        os.makedirs(os.path.dirname(temp_profile_full_path), exist_ok=True)
+
+        with open(temp_profile_full_path, 'w') as f:
+            yaml.safe_dump(profile, f)
+
         is_sql = BlockLanguage.SQL == self.language
         if is_sql:
             create_upstream_tables(
@@ -214,4 +229,9 @@ class DBTBlock(Block):
                 )
                 outputs = [df]
 
+        try:
+            shutil.rmtree(profiles_dir)
+        except Exception as err:
+            print(f'Error removing temporary profile at {temp_profile_full_path}: {err}')
+
         return outputs

mage_ai/data_preparation/models/block/dbt/utils/__init__.py

@@ -912,11 +912,13 @@ def build_command_line_arguments(
         project_full_path = f'{get_repo_path()}/dbt/{project_name}'
         args += block.content.split(' ')
 
+    profiles_dir = f'{project_full_path}/.mage_temp_profiles'
+
     args += [
         '--project-dir',
         project_full_path,
         '--profiles-dir',
-        project_full_path,
+        profiles_dir,
     ]
 
     dbt_profile_target = block.configuration.get('dbt_profile_target') \
@@ -934,6 +936,7 @@ def build_command_line_arguments(
 
     return dbt_command, args, dict(
         profile_target=dbt_profile_target,
+        profiles_dir=profiles_dir,
         project_full_path=project_full_path,
     )
 

mage_ai/data_preparation/models/pipeline.py

@@ -180,10 +180,19 @@ class Pipeline:
         )
 
     @classmethod
-    def get(self, uuid, repo_path: str = None):
+    def get(self, uuid, repo_path: str = None, check_if_exists: bool = False):
         from mage_ai.data_preparation.models.pipelines.integration_pipeline \
             import IntegrationPipeline
 
+        if check_if_exists and not os.path.exists(
+            os.path.join(
+                repo_path or get_repo_path(),
+                PIPELINES_FOLDER,
+                uuid,
+            ),
+        ):
+            return None
+
         pipeline = self(uuid, repo_path=repo_path)
         if PipelineType.INTEGRATION == pipeline.type:
             pipeline = IntegrationPipeline(uuid, repo_path=repo_path)

mage_ai/io/base.py

@@ -275,9 +275,9 @@ class BaseSQLDatabase(BaseIO):
         """
         return query_string.strip(' \n\t')
 
-    def _clean_column_name(self, column_name: str) -> str:
+    def _clean_column_name(self, column_name: str, allow_reserved_words: bool = False) -> str:
         col_new = re.sub(r'\W', '_', column_name.lower())
-        if col_new.upper() in SQL_RESERVED_WORDS:
+        if not allow_reserved_words and col_new.upper() in SQL_RESERVED_WORDS:
             col_new = f'_{col_new}'
         return col_new
 

mage_ai/io/constants.py

@@ -841,3 +841,6 @@ SQL_RESERVED_WORDS_SUBSET = {
     'USER',
     'WHERE',
 }
+
+UNIQUE_CONFLICT_METHOD_IGNORE = 'IGNORE'
+UNIQUE_CONFLICT_METHOD_UPDATE = 'UPDATE'

mage_ai/io/export_utils.py

@@ -2,7 +2,7 @@ from enum import Enum
 from mage_ai.shared.utils import clean_name
 from pandas import DataFrame, Series
 from pandas.api.types import infer_dtype
-from typing import Callable, Dict, Mapping
+from typing import Callable, Dict, List, Mapping
 
 """
 Utilities for exporting Python data frames to external databases.
@@ -31,6 +31,7 @@ class PandasTypes(str, Enum):
     DATETIME64 = 'datetime64'
     DECIMAL = 'decimal'
     INTEGER = 'integer'
+    INT64 = 'int64'
     EMPTY = 'empty'
     FLOATING = 'floating'
     MIXED = 'mixed'
@@ -101,6 +102,7 @@ def gen_table_creation_query(
     dtypes: Mapping[str, str],
     schema_name: str,
     table_name: str,
+    unique_constraints: List[str] = [],
 ) -> str:
     """
     Generates a database table creation query from a data frame.
@@ -123,4 +125,15 @@ def gen_table_creation_query(
     else:
         full_table_name = table_name
 
+    if unique_constraints:
+        unique_constraints_clean = [clean_name(col) for col in unique_constraints]
+        unique_constraints_escaped = [f'"{col}"'
+                                      for col in unique_constraints_clean]
+        index_name = '_'.join([
+            clean_name(full_table_name),
+        ] + unique_constraints_clean)
+        index_name = f'unique{index_name}'[:64]
+        query.append(
+            f"CONSTRAINT {index_name} UNIQUE ({', '.join(unique_constraints_escaped)})",
+        )
     return f'CREATE TABLE {full_table_name} (' + ','.join(query) + ');'

mage_ai/io/mssql.py

@@ -3,7 +3,7 @@ from mage_ai.io.export_utils import PandasTypes
 from mage_ai.io.base import QUERY_ROW_LIMIT
 from mage_ai.io.sql import BaseSQL
 from pandas import DataFrame, Series
-from typing import Any, IO, Union
+from typing import Any, IO, List, Union
 import json
 import numpy as np
 import pyodbc
@@ -87,8 +87,11 @@ class MSSQL(BaseSQL):
         self,
         cursor: Any,
         df: DataFrame,
+        db_dtypes: List[str],
+        dtypes: List[str],
         full_table_name: str,
-        buffer: Union[IO, None] = None
+        buffer: Union[IO, None] = None,
+        **kwargs,
     ) -> None:
         values_placeholder = ', '.join(["?" for i in range(len(df.columns))])
         values = []

mage_ai/io/mysql.py

@@ -5,7 +5,7 @@ from mage_ai.shared.utils import clean_name
 from mysql.connector import connect
 from mysql.connector.cursor import MySQLCursor
 from pandas import DataFrame, Series
-from typing import IO, Mapping, Union
+from typing import IO, List, Mapping, Union
 import numpy as np
 
 
@@ -47,7 +47,8 @@ class MySQL(BaseSQL):
         self,
         dtypes: Mapping[str, str],
         schema_name: str,
-        table_name: str
+        table_name: str,
+        unique_constraints: List[str] = [],
     ) -> str:
         query = []
         for cname in dtypes:
@@ -73,8 +74,11 @@ class MySQL(BaseSQL):
         self,
         cursor: MySQLCursor,
         df: DataFrame,
+        db_dtypes: List[str],
+        dtypes: List[str],
         full_table_name: str,
-        buffer: Union[IO, None] = None
+        buffer: Union[IO, None] = None,
+        **kwargs,
     ) -> None:
         values_placeholder = ', '.join(["%s" for i in range(len(df.columns))])
         values = []

mage_ai/io/postgres.py

@@ -1,4 +1,5 @@
 from mage_ai.io.config import BaseConfigLoader, ConfigKey
+from mage_ai.io.constants import UNIQUE_CONFLICT_METHOD_UPDATE
 from mage_ai.io.export_utils import BadConversionError, PandasTypes
 from mage_ai.io.sql import BaseSQL
 from mage_ai.shared.parsers import encode_complex
@@ -6,12 +7,21 @@ from mage_ai.shared.utils import is_port_in_use
 from pandas import DataFrame, Series
 from psycopg2 import connect, _psycopg
 from sshtunnel import SSHTunnelForwarder
-from typing import Union, IO
+from typing import IO, List, Union
 import numpy as np
 import pandas as pd
 import simplejson
 
 
+JSON_SERIALIZABLE_TYPES = frozenset([
+    PandasTypes.DATE,
+    PandasTypes.DATETIME,
+    PandasTypes.DATETIME64,
+    PandasTypes.OBJECT,
+    PandasTypes.TIME,
+])
+
+
 class Postgres(BaseSQL):
     """
     Handles data transfer between a PostgreSQL database and the Mage app.
@@ -159,9 +169,9 @@ class Postgres(BaseSQL):
             column_type = None
 
             if len(values) >= 1:
-                value = values[0]
                 column_type = 'JSONB'
 
+                value = values[0]
                 if type(value) is list:
                     if len(value) >= 1:
                         item = value[0]
@@ -204,7 +214,7 @@ class Postgres(BaseSQL):
             return 'bytea'
         elif dtype in (PandasTypes.FLOATING, PandasTypes.DECIMAL, PandasTypes.MIXED_INTEGER_FLOAT):
             return 'double precision'
-        elif dtype == PandasTypes.INTEGER:
+        elif dtype == PandasTypes.INTEGER or dtype == PandasTypes.INT64:
             max_int, min_int = column.max(), column.min()
             if np.int16(max_int) == max_int and np.int16(min_int) == min_int:
                 return 'smallint'
@@ -229,9 +239,21 @@ class Postgres(BaseSQL):
         self,
         cursor: _psycopg.cursor,
         df: DataFrame,
+        db_dtypes: List[str],
+        dtypes: List[str],
         full_table_name: str,
-        buffer: Union[IO, None] = None
+        buffer: Union[IO, None] = None,
+        allow_reserved_words: bool = False,
+        unique_conflict_method: str = None,
+        unique_constraints: List[str] = None,
     ) -> None:
+        def clean_array_value(val):
+            if val is None or type(val) is not str or len(val) < 2:
+                return val
+            if val[0] == '[' and val[-1] == ']':
+                return '{' + val[1:-1] + '}'
+            return val
+
         df_ = df.copy()
         columns = df_.columns
 
@@ -239,28 +261,49 @@ class Postgres(BaseSQL):
             df_col_dropna = df_[col].dropna()
             if df_col_dropna.count() == 0:
                 continue
-            if PandasTypes.OBJECT == df_[col].dtype and type(df_col_dropna.iloc[0]) != str:
+            if dtypes[col] in JSON_SERIALIZABLE_TYPES \
+                    or (df_[col].dtype == PandasTypes.OBJECT and
+                        type(df_col_dropna.iloc[0]) != str):
                 df_[col] = df_[col].apply(lambda x: simplejson.dumps(
                     x,
                     default=encode_complex,
                     ignore_nan=True,
                 ))
+                if '[]' in db_dtypes[col]:
+                    df_[col] = df_[col].apply(lambda x: clean_array_value(x))
 
-        df_.to_csv(
-            buffer,
-            header=False,
-            index=False,
-            na_rep='',
-        )
+        values = []
 
-        buffer.seek(0)
+        for _, row in df_.iterrows():
+            t = tuple(row)
+            if len(t) == 1:
+                value = f'({str(t[0])})'
+            else:
+                value = str(t)
+            values.append(value.replace('None', 'NULL'))
+        values_string = ', '.join(values)
+        insert_columns = ', '.join([f'"{col}"'for col in columns])
+
+        commands = [
+            f'INSERT INTO {full_table_name} ({insert_columns})',
+            f'VALUES {values_string}',
+        ]
+        if unique_constraints and unique_conflict_method:
+            unique_constraints = \
+                [f'"{self._clean_column_name(col, allow_reserved_words=allow_reserved_words)}"'
+                 for col in unique_constraints]
+            columns_cleaned = \
+                [f'"{self._clean_column_name(col, allow_reserved_words=allow_reserved_words)}"'
+                 for col in columns]
 
-        columns_names = ', '.join(columns)
-        cursor.copy_expert(f"""
-COPY {full_table_name} FROM STDIN (
-    FORMAT csv
-    , DELIMITER \',\'
-    , NULL \'\'
-    , FORCE_NULL({columns_names})
-);
-    """, buffer)
+            commands.append(f"ON CONFLICT ({', '.join(unique_constraints)})")
+            if UNIQUE_CONFLICT_METHOD_UPDATE == unique_conflict_method:
+                update_command = [f'{col} = EXCLUDED.{col}' for col in columns_cleaned]
+                commands.append(
+                    f"DO UPDATE SET {', '.join(update_command)}",
+                )
+            else:
+                commands.append('DO NOTHING')
+        cursor.execute(
+            '\n'.join(commands)
+        )

mage_ai/io/sql.py

@@ -43,9 +43,15 @@ class BaseSQL(BaseSQLConnection):
         self,
         dtypes: Mapping[str, str],
         schema_name: str,
-        table_name: str
+        table_name: str,
+        unique_constraints: List[str] = [],
     ) -> str:
-        return gen_table_creation_query(dtypes, schema_name, table_name)
+        return gen_table_creation_query(
+            dtypes,
+            schema_name,
+            table_name,
+            unique_constraints=unique_constraints,
+        )
 
     def build_create_table_as_command(
         self,
@@ -80,6 +86,8 @@ class BaseSQL(BaseSQLConnection):
         self,
         cursor,
         df: DataFrame,
+        db_dtypes: List[str],
+        dtypes: List[str],
         full_table_name: str,
         buffer: Union[IO, None] = None
     ) -> None:
@@ -183,6 +191,9 @@ class BaseSQL(BaseSQLConnection):
         query_string: Union[str, None] = None,
         drop_table_on_replace: bool = False,
         cascade_on_drop: bool = False,
+        allow_reserved_words: bool = False,
+        unique_conflict_method: str = None,
+        unique_constraints: List[str] = None,
     ) -> None:
         """
         Exports dataframe to the connected database from a Pandas data frame. If table doesn't
@@ -221,7 +232,10 @@ class BaseSQL(BaseSQLConnection):
             df = clean_df_for_export(df, self.clean, dtypes)
 
             # Clean column names
-            col_mapping = {col: self._clean_column_name(col) for col in df.columns}
+            col_mapping = {col: self._clean_column_name(
+                                        col,
+                                        allow_reserved_words=allow_reserved_words)
+                           for col in df.columns}
             df = df.rename(columns=col_mapping)
             dtypes = infer_dtypes(df)
 
@@ -263,12 +277,27 @@ class BaseSQL(BaseSQLConnection):
                         )
                     cur.execute(query)
                 else:
+                    db_dtypes = {col: self.get_type(df[col], dtypes[col]) for col in dtypes}
                     if should_create_table:
-                        db_dtypes = {col: self.get_type(df[col], dtypes[col]) for col in dtypes}
-                        query = self.build_create_table_command(db_dtypes, schema_name, table_name)
+                        query = self.build_create_table_command(
+                            db_dtypes,
+                            schema_name,
+                            table_name,
+                            unique_constraints=unique_constraints,
+                        )
                         cur.execute(query)
 
-                    self.upload_dataframe(cur, df, full_table_name, buffer)
+                    self.upload_dataframe(
+                        cur,
+                        df,
+                        db_dtypes,
+                        dtypes,
+                        full_table_name,
+                        buffer,
+                        allow_reserved_words=allow_reserved_words,
+                        unique_conflict_method=unique_conflict_method,
+                        unique_constraints=unique_constraints,
+                    )
             self.conn.commit()
 
         if verbose:

mage_ai/io/trino.py

@@ -15,7 +15,7 @@ from pandas import DataFrame, Series
 from trino.auth import BasicAuthentication
 from trino.dbapi import Connection, Cursor as CursorParent
 from trino.transaction import IsolationLevel
-from typing import IO, Mapping, Union
+from typing import IO, List, Mapping, Union
 import pandas as pd
 
 
@@ -86,7 +86,8 @@ class Trino(BaseSQL):
         self,
         dtypes: Mapping[str, str],
         schema_name: str,
-        table_name: str
+        table_name: str,
+        unique_constraints: List[str] = [],
     ):
         query = []
         for cname in dtypes:
@@ -123,8 +124,11 @@ class Trino(BaseSQL):
         self,
         cursor: Cursor,
         df: DataFrame,
+        db_dtypes: List[str],
+        dtypes: List[str],
         full_table_name: str,
-        buffer: Union[IO, None] = None
+        buffer: Union[IO, None] = None,
+        **kwargs,
     ) -> None:
         values = []
         for _, row in df.iterrows():

mage_ai/orchestration/pipeline_scheduler.py

@@ -81,35 +81,11 @@ class PipelineScheduler:
             self.schedule()
 
     def stop(self) -> None:
-        if self.pipeline_run.status not in [PipelineRun.PipelineRunStatus.INITIAL,
-                                            PipelineRun.PipelineRunStatus.RUNNING]:
-            return
-
-        self.pipeline_run.update(status=PipelineRun.PipelineRunStatus.CANCELLED)
-
-        # Cancel all the block runs
-        block_runs_to_cancel = []
-        running_blocks = []
-        for b in self.pipeline_run.block_runs:
-            if b.status in [
-                BlockRun.BlockRunStatus.INITIAL,
-                BlockRun.BlockRunStatus.QUEUED,
-                BlockRun.BlockRunStatus.RUNNING,
-            ]:
-                block_runs_to_cancel.append(b)
-            if b.status == BlockRun.BlockRunStatus.RUNNING:
-                running_blocks.append(b)
-        BlockRun.batch_update_status(
-            [b.id for b in block_runs_to_cancel],
-            BlockRun.BlockRunStatus.CANCELLED,
+        stop_pipeline_run(
+            self.pipeline_run,
+            self.pipeline,
         )
 
-        if self.pipeline.type in [PipelineType.INTEGRATION, PipelineType.STREAMING]:
-            job_manager.kill_pipeline_run_job(self.pipeline_run.id)
-        else:
-            for b in running_blocks:
-                job_manager.kill_block_run_job(b.id)
-
     def schedule(self, block_runs: List[BlockRun] = None) -> None:
         self.__run_heartbeat()
 
@@ -806,6 +782,40 @@ def run_pipeline(pipeline_run_id, variables, tags):
     )
 
 
+def stop_pipeline_run(
+    pipeline_run: PipelineRun,
+    pipeline: Pipeline = None,
+) -> None:
+    if pipeline_run.status not in [PipelineRun.PipelineRunStatus.INITIAL,
+                                   PipelineRun.PipelineRunStatus.RUNNING]:
+        return
+
+    pipeline_run.update(status=PipelineRun.PipelineRunStatus.CANCELLED)
+
+    # Cancel all the block runs
+    block_runs_to_cancel = []
+    running_blocks = []
+    for b in pipeline_run.block_runs:
+        if b.status in [
+            BlockRun.BlockRunStatus.INITIAL,
+            BlockRun.BlockRunStatus.QUEUED,
+            BlockRun.BlockRunStatus.RUNNING,
+        ]:
+            block_runs_to_cancel.append(b)
+        if b.status == BlockRun.BlockRunStatus.RUNNING:
+            running_blocks.append(b)
+    BlockRun.batch_update_status(
+        [b.id for b in block_runs_to_cancel],
+        BlockRun.BlockRunStatus.CANCELLED,
+    )
+
+    if pipeline and pipeline.type in [PipelineType.INTEGRATION, PipelineType.STREAMING]:
+        job_manager.kill_pipeline_run_job(pipeline_run.id)
+    else:
+        for b in running_blocks:
+            job_manager.kill_block_run_job(b.id)
+
+
 def check_sla():
     repo_pipelines = set(Pipeline.get_all_pipelines(get_repo_path()))
     pipeline_schedules = \

mage_ai/server/active_kernel.py

@@ -1,6 +1,9 @@
 from jupyter_client import KernelClient, KernelManager
 from jupyter_client.kernelspec import NoSuchKernel
 from mage_ai.server.kernels import DEFAULT_KERNEL_NAME, KernelName, kernel_managers
+from mage_ai.server.logger import Logger
+
+logger = Logger().new_server_logger(__name__)
 
 
 class ActiveKernel():
@@ -13,14 +16,14 @@ active_kernel = ActiveKernel()
 
 
 def switch_active_kernel(kernel_name: KernelName) -> None:
-    print(f'Switch active kernel: {kernel_name}')
+    logger.info(f'Switch active kernel: {kernel_name}')
     if kernel_managers[kernel_name].is_alive():
-        print(f'Kernel {kernel_name} is already alive.')
+        logger.info(f'Kernel {kernel_name} is already alive.')
         return
 
     for kernel in kernel_managers.values():
         if kernel.is_alive():
-            print(f'Shut down current kernel {kernel}.')
+            logger.info(f'Shut down current kernel {kernel}.')
             kernel.request_shutdown()
 
     try:

mage_ai/server/api/clusters.py

@@ -10,9 +10,12 @@ from mage_ai.cluster_manager.constants import (
     KUBE_NAMESPACE,
     KUBE_STORAGE_CLASS_NAME
 )
+from mage_ai.server.logger import Logger
 import os
 import yaml
 
+logger = Logger().new_server_logger(__name__)
+
 
 class ClusterType(str, Enum):
     EMR = 'emr'
@@ -32,7 +35,7 @@ class ApiInstancesHandler(BaseHandler):
                 ecs_instance_manager = EcsTaskManager(cluster_name)
                 instances = ecs_instance_manager.list_tasks()
             except Exception as e:
-                print(str(e))
+                logger.error(str(e))
                 instances = list()
         elif cluster_type == ClusterType.CLOUD_RUN:
             from mage_ai.cluster_manager.gcp.cloud_run_service_manager import CloudRunServiceManager

mage_ai/server/api/integration_sources.py

@@ -1,10 +1,13 @@
 from mage_ai.data_preparation.models.block import PYTHON_COMMAND
+from mage_ai.server.logger import Logger
 from typing import List, Dict
 import importlib
 import json
 import subprocess
 import traceback
 
+logger = Logger().new_server_logger(__name__)
+
 
 def get_collection(key: str, available_options: List[Dict]):
     collection = []
@@ -38,8 +41,8 @@ def get_collection(key: str, available_options: List[Dict]):
                     except Exception:
                         pass
             except Exception as err:
-                print(f"Failed to load source {d['uuid']}: {err}")
-                print(traceback.format_exc())
+                logger.error(f"Failed to load source {d['uuid']}: {err}")
+                logger.error(traceback.format_exc())
                 continue
 
         collection.append(d)

mage_ai/server/client/mage.py

@@ -1,10 +1,10 @@
 from mage_ai.shared.hash import merge_dict
+from mage_ai.server.logger import Logger
 
 import json
-import logging
 import requests
 
-logger = logging.getLogger(__name__)
+logger = Logger().new_server_logger(__name__)
 
 
 class Mage: