morin 0.2.6__tar.gz

morin-0.2.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Директ-ПРО
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

morin-0.2.6/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: morin
+Version: 0.2.6
+Summary: Помощь в подключениях и загрузке в БД
+Home-page: https://github.com/morinad/morin
+Author: Александр Морин
+Author-email: y.director@yandex.ru
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# morin

morin-0.2.6/README.md

@@ -0,0 +1 @@
+# morin

morin-0.2.6/morin/__init__.py

@@ -0,0 +1,3 @@
+from .wb_by_date import WBbyDate
+from .yd_by_date import YDbyDate
+from .ozon_by_date import OZONbyDate

morin-0.2.6/morin/clickhouse.py

@@ -0,0 +1,183 @@
+from .common import Common
+import requests
+from datetime import datetime,timedelta
+import clickhouse_connect
+import pandas as pd
+import os
+from dateutil import parser
+import time
+import logging
+import hashlib
+from io import StringIO
+import json
+import math
+
+class Clickhouse:
+    def __init__(self, logging_path:str, host: str, port: str, username: str, password: str, database: str, start:str, add_name:str, err429:bool, backfill_days:int, platform:str):
+        self.logging_path = logging_path
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.database = database
+        self.now = datetime.now()
+        self.start = start
+        self.add_name = add_name
+        self.err429 = err429
+        self.backfill_days = backfill_days
+        self.today = datetime.now().date()
+        self.platform = platform
+        self.common = Common(logging_path)
+        logging.basicConfig(filename=self.logging_path, level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+    # датафрейм, название таблицы -> вставка данных
+    def ch_insert(self, df, to_table):
+        try:
+            data_tuples = [tuple(x) for x in df.to_numpy()]
+            client = clickhouse_connect.get_client(host=self.host, port=self.port, username=self.username,
+                                                   password=self.password, database=self.database)
+            client.insert(to_table, data_tuples, column_names=df.columns.tolist())
+            print(f'Данные вставлены в CH, таблица {to_table}')
+            logging.info(f'Данные вставлены в CH, таблица {to_table}')
+            optimize_table = f"OPTIMIZE TABLE {to_table} FINAL"
+            client.command(optimize_table)
+        except Exception as e:
+            print(f'Ошибка вставки в CH: {e}')
+            logging.info(f'Ошибка вставки в CH: {e}')
+            raise
+        finally:
+            if client:
+                client.close()
+
+    def ch_execute(self, expression):
+        try:
+            client = clickhouse_connect.get_client(host=self.host, port=self.port, username=self.username, password=self.password, database=self.database)
+            client.command(expression)
+            disp_exp = expression.strip()[:17]+'...'
+            print(f'Выражение {disp_exp} выполнено')
+            logging.info(f'Выражение {disp_exp} выполнено')
+        except Exception as e:
+            print(f'Ошибка выражения {disp_exp}: {e}')
+            logging.info(f'Ошибка выражения {disp_exp}: {e}')
+        finally:
+            if client:
+                client.close()
+
+    # список словарей (данные)+уникальность+имятаблицы -> создание/изменение таблицы ch
+    def create_alter_ch(self, data, table_name, uniq_columns, partitions, mergetree):
+        try:
+            upload_list = self.common.analyze_column_types(data, uniq_columns, partitions)
+            upload_set = set(upload_list)
+            uploads = ''
+            for i in upload_list:
+                uploads += i + ',\n'
+            if partitions == '':
+                part_part =''
+            else:
+                part_part = f'PARTITION BY {partitions}'
+            create_table_query_campaigns = f'CREATE TABLE IF NOT EXISTS {table_name} (' + uploads + f'timeStamp DateTime ) ENGINE = {mergetree} ORDER BY ({uniq_columns}) {part_part}'
+            client = clickhouse_connect.get_client(host=self.host, port=self.port, username=self.username, password=self.password, database=self.database)
+            client.query(create_table_query_campaigns)
+            query = f"DESCRIBE TABLE {table_name};"
+            result = client.query(query)
+            columns_info = result.result_rows
+            current_set = set([f"{col[0]} {col[1]}" for col in columns_info])
+            diff = list(upload_set - current_set)
+            if len(diff) > 0:
+                start_alter_exp=f'ALTER TABLE {table_name} '
+                for d in diff:
+                    alter_exp =start_alter_exp + 'ADD COLUMN IF NOT EXISTS ' + d + ' AFTER timeStamp;'
+                    print(f'Попытка изменения {table_name}, Формула: {alter_exp}')
+                    logging.info(f'Попытка изменения {table_name}, Формула: {alter_exp}')
+                    client.query(alter_exp)
+                    print(f'Успешное изменение {table_name}, Формула: {alter_exp}')
+                    logging.info(f'Успешное изменение {table_name}, Формула: {alter_exp}')
+                    time.sleep(2)
+            else:
+                print(f'Данные готовы для вставки в {table_name}')
+                logging.info(f'Данные готовы для вставки в {table_name}')
+        except Exception as e:
+            print(f'Ошибка подготовки данных: {e}')
+            logging.info(f'Ошибка подготовки данных: {e}')
+
+
+    def get_missing_dates(self, table_name, report_name, start_date_str):
+        try:
+            start_date = datetime.strptime(start_date_str, '%Y-%m-%d').date()
+            query = f"""
+            SELECT date
+            FROM {table_name}
+            WHERE report = '{report_name}' and collect = True"""
+            client = clickhouse_connect.get_client(host=self.host, port=self.port, username=self.username, password=self.password, database=self.database)
+            result = client.query(query)
+            existing_dates = {row[0] for row in result.result_rows}
+            current_date = start_date
+            all_dates = set()
+            while current_date < self.today:
+                all_dates.add(current_date)
+                current_date += timedelta(days=1)
+            missing_dates = sorted(all_dates - existing_dates)
+            missing_dates_str = [date.strftime('%Y-%m-%d') for date in missing_dates]
+            print(f'Успешное получение дат. Таблица: {table_name}, Старт: {start_date}')
+            logging.info(f'Успешное получение дат. Таблица: {table_name}, Старт: {start_date}')
+        except Exception as e:
+            print(f'Ошибка получения дат: {e}')
+            logging.info(f'Ошибка получения дат: {e}')
+        return missing_dates_str
+
+
+    def upload_data(self, platform, report_name,upload_table, func_name, uniq_columns, partitions, merge_type, refresh_type, history, delay, date):
+        if self.err429 == False:
+            try:
+                n_days_ago = self.today - timedelta(days=self.backfill_days)
+                table_name = f'{platform}_{upload_table}_{self.add_name}'
+                if refresh_type == 'delete_date':
+                    refresh = f"ALTER TABLE {table_name} DROP PARTITION '{date}';"
+                elif refresh_type == 'delete_all':
+                    refresh = f"TRUNCATE TABLE {table_name};"
+                else:
+                    refresh = f"OPTIMIZE TABLE {table_name};"
+                data = func_name(date)
+                collect = True
+                if history and datetime.strptime(date, '%Y-%m-%d').date() >= n_days_ago:
+                    collect = False
+                collection_data = pd.DataFrame({'date': pd.to_datetime([date], format='%Y-%m-%d'), 'report': [report_name], 'collect': [collect]})
+                self.create_alter_ch(data, table_name, uniq_columns, partitions, merge_type)
+                df = self.common.check_and_convert_types(data, uniq_columns, partitions)
+                self.ch_execute(refresh)
+                self.ch_insert(df, table_name)
+                self.ch_insert(collection_data, f'{platform}_collection_{self.add_name}')
+                print(f'Данные добавлены. Репорт: {report_name}. Дата: {date}')
+                logging.info(f'Данные добавлены. Репорт: {report_name}. Дата: {date}')
+                time.sleep(delay)
+            except Exception as e:
+                print(f'Ошибка вставки: {e}. Репорт: {report_name}. Дата: {date}')
+                logging.info(f'Ошибка вставки: {e}. Репорт: {report_name}. Дата: {date}')
+                time.sleep(delay)
+        else:
+            raise ValueError("Обнаружена ошибка 429")
+
+
+    def collecting_report(self, platform, report_name, upload_table, func_name, uniq_columns, partitions, merge_type, refresh_type, history, frequency, delay):
+        logging.info(f"Начинаем сбор {report_name} для клиента: {self.add_name}")
+        print(f"Начинаем сбор {report_name} для клиента: {self.add_name}")
+        create_table_query_collect = f"""
+            CREATE TABLE IF NOT EXISTS {platform}_collection_{self.add_name} (
+            date Date, report String, collect Bool ) ENGINE = ReplacingMergeTree(collect) ORDER BY (report, date)"""
+        optimize_collection = f"OPTIMIZE TABLE {platform}_collection_{self.add_name} FINAL"
+        self.ch_execute(create_table_query_collect)
+        self.ch_execute(optimize_collection)
+        time.sleep(3)
+        if history:
+            date_list = self.get_missing_dates(f'{platform}_collection_{self.add_name}', report_name, self.start)
+            for date in date_list:
+                if self.err429 == False and self.common.to_collect(frequency, date):
+                    print(f'Начинаем сбор. Репорт: {report_name}, Дата: {date}')
+                    logging.info(f'Начинаем сбор. Репорт: {report_name}, Дата: {date}')
+                    self.upload_data(platform, report_name, upload_table, func_name, uniq_columns, partitions, merge_type, refresh_type, history, delay, date)
+        else:
+            date = self.today.strftime('%Y-%m-%d')
+            if self.err429 == False and self.common.to_collect(frequency, date):
+                print(f'Начинаем сбор. Репорт: {report_name}, Дата: {date}')
+                logging.info(f'Начинаем сбор. Репорт: {report_name}, Дата: {date}')
+                self.upload_data(platform, report_name, upload_table, func_name, uniq_columns, partitions, merge_type, refresh_type, history, delay, date)

morin-0.2.6/morin/common.py

@@ -0,0 +1,247 @@
+import requests
+from datetime import datetime,timedelta
+import clickhouse_connect
+import pandas as pd
+import os
+from dateutil import parser
+import time
+import logging
+import hashlib
+from io import StringIO
+import json
+import math
+
+class Common:
+    def __init__(self, logging_path:str):
+        self.logging_path = logging_path
+        self.now = datetime.now()
+        self.today = datetime.now().date()
+        logging.basicConfig(filename=self.logging_path, level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+    def shorten_text(self, text):
+        # Используем хеш-функцию md5 для сокращения строки
+        hash_object = hashlib.md5(text.encode())  # Можно также использовать sha256
+        return hash_object.hexdigest()[:10]  # Возвращаем первые 10 символов хеша
+
+    def shift_date(self, date_str, days=7):
+        # Преобразуем строку в объект datetime
+        date_obj = datetime.strptime(date_str, '%Y-%m-%d')
+        # Сдвигаем дату на указанное количество дней назад
+        new_date = date_obj - timedelta(days=days)
+        # Преобразуем дату обратно в строку
+        return new_date.strftime('%Y-%m-%d')
+
+    # значение -> тип значения для clickhouse
+    def get_data_type(self, column, value, partitions):
+        if value == None: return 'None'
+        part_list = partitions.replace(' ', '').split(',')
+        if isinstance(value, str):
+            if value.lower() == 'false' or value.lower() == 'true':
+                return 'UInt8'
+            date_formats = [
+                '%Y-%m-%dT%H:%M:%S',  # ISO формат DateTime: 2024-09-01T21:20:10
+                '%Y-%m-%d %H:%M:%S',  # DateTime с пробелом: 2024-09-01 21:20:10
+                '%Y-%m-%d',  # Формат Date: 2021-09-08
+                '%d-%m-%Y',  # Формат Date с днем в начале: 08-09-2021
+                '%Y/%m/%d',  # Формат Date через слэш: 2024/09/01
+                '%H:%M:%S',  # Формат Time: 21:20:10
+            ]
+            for date_format in date_formats:
+                try:
+                    parsed_date = datetime.strptime(value, date_format)
+                    # Если дата меньше 1970 года — это не допустимая дата для ClickHouse
+                    if parsed_date.year < 1970:
+                        return 'String'
+                    # Определяем тип на основе формата
+                    if date_format in ['%Y-%m-%d', '%d-%m-%Y', '%Y/%m/%d']:
+                        return 'Date'  # Это формат Date
+                    elif date_format == '%H:%M:%S':
+                        return 'Time'  # Это формат Time
+                    else:
+                        return 'DateTime'  # Форматы с датой и временем
+                except ValueError:
+                    continue  # Если строка не соответствует формату, продолжаем проверку
+            try:
+                parsed_date = parser.isoparse(value)
+                return 'DateTime'  # Это формат DateTime с временной зоной
+            except (ValueError, TypeError):
+                pass
+            try:
+                if value.endswith('Z'):
+                    value = value[:-1] + '+00:00'  # Заменяем 'Z' на '+00:00' для UTC
+                if '+' in value and value[-3] == ':':
+                    value = value[:-3] + value[-2:]  # Убираем двоеточие в зоне (+00:00 -> +0000)
+                parsed_date = datetime.fromisoformat(value)
+                return 'DateTime'  # Формат с датой, временем и временной зоной
+            except ValueError:
+                pass
+            return 'String'  # Если ничего не подошло, возвращаем String
+
+        # Если значение булевое
+        elif isinstance(value, bool):
+            return 'UInt8'
+
+        # Если значение целое число
+        elif isinstance(value, int):
+            if len(str(abs(value))) > 10 or column in part_list:
+                return 'String'
+            return 'Float64'
+
+        # Если значение с плавающей запятой
+        elif isinstance(value, float):
+            if math.isnan(value):
+                return 'Float64'
+            if len(str(int(abs(value)))) > 10 or column in part_list:
+                return 'String'
+            return 'Float64'
+
+        # Для всех остальных типов
+        else:
+            return 'String'
+
+    def column_to_datetime(self, date_str):
+        if pd.isna(date_str):
+            return None
+        date_str = date_str.strip()
+
+        # Обрабатываем таймзону 'Z' (UTC) и заменяем на '+0000'
+        if date_str.endswith('Z'):
+            date_str = date_str[:-1] + '+0000'
+        # Обрабатываем таймзоны вида +00:00 и заменяем на +0000
+        elif '+' in date_str and date_str.endswith(':00'):
+            date_str = date_str[:-3] + date_str[-2:]
+
+        date_formats = [
+            "%Y-%m-%dT%H:%M:%S.%f%z",  # 2023-10-22T16:36:15.507+0000
+            "%Y-%m-%d %H:%M:%S.%f%z",  # 2023-10-22 16:36:15.507+0000
+            "%Y-%m-%dT%H:%M:%S%z",  # 2023-10-22T16:36:15+0000
+            "%Y-%m-%d %H:%M:%S%z",  # 2023-10-22 16:36:15+0000
+            "%Y-%m-%dT%H:%M:%S.%f",  # 2023-10-22T16:36:15.507 (без таймзоны)
+            "%Y-%m-%d %H:%M:%S.%f",  # 2023-10-22 16:36:15.507 (без 'T')
+            "%Y-%m-%dT%H:%M:%S",  # 2023-10-22T16:36:15 (без миллисекунд и таймзоны)
+            "%Y-%m-%d %H:%M:%S",  # 2023-10-22 16:36:15 (без 'T', без миллисекунд)
+            "%Y-%m-%d",  # 2023-10-22 (только дата)
+            "%d-%m-%Y"  # 22-10-2023 (европейский формат)
+        ]
+
+        for fmt in date_formats:
+            try:
+                dt = datetime.strptime(date_str, fmt)
+                return dt.strftime("%Y-%m-%d %H:%M:%S.%f")
+            except ValueError:
+                continue
+        return None
+        # список словарей (данные) -> список поле_типданных
+
+    def analyze_column_types(self, data, uniq_columns, partitions):
+        try:
+            column_types = {}
+            # Проходим по всем строкам в данных
+            for row in data:
+                for column, value in row.items():
+                    value_type = self.get_data_type(column, value, partitions)  # Определяем тип данных
+                    if column not in column_types:
+                        column_types[column] = set()  # Создаем множество для уникальных типов
+                    column_types[column].add(value_type)
+            # Приводим типы столбцов к общему типу
+            final_column_types = {}
+            for column, types in column_types.items():
+                try: types.remove('None')
+                except: pass
+                if len(types) == 1:
+                    final_column_types[column] = next(iter(types))
+                else:
+                    final_column_types[column] = 'String'  # Если разные типы, делаем строкой
+            create_table_query = []
+            non_nullable_list = uniq_columns.replace(' ','').split(',')+[partitions.strip()]
+            for field, data_type in final_column_types.items():
+                field_type = f'Nullable({data_type})'
+                for non in non_nullable_list:
+                    if field == non:
+                        field_type = f'{data_type}'
+                create_table_query.append(f"{field} {field_type}")
+        except Exception as e:
+            print(f'Ошибка анализа: {e}')
+            logging.info(f'Ошибка анализа: {e}')
+        return create_table_query
+
+    # список словарей (данные) -> датафрейм с нужными типами
+    def check_and_convert_types(self, data, uniq_columns, partitions):
+        try:
+            columns_list=self.analyze_column_types(data, uniq_columns, partitions)
+            df=pd.DataFrame(data,dtype=str)
+            type_mapping = {
+                'UInt8': 'bool',
+                'Nullable(UInt8)': 'bool',
+                'Date': 'datetime64[ns]',  # pandas формат для дат
+                'DateTime': 'datetime64[ns]',  # pandas формат для дат с временем
+                'String': 'object',  # Строковый формат в pandas
+                'Float64': 'float64',  # float64 тип в pandas
+                'Nullable(Date)': 'datetime64[ns]',  # pandas формат для дат
+                'Nullable(DateTime)': 'datetime64[ns]',  # pandas формат для дат с временем
+                'Nullable(String)': 'object',  # Строковый формат в pandas
+                'Nullable(Float64)': 'float64'  # float64 тип в pandas
+            }
+            for item in columns_list:
+                column_name, expected_type = item.split()  # Разделяем по пробелу: 'column_name expected_type'
+                if column_name in df.columns:
+                    expected_type = expected_type.strip()
+                    try:
+                        if expected_type in ['Date', 'Nullable(Date)']:
+                            df[column_name] = df[column_name].apply(self.column_to_datetime)
+                            df[column_name] = pd.to_datetime(df[column_name], errors='raise')
+                            df[column_name] = df[column_name].fillna(pd.to_datetime('1970-01-01').date())
+                        if expected_type in ['DateTime', 'Nullable(DateTime)']:
+                            df[column_name] = df[column_name].apply(self.column_to_datetime)
+                            df[column_name] = pd.to_datetime(df[column_name], errors='raise')
+                            df[column_name] = df[column_name].fillna(pd.Timestamp('1970-01-01'))
+                        elif expected_type in ['UInt8','Nullable(UInt8)']:
+                            df[column_name] = df[column_name].replace({'True': True, 'False': False, 'true': True, 'false': False, })
+                            df[column_name] = df[column_name].fillna(False)
+                            df[column_name] = df[column_name].astype('bool')
+                        elif expected_type in ['Float64','Nullable(Float64)']:
+                            df[column_name] = pd.to_numeric(df[column_name], errors='raise').astype('float64')
+                            df[column_name] = df[column_name].fillna(0)
+                        elif expected_type in ['String','Nullable(String)']:
+                            df[column_name] = df[column_name].astype(str)
+                            df[column_name] = df[column_name].fillna("")
+                    except Exception as e:
+                        print(f"Ошибка при преобразовании столбца '{column_name}': {e}")
+                        logging.info(f"Ошибка при преобразовании столбца '{column_name}': {e}")
+            df['timeStamp'] = self.now
+            print(f'Датафрейм успешно преобразован')
+            logging.info(f'Датафрейм успешно преобразован')
+        except Exception as e:
+            print(f'Ошибка преобразования df: {e}')
+            logging.info(f'Ошибка преобразования df: {e}')
+        return df
+
+    def to_collect(self, schedule_str, date_str):
+        try:
+            today = datetime.strptime(date_str, '%Y-%m-%d').date()
+        except ValueError:
+            raise ValueError("Дата должна быть в формате 'YYYY-MM-DD'")
+        day_of_week = today.strftime('%A').lower()  # День недели (например, 'friday')
+        day_of_month = today.day  # Число месяца (например, 22)
+        schedule_list = [s.strip().lower() for s in schedule_str.split(',')]
+        for schedule in schedule_list:
+            if schedule == 'daily':  # Если указано "daily", всегда возвращаем True
+                return True
+            if schedule == day_of_week:  # Проверка дня недели (например, 'friday')
+                return True
+            if schedule.isdigit() and int(schedule) == day_of_month:  # Проверка числа месяца
+                return True
+        return False
+
+    def spread_table(self, source_list):
+        result_list = []
+        for row in source_list:
+            row_dict = {}
+            for key, value in row.items():
+                if isinstance(value, dict):
+                    for name, inner_value in dict(value).items():
+                        row_dict[f'{key}_{name}'] = inner_value
+                else:
+                    row_dict[f'{key}'] = value
+            result_list.append(row_dict)
+        return result_list