analyser_hj3415 2.0.2__py2.py3-none-any.whl → 2.2.0__py2.py3-none-any.whl

analyser_hj3415/db/mongo.py

@@ -1,934 +0,0 @@
-import pymongo
-import sys
-
-import copy
-from pymongo import errors, MongoClient
-import math
-import random
-import datetime
-from typing import List, Tuple
-from collections import OrderedDict
-from abc import *
-from utils_hj3415 import utils
-import pandas as pd
-
-
-import logging
-logger = logging.getLogger(__name__)
-formatter = logging.Formatter('%(levelname)s: [%(name)s] %(message)s')
-ch = logging.StreamHandler()
-ch.setFormatter(formatter)
-logger.addHandler(ch)
-logger.setLevel(logging.WARNING)
-
-"""
-몽고db구조
-RDBMS :     database    / tables        / rows      / columns
-MongoDB :   database    / collections   / documents / fields
-"""
-
-
-class UnableConnectServerException(Exception):
-    """
-    몽고 서버 연결 에러를 처리하기 위한 커스텀 익셉션
-    """
-    pass
-
-
-def connect_mongo(addr: str, timeout=5) -> MongoClient:
-    """
-    몽고 클라이언트를 만들어주는 함수.
-    필요할 때마다 클라이언트를 생성하는 것보다 클라이언트 한개로 데이터베이스를 다루는게 효율적이라 함수를 따로 뺐음.
-    resolve conn error - https://stackoverflow.com/questions/54484890/ssl-handshake-issue-with-pymongo-on-python3
-    :param addr:
-    :param timeout:
-    :return:
-    """
-    import certifi
-    ca = certifi.where()
-    if addr.startswith('mongodb://'):
-        # set a some-second connection timeout
-        client = pymongo.MongoClient(addr, serverSelectionTimeoutMS=timeout * 1000)
-    elif addr.startswith('mongodb+srv://'):
-        client = pymongo.MongoClient(addr, serverSelectionTimeoutMS=timeout * 1000, tlsCAFile=ca)
-    else:
-        raise Exception(f"Invalid address: {addr}")
-    try:
-        srv_info = client.server_info()
-        conn_str = f"Connect to Mongo Atlas v{srv_info['version']}..."
-        print(conn_str, f"Server Addr : {addr}")
-        return client
-    except:
-        raise UnableConnectServerException()
-
-
-def extract_addr_from_client(client: MongoClient) -> str:
-    """
-    scaraper는 클라이언트를 인자로 받지않고 주소를 받아서 사용하기 때문에 사용하는 주소 추출함수
-    """
-    # client에서 mongodb주소 추출
-    ip = str(list(client.nodes)[0][0])
-    port = str(list(client.nodes)[0][1])
-    return 'mongodb://' + ip + ':' + port
-
-
-class MongoBase:
-    def __init__(self, client: MongoClient, db_name: str, col_name: str):
-        self._db_name = "test"
-        self._col_name = "test"
-        self.client = client
-        self.db_name = db_name
-        self.col_name = col_name
-
-    @property
-    def db_name(self):
-        return self._db_name
-
-    @db_name.setter
-    def db_name(self, db_name):
-        if self.client is None:
-            raise Exception("You should set server connection first")
-        else:
-            self._db_name = db_name
-            self.my_db = self.client[self.db_name]
-            self.my_col = self.my_db[self.col_name]
-
-    @property
-    def col_name(self):
-        return self._col_name
-
-    @col_name.setter
-    def col_name(self, col_name):
-        if self.db_name is None:
-            raise Exception("You should set database first.")
-        else:
-            self._col_name = col_name
-            self.my_col = self.my_db[self.col_name]
-
-    # ========================End Properties=======================
-
-    @staticmethod
-    def get_all_db_name(client: MongoClient) -> list:
-        return sorted(client.list_database_names())
-
-    @staticmethod
-    def validate_db(client: MongoClient, db_name: str) -> bool:
-        """
-        db_name 이 실제로 몽고db 안에 있는지 확인한다.
-        """
-        if db_name in client.list_database_names():
-            return True
-        else:
-            return False
-
-    @staticmethod
-    def del_db(client: MongoClient, db_name: str):
-        if MongoBase.validate_db(client, db_name):
-            client.drop_database(db_name)
-            print(f"Drop '{db_name}' database..")
-        else:
-            print(f"Invalid db name : {db_name}", file=sys.stderr)
-
-    def validate_col(self) -> bool:
-        """
-        col_name 이 실제로 db 안에 있는지 확인한다.
-        """
-        if self.validate_db(self.client, self.db_name):
-            if self.col_name in self.my_db.list_collection_names():
-                return True
-            else:
-                return False
-
-    def get_all_docs(self, remove_id=True) -> list:
-        """
-        현재 설정된 컬렉션 안의 도큐먼트 전부를 리스트로 반환한다.
-        """
-        items = []
-        if remove_id:
-            for doc in self.my_col.find({}):
-                del doc['_id']
-                items.append(doc)
-        else:
-            items = list(self.my_col.find({}))
-        return items
-
-    def count_docs_in_col(self) -> int:
-        """
-        현재 설정된 컬렉션 안의 도큐먼트의 갯수를 반환한다.
-        """
-        return self.my_col.count_documents({})
-
-    def clear_docs_in_col(self):
-        """
-        현재 설정된 컬렉션 안의 도큐먼트를 전부 삭제한다.
-        (컬렉션 자체를 삭제하지는 않는다.)
-        """
-        self.my_col.delete_many({})
-        print(f"Delete all doccument in {self.col_name} collection..")
-
-    def del_col(self):
-        """
-        현재 설정된 컬렉션을 삭제한다.
-        """
-        self.my_db.drop_collection(self.col_name)
-        print(f"Drop {self.col_name} collection..")
-
-    def list_collection_names(self) -> list:
-        return self.my_db.list_collection_names()
-
-    def del_doc(self, del_query: dict):
-        """
-        del_query에 해당하는 도큐먼트를 삭제한다.
-        """
-        self.my_col.delete_one(del_query)
-
-
-class Corps(MongoBase):
-    """
-    mongodb의 데이터 중 기업 코드로 된 데이터 베이스를 다루는 클래스
-    """
-    COLLECTIONS = ('c101', 'c104y', 'c104q', 'c106y', 'c106q', 'c108',
-                   'c103손익계산서q', 'c103재무상태표q', 'c103현금흐름표q',
-                   'c103손익계산서y', 'c103재무상태표y', 'c103현금흐름표y',
-                   'dart', 'etc')
-
-    def __init__(self, client: MongoClient, code: str, page: str):
-        if utils.is_6digit(code) and page in self.COLLECTIONS:
-            super().__init__(client=client, db_name=code, col_name=page)
-        else:
-            raise Exception(f'Invalid value - code: {code} / {page}({self.COLLECTIONS})')
-
-    @property
-    def code(self):
-        return self.db_name
-
-    @code.setter
-    def code(self, code: str):
-        if utils.is_6digit(code):
-            self.db_name = code
-        else:
-            raise Exception(f'Invalid value : {code}')
-
-    @property
-    def page(self):
-        return self.col_name
-
-    @page.setter
-    def page(self, page: str):
-        if page in self.COLLECTIONS:
-            self.col_name = page
-        else:
-            raise Exception(f'Invalid value : {page}({self.COLLECTIONS})')
-
-    # ========================End Properties=======================
-
-    @staticmethod
-    def latest_value(data: dict, pop_count=2, nan_to_zero=False, allow_empty=False) -> Tuple[str, float]:
-        """
-        가장 최근 년/분기 값 - evaltools에서도 사용할수 있도록 staticmethod로 뺐음.
-
-        해당 타이틀의 가장 최근의 년/분기 값을 튜플 형식으로 반환한다.
-
-        Args:
-            data (dict): 찾고자하는 딕셔너리 데이터
-            pop_count: 유효성 확인을 몇번할 것인가
-            nan_to_zero: nan의 값을 0으로 바꿀것인가
-            allow_empty: title 항목이 없을경우에도 에러를 발생시키지 않을 것인가
-
-        Returns:
-            tuple: ex - ('2020/09', 39617.5) or ('', 0)
-
-        Note:
-            만약 최근 값이 nan 이면 찾은 값 바로 직전 것을 한번 더 찾아 본다.\n
-            데이터가 없는 경우 ('', nan) 반환한다.\n
-        """
-        def is_valid_value(value) -> bool:
-            """
-            숫자가 아닌 문자열이나 nan 또는 None의 경우 유효한 형식이 아님을 알려 리턴한다.
-            """
-            if isinstance(value, str):
-                # value : ('Unnamed: 1', '데이터가 없습니다.') 인 경우
-                is_valid = False
-            elif math.isnan(value):
-                # value : float('nan') 인 경우
-                is_valid = False
-            elif value is None:
-                # value : None 인 경우
-                is_valid = False
-            else:
-                is_valid = True
-            """
-            elif value == 0:
-                is_valid = False
-            """
-            return is_valid
-
-        logger.debug(f'Corps.latest_value raw data : {data}')
-
-        # 데이터를 추출해서 사용하기 때문에 원본 데이터는 보존하기 위해서 카피해서 사용
-        data_copied = copy.deepcopy(data)
-
-        for i in range(pop_count):
-            try:
-                d, v = data_copied.popitem()
-            except KeyError:
-                # when dictionary is empty
-                return '', 0 if nan_to_zero else float('nan')
-            if str(d).startswith('20') and is_valid_value(v):
-                logger.debug(f'last_one : {v}')
-                return d, v
-
-        return '', 0 if nan_to_zero else float('nan')
-
-    @staticmethod
-    def refine_data(data: dict, refine_words: list) -> dict:
-        """
-        주어진 딕셔너리에서 refine_words에 해당하는 키를 삭제해서 반환하는 유틸함수.
-        c10346에서 사용
-        refine_words : 정규표현식 가능
-        """
-        copy_data = data.copy()
-        import re
-        for regex_refine_word in refine_words:
-            # refine_word에 해당하는지 정규표현식으로 검사하고 매치되면 삭제한다.
-            p = re.compile(regex_refine_word)
-            for title, _ in copy_data.items():
-                # data 내부의 타이틀을 하나하나 조사한다.
-                m = p.match(title)
-                if m:
-                    del data[title]
-        return data
-
-    @staticmethod
-    def get_all_codes(client: MongoClient) -> list:
-        """
-        기업 코드를 데이터베이스명으로 가지는 모든 6자리 숫자 코드의 db 명 반환
-        """
-        corp_list = []
-        for db in MongoBase.get_all_db_name(client):
-            if utils.is_6digit(db):
-                corp_list.append(db)
-        return sorted(corp_list)
-
-    @staticmethod
-    def del_all_codes(client: MongoClient):
-        corp_list = Corps.get_all_codes(client)
-        for corp_db_name in corp_list:
-            MongoBase.del_db(client, corp_db_name)
-
-    @staticmethod
-    def pick_rnd_x_code(client: MongoClient, count: int) -> list:
-        """
-        임의의 갯수의 종목코드를 뽑아서 반환한다.
-        """
-        return random.sample(Corps.get_all_codes(client), count)
-
-    @staticmethod
-    def get_name(client: MongoClient, code: str):
-        """
-        code를 입력받아 종목명을 반환한다.
-        """
-        c101 = C101(client, code)
-        try:
-            name = c101.get_recent()['종목명']
-        except KeyError:
-            name = None
-        return name
-
-    def _save_df(self, df: pd.DataFrame) -> bool:
-        # c103, c104, c106, c108에서 주로 사용하는 저장방식
-        if df.empty:
-            print('Dataframe is empty..So we will skip saving db..')
-            return False
-        result = self.my_col.insert_many(df.to_dict('records'))
-        return result.acknowledged
-
-    def _load_df(self) -> pd.DataFrame:
-        # cdart와 c106, c103에서 주로 사용
-        try:
-            df = pd.DataFrame(self.get_all_docs())
-        except KeyError:
-            df = pd.DataFrame()
-        return df
-
-    def _save_dict(self, dict_data: dict, del_query: dict) -> bool:
-        # c101, cdart에서 주로 사용하는 저장방식
-        try:
-            result = self.my_col.insert_one(dict_data)
-        except errors.DuplicateKeyError:
-            self.my_col.delete_many(del_query)
-            result = self.my_col.insert_one(dict_data)
-        return result.acknowledged
-
-
-class C1034(Corps, metaclass=ABCMeta):
-    def __init__(self, client: MongoClient, db_name: str, col_name: str):
-        super().__init__(client=client, code=db_name, page=col_name)
-
-    def get_all_titles(self) -> list:
-        titles = []
-        for item in self.get_all_docs():
-            titles.append(item['항목'])
-        return list(set(titles))
-
-    @staticmethod
-    def sum_each_data(data_list: List[dict]) -> dict:
-        """
-        검색된 딕셔너리를 모은 리스트를 인자로 받아서 각각의 기간에 맞춰 합을 구해 하나의 딕셔너리로 반환한다.
-        """
-        sum_dict = {}
-        periods = list(data_list[0].keys())
-        # 여러딕셔너리를 가진 리스트의 합 구하기
-        for period in periods:
-            sum_dict[period] = sum(utils.nan_to_zero(data[period]) for data in data_list)
-        return sum_dict
-
-    def _find(self, title: str, refine_words: list) -> Tuple[List[dict], int]:
-        """
-        refine_words 에 해당하는 딕셔너리 키를 삭제하고
-        title 인자에 해당하는 항목을 검색하여 반환한다.
-        c103의 경우는 중복되는 이름의 항목이 있기 때문에
-        이 함수는 반환되는 딕셔너리 리스트와 갯수로 구성되는 튜플을 반환한다.
-        """
-        titles = self.get_all_titles()
-        if title in titles:
-            count = 0
-            data_list = []
-            for data in self.my_col.find({'항목': {'$eq': title}}):
-                # 도큐먼트에서 title과 일치하는 항목을 찾아낸다.
-                count += 1
-                # refine_data함수를 통해 삭제를 원하는 필드를 제거하고 data_list에 추가한다.
-                data_list.append(self.refine_data(data, refine_words))
-            return data_list, count
-        else:
-            raise Exception(f'{title} is not in {titles}')
-
-    def latest_value(self, title: str, pop_count=2, nan_to_zero=False, allow_empty=False) -> Tuple[str, float]:
-        od = OrderedDict(sorted(self.find(title, allow_empty=allow_empty).items(), reverse=False))
-        logger.debug(f'{title} : {od}')
-        return Corps.latest_value(od, pop_count, nan_to_zero, allow_empty)
-
-    @abstractmethod
-    def find(self, title: str, allow_empty=False) -> dict:
-        pass
-
-    def sum_recent_4q(self, title: str, nan_to_zero: bool = False) -> Tuple[str, float]:
-        """최근 4분기 합
-
-        분기 페이지 한정 해당 타이틀의 최근 4분기의 합을 튜플 형식으로 반환한다.
-
-        Args:
-            title (str): 찾고자 하는 타이틀
-            nan_to_zero: nan 값의 경우 zero로 반환한다.
-
-        Returns:
-            tuple: (계산된 4분기 중 최근분기, 총합)
-
-        Raises:
-            TypeError: 페이지가 q가 아닌 경우 발생
-
-        Note:
-            분기 데이터가 4개 이하인 경우 그냥 최근 연도의 값을 찾아 반환한다.
-        """
-        if self.col_name.endswith('q'):
-            # 딕셔너리 정렬 - https://kkamikoon.tistory.com/138
-            # reverse = False 이면 오래된것부터 최근순으로 정렬한다.
-            od_q = OrderedDict(sorted(self.find(title, allow_empty=True).items(), reverse=False))
-            logger.debug(f'{title} : {od_q}')
-
-            if len(od_q) < 4:
-                # od_q의 값이 4개 이하이면 그냥 최근 연도의 값으로 반환한다.
-                if self.page.startswith('c103'):
-                    y = C103(self.client, self.db_name, self.col_name[:-1] + 'y')
-                elif self.page.startswith('c104'):
-                    y = C104(self.client, self.db_name, self.col_name[:-1] + 'y')
-                else:
-                    Exception(f'Error on sum_recent_4q func...')
-                return y.latest_value(title, nan_to_zero=nan_to_zero, allow_empty=True)
-            else:
-                q_sum = 0
-                date_list = list(od_q.keys())
-                while True:
-                    try:
-                        latest_period = date_list.pop()
-                    except IndexError:
-                        latest_period = ""
-                        break
-                    else:
-                        if str(latest_period).startswith('20'):
-                            break
-
-                for i in range(4):
-                    # last = True 이면 최근의 값부터 꺼낸다.
-                    d, v = od_q.popitem(last=True)
-                    logger.debug(f'd:{d} v:{v}')
-                    q_sum += 0 if math.isnan(v) else v
-                return str(latest_period), round(q_sum, 2)
-        else:
-            raise TypeError(f'Not support year data..{self.col_name}')
-
-    def find_증감율(self, title: str) -> dict:
-        """
-
-        타이틀에 해당하는 전년/분기대비 값을 반환한다.\n
-
-        Args:
-            title (str): 찾고자 하는 타이틀
-
-        Returns:
-            float: 전년/분기대비 증감율
-
-        Note:
-            중복되는 title 은 취급하지 않기로함.\n
-        """
-        try:
-            data_list, count = self._find(title, ['_id', '항목'])
-        except:
-            # title을 조회할 수 없는 경우
-            if self.col_name.endswith('q'):
-                r = {'전분기대비': math.nan}
-            else:
-                r = {'전년대비': math.nan, '전년대비 1': math.nan}
-            return r
-        logger.info(data_list)
-        cmp_dict = {}
-        if count > 1:
-            # 중복된 타이틀을 가지는 페이지의 경우 경고 메시지를 보낸다.
-            logger.warning(f'Not single data..{self.code}/{self.page}/{title}')
-            logger.warning(data_list)
-        # 첫번째 데이터를 사용한다.
-        data_dict = data_list[0]
-        for k, v in data_dict.items():
-            if str(k).startswith('전'):
-                cmp_dict[k] = v
-        return cmp_dict
-
-
-class C104(C1034):
-    def __init__(self, client: MongoClient, code: str, page: str):
-        if page in ('c104y', 'c104q'):
-            super().__init__(client=client, db_name=code, col_name=page)
-        else:
-            raise Exception
-
-    def get_all_titles(self) -> list:
-        """
-        상위 C1034클래스에서 c104는 stamp항목이 있기 때문에 삭제하고 리스트로 반환한다.
-        """
-        titles = super().get_all_titles()
-        titles.remove('stamp')
-        return titles
-
-    def find(self, title: str, allow_empty=False) -> dict:
-        """
-        title에 해당하는 항목을 딕셔너리로 반환한다.
-        allow_empty를 true로 하면 에러를 발생시키지 않고 빈딕셔너리를 리턴한다.
-        """
-        try:
-            l, c = super(C104, self)._find(title, ['_id', '항목', '^전.+대비.*'])
-            return_dict = l[0]
-        except Exception as e:
-            if allow_empty:
-                return_dict = {}
-            else:
-                raise Exception(e)
-        return return_dict
-
-    def save_df(self, c104_df: pd.DataFrame) -> bool:
-        """데이터베이스에 저장
-
-        c104는 4페이지의 자료를 한 컬렉션에 모으는 것이기 때문에
-        stamp 를 검사하여 12시간 전보다 이전에 저장된 자료가 있으면
-        삭제한 후 저장하고 12시간 이내의 자료는 삭제하지 않고
-        데이터를 추가하는 형식으로 저장한다.
-
-        Example:
-            c104_data 예시\n
-            [{'항목': '매출액증가율',...'2020/12': 2.78, '2021/12': 14.9, '전년대비': 8.27, '전년대비1': 12.12},
-            {'항목': '영업이익증가율',...'2020/12': 29.62, '2021/12': 43.86, '전년대비': 82.47, '전년대비1': 14.24}]
-
-        Note:
-            항목이 중복되는 경우가 있기 때문에 c104처럼 각 항목을 키로하는 딕셔너리로 만들지 않는다.
-        """
-        self.my_col.create_index('항목', unique=True)
-        time_now = datetime.datetime.now()
-        try:
-            stamp = self.my_col.find_one({'항목': 'stamp'})['time']
-            if stamp < (time_now - datetime.timedelta(days=.01)):
-                # 스템프가 약 10분 이전이라면..연속데이터가 아니라는 뜻이므로 컬렉션을 초기화한다.
-                print("Before save data, cleaning the collection...", end='')
-                self.clear_docs_in_col()
-        except TypeError:
-            # 스템프가 없다면...
-            pass
-        # 항목 stamp를 찾아 time을 업데이트하고 stamp가 없으면 insert한다.
-        self.my_col.update_one({'항목': 'stamp'}, {"$set": {'time': time_now}}, upsert=True)
-        return super(C104, self)._save_df(c104_df)
-
-    def get_stamp(self) -> datetime.datetime:
-        """
-        c104y, c104q가 작성된 시간이 기록된 stamp 항목을 datetime 형식으로 리턴한다.
-        """
-        return self.my_col.find_one({"항목": "stamp"})['time']
-
-    def modify_stamp(self, days_ago: int):
-        """
-        인위적으로 타임스템프를 수정한다 - 주로 테스트 용도
-        """
-        try:
-            before = self.my_col.find_one({'항목': 'stamp'})['time']
-        except TypeError:
-            # 이전에 타임스템프가 없는 경우
-            before = None
-        time_2da = datetime.datetime.now() - datetime.timedelta(days=days_ago)
-        self.my_col.update_one({'항목': 'stamp'}, {"$set": {'time': time_2da}}, upsert=True)
-        after = self.my_col.find_one({'항목': 'stamp'})['time']
-        logger.info(f"Stamp changed: {before} -> {after}")
-
-
-class C103(C1034):
-    def __init__(self, client: MongoClient, code: str, page: str):
-        if page in ('c103손익계산서q', 'c103재무상태표q', 'c103현금흐름표q',
-                    'c103손익계산서y', 'c103재무상태표y', 'c103현금흐름표y',):
-            super().__init__(client=client, db_name=code, col_name=page)
-        else:
-            raise Exception
-
-    def save_df(self, c103_df: pd.DataFrame) -> bool:
-        """데이터베이스에 저장
-
-        Example:
-            c103_list 예시\n
-            [{'항목': '자산총계', '2020/03': 3574575.4, ... '전분기대비': 3.9},
-            {'항목': '유동자산', '2020/03': 1867397.5, ... '전분기대비': 5.5}]
-
-        Note:
-            항목이 중복되는 경우가 있기 때문에 c104처럼 각 항목을 키로하는 딕셔너리로 만들지 않는다.
-        """
-        self.my_col.create_index('항목', unique=False)
-        print("Before save data, cleaning the collection...", end='')
-        self.clear_docs_in_col()
-        return super(C103, self)._save_df(c103_df)
-
-    def load_df(self) -> pd.DataFrame:
-        """
-        데이터베이스에 저장된 페이지를 데이터프레임으로 반환한다.
-        """
-        return super(C103, self)._load_df()
-
-    def find(self, title: str, allow_empty=False) -> dict:
-        """
-        title에 해당하는 항목을 딕셔너리로 반환한다.
-        allow_empty를 true로 하면 에러를 발생시키지 않고 빈딕셔너리를 리턴한다.
-        c103의 경우는 중복된 타이틀을 가지는 항목이 있어 합쳐서 한개의 딕셔너리로 반환한다.
-        """
-        try:
-            l, c = super(C103, self)._find(title, ['_id', '항목', '^전.+대비.*'])
-            sum_dict = self.sum_each_data(l)
-        except Exception as e:
-            if allow_empty:
-                sum_dict = {}
-            else:
-                raise Exception(e)
-        return sum_dict
-
-
-class C101(Corps):
-    def __init__(self, client: MongoClient, code: str):
-        super().__init__(client=client, code=code, page='c101')
-        self.my_col.create_index('date', unique=True)
-
-    def save_dict(self, c101_dict: dict) -> bool:
-        """
-        c101의 구조에 맞는 딕셔너리값을 받아서 구조가 맞는지 확인하고 맞으면 저장한다.
-
-        Note:
-            <c101_struc>\n
-            'date', '코드', '종목명',\n
-            '업종', '주가', '거래량',\n
-            'EPS', 'BPS', 'PER',\n
-            '업종PER', 'PBR', '배당수익률',\n
-            '최고52주', '최저52주', '거래대금',\n
-            '시가총액', '베타52주', '발행주식',\n
-            '유통비율', 'intro'\n
-        """
-        c101_template = ['date', '코드', '종목명', '업종', '주가', '거래량', 'EPS', 'BPS', 'PER', '업종PER', 'PBR',
-                         '배당수익률', '최고52주', '최저52주', '거래대금', '시가총액', '베타52주', '발행주식', '유통비율']
-        # 리스트 비교하기
-        # reference from https://codetorial.net/tips_and_examples/compare_two_lists.html
-        if c101_dict['코드'] != self.db_name:
-            raise Exception("Code isn't equal input data and db data..")
-        logger.debug(c101_dict.keys())
-        # c101 데이터가 c101_template의 내용을 포함하는가 확인하는 if문
-        # refered from https://appia.tistory.com/101
-        if (set(c101_template) - set(c101_dict.keys())) == set():
-            # 스크랩한 날짜 이후의 데이터는 조회해서 먼저 삭제한다.
-            del_query = {'date': {"$gte": c101_dict['date']}}
-            return super(C101, self)._save_dict(c101_dict, del_query)
-        else:
-            raise Exception('Invalid c101 dictionary structure..')
-
-    def find(self, date: str) -> dict:
-        """
-
-        해당 날짜의 데이터를 반환한다.
-        만약 리턴값이 없으면 {} 을 반환한다.
-
-        Args:
-            date (str): 예 - 20201011(6자리숫자)
-        """
-        if utils.isYmd(date):
-            converted_date = date[:4] + '.' + date[4:6] + '.' + date[6:]
-        else:
-            raise Exception(f'Invalid date format : {date}(ex-20201011(8자리숫자))')
-        d = self.my_col.find_one({'date': converted_date})
-        if d is None:
-            return {}
-        else:
-            del d['_id']
-            return d
-
-    def get_recent(self, merge_intro=False) -> dict:
-        """
-        저장된 데이터에서 가장 최근 날짜의 딕셔너리를 반환한다.
-
-        리턴값
-        {'BPS': 50817.0,
-        'EPS': 8057.0,
-        'PBR': 1.28,
-        'PER': 8.08,
-        'date': '2023.04.14',
-        'intro1': '한국 및 DX부문 해외 9개 지역총괄과 DS부문 해외 5개 지역총괄, SDC, Harman 등 233개의 종속기업으로 구성된 글로벌 전자기업임.',
-        'intro2': '세트사업(DX)에는 TV, 냉장고 등을 생산하는 CE부문과 스마트폰, 네트워크시스템, 컴퓨터 등을 생산하는 IM부문이 있음.',
-        'intro3': '부품사업(DS)에서는 D램, 낸드 플래쉬, 모바일AP 등의 제품을 생산하는 반도체 사업과 TFT-LCD 및 OLED 디스플레이 패널을 생산하는 DP사업으로 구성됨.',
-        '거래대금': '1062800000000',
-        '거래량': '16176500',
-        '발행주식': '5969782550',
-        '배당수익률': '2.22',
-        '베타52주': '0.95',
-        '시가총액': '388632800000000',
-        '업종': '반도체와반도체장비',
-        '업종PER': '8.36',
-        '유통비율': '75.82',
-        '종목명': '삼성전자',
-        '주가': '65100',
-        '최고52주': '68800',
-        '최저52주': '51800',
-        '코드': '005930'}
-        """
-        try:
-            d = self.my_col.find({'date': {'$exists': True}}, {"_id": 0}).sort('date', pymongo.DESCENDING).next()
-            # del doc['_id'] - 위의 {"_id": 0} 으로 해결됨.
-            if merge_intro:
-                d['intro'] = d['intro1'] + d['intro2'] + d['intro3']
-                del d['intro1']
-                del d['intro2']
-                del d['intro3']
-        except StopIteration:
-            d = {}
-        return d
-
-    def get_all(self) -> list:
-        """
-
-        저장된 모든 데이터를 딕셔너리로 가져와서 리스트로 포장하여 반환한다.
-        """
-        items = []
-        for doc in self.my_col.find({'date': {'$exists': True}}, {"_id": 0}).sort('date', pymongo.ASCENDING):
-            # del doc['_id'] - 위의 {"_id": 0} 으로 해결됨.
-            items.append(doc)
-        return items
-
-    def get_trend(self, title: str) -> dict:
-        """
-        title에 해당하는 데이터베이스에 저장된 모든 값을 {날짜: 값} 형식의 딕셔너리로 반환한다.
-
-        title should be in ['BPS', 'EPS', 'PBR', 'PER', '주가', '배당수익률', '베타52주', '거래량']
-
-        리턴값 - 주가
-        {'2023.04.05': '63900',
-         '2023.04.06': '62300',
-         '2023.04.07': '65000',
-         '2023.04.10': '65700',
-         '2023.04.11': '65900',
-         '2023.04.12': '66000',
-         '2023.04.13': '66100',
-         '2023.04.14': '65100',
-         '2023.04.17': '65300'}
-        """
-        titles = ['BPS', 'EPS', 'PBR', 'PER', '주가', '배당수익률', '베타52주', '거래량']
-        if title not in titles:
-            raise Exception(f"title should be in {titles}")
-        items = dict()
-        for doc in self.my_col.find({'date': {'$exists': True}}, {"_id": 0, "date": 1, f"{title}": 1}).sort('date', pymongo.ASCENDING):
-            items[doc['date']] = doc[f'{title}']
-        return items
-
-class C106(Corps):
-    def __init__(self, client: MongoClient, code: str, page: str):
-        if page in ('c106y', 'c106q'):
-            super().__init__(client=client, code=code, page=page)
-        else:
-            raise Exception
-
-    def save_df(self, c106_df: pd.DataFrame) -> bool:
-        self.my_col.create_index('항목', unique=True)
-        self.clear_docs_in_col()
-        return super(C106, self)._save_df(c106_df)
-
-    def load_df(self) -> pd.DataFrame:
-        return super(C106, self)._load_df()
-
-    def get_all_titles(self) -> list:
-        titles = []
-        for item in self.get_all_docs():
-            titles.append(item['항목'])
-        return list(set(titles))
-
-    def find(self, title: str, allow_empty=False) -> dict:
-        """
-        title에 해당하는 항목을 딕셔너리로 반환한다.
-        """
-        titles = self.get_all_titles()
-        if title in titles:
-            data = self.my_col.find_one({'항목': {'$eq': title}})
-            return self.refine_data(data, ['_id', '항목'])
-        else:
-            if allow_empty:
-                return {}
-            else:
-                raise Exception(f'{title} is not in {titles}')
-
-
-class DateBase(MongoBase):
-    """
-    날짜를 컬렉션으로 가지는 데이터베이스를 위한 기반클래스
-    """
-    def __init__(self, client: MongoClient, db_name: str, date: str):
-        if utils.isYmd(date):
-            super().__init__(client=client, db_name=db_name, col_name=date)
-        else:
-            raise Exception(f"Invalid date : {date}(%Y%m%d)")
-
-    @property
-    def date(self):
-        return self.col_name
-
-    @date.setter
-    def date(self, date: str):
-        if utils.isYmd(date):
-            self.col_name = date
-        else:
-            raise Exception(f"Invalid date : {date}(%Y%m%d)")
-
-    # ========================End Properties=======================
-
-    def save_df(self, df: pd.DataFrame) -> bool:
-        if df.empty:
-            print('Dataframe is empty..So we will skip saving db..')
-            return False
-
-        self.clear_docs_in_col()
-        print(f"Save new data to '{self.db_name}' / '{self.col_name}'")
-        result = self.my_col.insert_many(df.to_dict('records'))
-        return result.acknowledged
-
-    def load_df(self) -> pd.DataFrame:
-        try:
-            df = pd.DataFrame(list(self.my_col.find({}))).drop(columns=['_id'])
-        except KeyError:
-            df = pd.DataFrame()
-        return df
-
-
-class EvalByDate(DateBase):
-    """
-    각 날짜별로 만들어진 eval-report 데이터프레임을 관리하는 클래스
-    DB_NAME : eval
-    COL_NAME : Ymd형식 날짜
-    """
-    EVAL_DB = 'eval'
-
-    def __init__(self, client: MongoClient, date: str):
-        super().__init__(client, self.EVAL_DB, date)
-        # 인덱스 설정
-        self.my_col.create_index('code', unique=True)
-
-    @staticmethod
-    def get_dates(client: MongoClient) -> List[str]:
-        # 데이터베이스에 저장된 날짜 목록을 리스트로 반환한다.
-        dates_list = client.eval.list_collection_names()
-        dates_list.sort()
-        return dates_list
-
-    @classmethod
-    def get_recent(cls, client: MongoClient, type: str):
-        """
-        eval 데이터베이스의 가장 최근의 유요한 자료를 반환한다.
-        type의 종류에 따라 반환값이 달라진다.[date, dataframe, dict]
-        """
-        dates = cls.get_dates(client)
-
-        while len(dates) > 0:
-            recent_date = dates.pop()
-            recent_df = cls(client, recent_date).load_df()
-            if len(recent_df) != 0:
-                if type == 'date':
-                    return recent_date
-                elif type == 'dataframe':
-                    return recent_df
-                elif type == 'dict':
-                    return recent_df.to_dict('records')
-                else:
-                    raise Exception(f"Invalid type : {type}")
-
-        return None
-
-class MI(MongoBase):
-    """mi 데이터베이스 클래스
-
-    Note:
-        db - mi\n
-        col - 'aud', 'chf', 'gbond3y', 'gold', 'silver', 'kosdaq', 'kospi', 'sp500', 'usdkrw', 'wti', 'avgper', 'yieldgap', 'usdidx' - 총 13개\n
-        doc - date, value\n
-    """
-    MI_DB = 'mi'
-    COL_TITLE = ('aud', 'chf', 'gbond3y', 'gold', 'silver', 'kosdaq', 'kospi',
-                 'sp500', 'usdkrw', 'wti', 'avgper', 'yieldgap', 'usdidx')
-
-    def __init__(self, client: MongoClient, index: str):
-        if index in self.COL_TITLE:
-            super().__init__(client=client, db_name=self.MI_DB, col_name=index)
-        else:
-            raise Exception(f'Invalid index : {index}({self.COL_TITLE})')
-
-    @property
-    def index(self):
-        return self.col_name
-
-    @index.setter
-    def index(self, index: str):
-        if index in self.COL_TITLE:
-            self.col_name = index
-        else:
-            raise Exception(f'Invalid index : {index}({self.COL_TITLE})')
-
-    # ========================End Properties=======================
-
-    def get_recent(self) -> Tuple[str, float]:
-        """저장된 가장 최근의 값을 반환하는 함수
-        """
-        if self.validate_col():
-            d = self.my_col.find({'date': {'$exists': True}}).sort('date', pymongo.DESCENDING).next()
-            del d['_id']
-            return d['date'], d['value']
-
-    def save_dict(self, mi_dict: dict) -> bool:
-        """MI 데이터 저장
-
-        Args:
-            mi_dict (dict): ex - {'date': '2021.07.21', 'value': '1154.50'}
-        """
-        self.my_col.create_index('date', unique=True)
-        result = self.my_col.update_one({'date': mi_dict['date']}, {"$set": {'value': mi_dict['value']}}, upsert=True)
-        return result.acknowledged