vos-data-utils 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

vdutils/genpnu.py

@@ -6,13 +6,17 @@ from typing import (
     List,
     Dict,
     Tuple,
+    Union,
     Optional
 )
 from dataclasses import dataclass
 from collections import defaultdict
 from vdutils.library.data import (
     SGG_SPLIT_LIST,
-    LAST_NM_REFINE_MAP
+    LAST_NM_REFINE_MAP,
+    LOAD_PATTERN_FOR_SLICE,
+    JIBUN_PATTERN_FOR_SLICE,
+    ETC_LAND_PATTERN_FOR_SPLIT
 )
 from vdutils.library import Log
 from vdutils.data import (
@@ -21,6 +25,7 @@ from vdutils.data import (
     __encoding__,
     _get_folder_names
 )
+from vdutils.convaddr import ConvAddr
 
 
 @dataclass
@@ -46,6 +51,7 @@ class GenPnu():
         self.sep = __sep__
         self.index: bool = __index__
         self.encoding: str = __encoding__
+        self.origin_base_dt: str = base_dt
         self.base_dt: Optional[str] = base_dt
         self.bjd_current_df: pd.DataFrame() = None
         self.bjd_current_nm_cd_dic = defaultdict(list)
@@ -66,6 +72,7 @@ class GenPnu():
             "data/bjd"
         )
 
+
     def _find_latest_base_dt(
         self,
         base_dts: List[str]
@@ -99,7 +106,7 @@ class GenPnu():
             else:
                 self.base_dt = self._find_latest_base_dt(base_dts=base_dts)
         finally:
-            self.logger.info(f"적용 법정동 데이터 시점: {self.base_dt}")
+            self.logger.info(f"[GenPnu] 적용 법정동 데이터 시점: {self.base_dt}")
 
 
     def _get_file_names(self):
@@ -173,6 +180,16 @@ class GenPnu():
             self.logger.error(e)
 
 
+    def _import_convaddr(self):
+        try:
+            self.convaddr = ConvAddr(base_dt=self.origin_base_dt)
+            self.bjd_smallest_list = self.convaddr.bjd_smallest_list
+            self.convert_pnu_dic = dict((bjd_nm, bjd_cd) for bjd_cd, bjd_nm in self.convaddr.bjd_current_dic.items() if bjd_cd != "법정동코드")
+        except Exception as e:
+            self.logger.error(f"Failed to import vdutils.convaddr module")
+            self.logger.error(e)
+
+
     def _prepare(self):
         self._get_bjd_current_df(
             file_name_bjd_current=self.file_name_bjd_current,
@@ -182,6 +199,7 @@ class GenPnu():
         )
         self._create_bjd_current_nm_cd_dic()
         self._create_bjd_dic()
+        self._import_convaddr()
 
 
     def get_bjd_cd(
@@ -214,14 +232,14 @@ class GenPnu():
         if not re.match("^[가-힣0-9 ]+$", bjd_nm):
             raise ValueError("object('bjd_nm') should consist of only Korean characters and numbers")
 
+        not_a_valid_district_response: Dict[str, Any] = {
+            "error": True,
+            "bjd_cd": None, 
+            "deleted_dt": None,
+            "base_dt": self.base_dt_print,
+            "msg": f"'{bjd_nm}' is not a valid legal district name"
+        }
         try:
-            not_a_valid_district_response: Dict[str, Any] = {
-                "error": True,
-                "bjd_cd": None, 
-                "deleted_dt": None,
-                "base_dt": self.base_dt_print,
-                "msg": f"'{bjd_nm}' is not a valid legal district name"
-            }
             bjd_nm = " ".join(bjd_nm.split())
 
             if bjd_nm in self.bjd_current_nm_cd_dic:
@@ -289,7 +307,8 @@ class GenPnu():
                 "full_bjd_nm": Optional[str],
                 "created_dt": Optional[str],
                 "deleted_dt": Optional[str],
-                "base_dt": str
+                "base_dt": str,
+                "msg": str
             }
         """
 
@@ -302,25 +321,25 @@ class GenPnu():
         if len(bjd_cd) != 10:
             raise ValueError("object('bjd_cd') should be a string consisting of exactly 10 digits")
 
+        not_a_valid_district_response: Dict[str, Any] = {
+            "error": True,
+            "sido_nm": None,
+            "sgg_nm": None,
+            "emd_nm": None,
+            "ri_nm": None,
+            "full_bjd_nm": None,
+            "created_dt": None,
+            "deleted_dt": None,
+            "base_dt": self.base_dt_print,
+            "msg": f"'{bjd_cd}' is not a valid legal district code"
+        }
         try:
-            not_a_valid_district_response: Dict[str, Any] = {
-                "error": True,
-                "sido_nm": None,
-                "sgg_nm": None,
-                "emd_nm": None,
-                "ri_nm": None,
-                "full_bjd_nm": None,
-                "created_dt": None,
-                "deleted_dt": None,
-                "base_dt": self.base_dt_print,
-                "msg": f"'{bjd_cd}' is not a valid legal district code"
-            }
             if bjd_cd in self.bjd_dic:
                 return {"error": False, **self.bjd_dic[bjd_cd], "base_dt": self.base_dt_print, "msg": ""}
             else:
-                return {"error": True, **not_a_valid_district_response}
+                return not_a_valid_district_response
         except Exception as e:
-            return {"error": True, **not_a_valid_district_response.update({"msg": str(e)})}
+            return {**not_a_valid_district_response, "msg": str(e)}
 
 
     @staticmethod
@@ -346,10 +365,11 @@ class GenPnu():
             ValueError: If the 'jibun' object is not of the specified format.
 
         Returns:
-            bool
+            dict: Validation result containing 'error' (bool) and 'msg' (str).
         """
 
-        msg = """
+        msg = "Invalid 'jibun' format. Please follow the specified format."
+        """
         Invalid 'jibun' format. Please follow the specified format.
 
         The address should include '산' and only contain digits except for '산' and '-'.
@@ -365,17 +385,17 @@ class GenPnu():
         or jibun == ""  \
         or jibun is None  \
         or jibun[0] in ["B", "가", "지"]:
-            return True
+            return {"error": True, "msg": msg}
         if "*" in jibun:
-            return True
+            return {"error": True, "msg": msg}
 
         jibun = jibun.replace(" ", "")
         pattern = re.compile(r'^(산\s*)?\d{1,4}-\d{1,4}$|^(산\s*)?\d{1,4}$|^\d{1,4}-\d{1,4}$|^\d{1,4}$')
 
         if not bool(pattern.match(jibun)):
-            raise ValueError(msg)
+            return {"error": True, "msg": msg}
 
-        return True
+        return {"error": False, "msg": ""}
 
 
     @staticmethod
@@ -401,7 +421,7 @@ class GenPnu():
     def _get_jibun_datas(
         jibun: str
     ) -> Tuple[str, str, str]:
-        
+
         """
         입력된 지번 문자열(지번 문자열 적합성 확인된 입력값)에서 본번과 부번을 분리하여 번, 지 코드를 반환
         """
@@ -427,6 +447,110 @@ class GenPnu():
         return bunji_cd, bun, ji
 
 
+    @staticmethod
+    def _validate_pnu(
+        pnu: Optional[str]
+    ) -> dict:
+        """
+        입력된 PNU 문자열이 올바른 형식인지 정규식을 이용하여 검증하여 반환
+
+        Args:
+            pnu (str): Validates the format of the given PNU.
+                The PNU must be a 19-character string consisting only of digits.
+
+        Raises:
+            ValueError: If the 'pnu' object is not of the specified format.
+
+        Returns:
+            dict: Validation result containing 'error' (bool) and 'msg' (str).
+        """
+
+        msg = "Invalid 'pnu' format. Please follow the specified format."
+        """
+        Invalid 'pnu' format. Please follow the specified format.
+
+        The PNU must be a 19-character string consisting only of digits.
+        Example:
+            1234567890123456789
+        """
+
+        if not pnu or not isinstance(pnu, str):
+            return {"error": True, "msg": msg}
+
+        pattern = re.compile(r'^\d{19}$')
+        if not pattern.match(pnu):
+            return {"error": True, "msg": msg}
+
+        return {"error": False, "msg": ""}
+
+
+    def _create_generate_pnu_result(
+        self,
+        error=True, 
+        pnu=None,
+        bjd_cd=None,
+        mountain_cd=None,
+        bunji_cd=None, 
+        bjd_datas=None,
+        bun=None,
+        ji=None,
+        msg=""
+    ) -> Dict[str, Any]:
+
+        """
+        결과 딕셔너리를 생성하는 유틸리티 함수
+
+        Returns:
+            Dict[str, Any]: {
+                "error": bool,
+                "pnu": Optional[str],
+                "bjd_cd": Optional[str],
+                "mountain_cd": Optional[str],
+                "bunji_cd": Optional[str],
+                "bjd_datas": {
+                    "error": bool,
+                    "sido_nm": Optional[str],
+                    "sgg_nm": Optional[str],
+                    "emd_nm": Optional[str],
+                    "ri_nm": Optional[str],
+                    "full_bjd_nm": Optional[str],
+                    "created_dt": Optional[str],
+                    "deleted_dt": Optional[str],
+                    "base_dt": str,
+                    "msg": str,
+                },
+                "bun": Optional[str],
+                "ji": Optional[str],
+                "base_dt": str,
+                "msg": str
+            }
+        """
+
+        return {
+            "error": error,
+            "pnu": pnu,
+            "bjd_cd": bjd_cd,
+            "mountain_cd": mountain_cd,
+            "bunji_cd": bunji_cd,
+            "bjd_datas": bjd_datas or {
+                "error": True,
+                "sido_nm": None,
+                "sgg_nm": None,
+                "emd_nm": None,
+                "ri_nm": None,
+                "full_bjd_nm": None,
+                "created_dt": None,
+                "deleted_dt": None,
+                "base_dt": self.base_dt_print,
+                "msg": ""
+            },
+            "bun": bun,
+            "ji": ji,
+            "base_dt": self.base_dt_print,
+            "msg": msg
+        }
+
+
     def generate_pnu(
         self,
         bjd_cd: str,
@@ -452,20 +576,30 @@ class GenPnu():
             TypeError: If the 'jibun' object is not of type string.
             ValueError: If the 'bjd_cd' object does not consist of digits only.
             ValueError: If the 'bjd_cd' object does not consist of exactly 10 digits.
-            ValueError: If the 'jibun' object is not of the specified format.
 
         Returns:
             Dict[str, Any]: {
                 "error": bool,
-                "pnu": str,
-                "bjd_cd": str,
-                "mountain_cd": str,
-                "bunji_cd": str,
-                "bjd_datas": Dict[str, Any],
-                "bun": str,
-                "ji": str,
-                "msg": str,
-                "base_dt": str
+                "pnu": Optional[str],
+                "bjd_cd": Optional[str],
+                "mountain_cd": Optional[str],
+                "bunji_cd": Optional[str],
+                "bjd_datas": {
+                    "error": bool,
+                    "sido_nm": Optional[str],
+                    "sgg_nm": Optional[str],
+                    "emd_nm": Optional[str],
+                    "ri_nm": Optional[str],
+                    "full_bjd_nm": Optional[str],
+                    "created_dt": Optional[str],
+                    "deleted_dt": Optional[str],
+                    "base_dt": str,
+                    "msg": str,
+                },
+                "bun": Optional[str],
+                "ji": Optional[str],
+                "base_dt": str,
+                "msg": str
             }
         """
 
@@ -481,55 +615,59 @@ class GenPnu():
         if len(bjd_cd) != 10:
             raise ValueError("object('bjd_cd') should be a string consisting of exactly 10 digits")
 
-        if self._validate_jibun(jibun):
-            msg = ""
-            try:
-                bjd_datas = self.get_bjd_data(bjd_cd)
-
-                if pd.isna(jibun) \
-                or jibun == ""  \
-                or jibun is None  \
-                or jibun[0] in ["B", "가", "지"]:
-                    error = True
-                    mountain_cd = "1"
-                    bunji_cd = "00000000"
-                    bun, ji = "0", "0"
-                    msg = "블록지번"
-
-                elif "*" in jibun:
-                    error = True
-                    mountain_cd = "1"
-                    bunji_cd = "00000000"
-                    bun, ji = "0", "0"
-                    msg = "매칭필요"
+        is_valid_jibun = self._validate_jibun(jibun)
+        if is_valid_jibun.get("error") is True:
+            return self._create_generate_pnu_result(
+                error=True,
+                msg=is_valid_jibun.get("msg")
+            )
+
+        try:
+            bjd_datas = self.get_bjd_data(bjd_cd)
+            if bjd_datas.get("error") is True:
+                return self._create_generate_pnu_result(
+                    error=True,
+                    bjd_datas=bjd_datas,
+                    msg=bjd_datas.get("msg")
+                )
+
+            else:
+                jibun = jibun.replace(" ", "")
+                jibun, mountain_cd = self._get_mountain_cd(jibun)
+                bunji_cd, bun, ji = self._get_jibun_datas(jibun)
+                is_valid_pnu = self._validate_pnu(f"{bjd_cd}{mountain_cd}{bunji_cd}")
+
+                if is_valid_pnu.get("error") is True:
+                    return self._create_generate_pnu_result(
+                        error=True,
+                        pnu=f"{bjd_cd}{mountain_cd}{bunji_cd}",
+                        bjd_cd=bjd_cd,
+                        mountain_cd=mountain_cd,
+                        bunji_cd=bunji_cd,
+                        bjd_datas=bjd_datas,
+                        bun=bun,
+                        ji=ji,
+                        msg=is_valid_pnu.get("msg")
+                    )
 
                 else:
-                    error = bjd_datas.get("error")
-                    if error is True:
-                        msg = bjd_datas.get("msg")
-                    jibun = jibun.replace(" ", "")
-                    jibun, mountain_cd = self._get_mountain_cd(jibun)
-                    bunji_cd, bun, ji = self._get_jibun_datas(jibun)
-
-            except Exception as e:
-                error = True
-                mountain_cd = "1"
-                bunji_cd = "00000000"
-                bun, ji = "0", "0"
-                msg = str(e)
-
-            return {
-                "error": error,
-                "pnu": f"{bjd_cd}{mountain_cd}{bunji_cd}",
-                "bjd_cd": bjd_cd,
-                "mountain_cd": mountain_cd,
-                "bunji_cd": bunji_cd,
-                "bjd_datas": bjd_datas,
-                "bun": bun,
-                "ji": ji,
-                "msg": msg,
-                "base_dt": self.base_dt_print
-            }
+                    return self._create_generate_pnu_result(
+                        error=False,
+                        pnu=f"{bjd_cd}{mountain_cd}{bunji_cd}",
+                        bjd_cd=bjd_cd,
+                        mountain_cd=mountain_cd,
+                        bunji_cd=bunji_cd,
+                        bjd_datas=bjd_datas,
+                        bun=bun,
+                        ji=ji,
+                        msg=""
+                    )
+
+        except Exception as e:
+            self._create_generate_pnu_result(
+                error=True,
+                msg=str(e)
+            )
 
 
     def generate_pnu_from_bjd_nm(
@@ -539,7 +677,7 @@ class GenPnu():
     ) -> Dict[str, Any]:
 
         """
-        입력된 문자열(법정동 코드, 지번)을 필지관리번호(pnu)로 변환하여 반환
+        입력된 문자열(법정동명, 지번)을 필지관리번호(pnu)로 변환하여 반환
 
         Args:
             bjd_nm (str): The input should be a string consisting of Korean administrative district names.
@@ -556,20 +694,30 @@ class GenPnu():
             TypeError: If the 'bjd_nm' object is not of type string.
             TypeError: If the 'jibun' object is not of type string.
             ValueError: If the 'bjd_nm' object is not consist of only Korean characters and numbers.
-            ValueError: If the 'jibun' object is not of the specified format.
 
         Returns:
             Dict[str, Any]: {
                 "error": bool,
-                "pnu": str,
-                "bjd_cd": str,
-                "mountain_cd": str,
-                "bunji_cd": str,
-                "bjd_datas": Dict[str, Any],
-                "bun": str,
-                "ji": str,
-                "msg": str,
-                "base_dt": str
+                "pnu": Optional[str],
+                "bjd_cd": Optional[str],
+                "mountain_cd": Optional[str],
+                "bunji_cd": Optional[str],
+                "bjd_datas": {
+                    "error": bool,
+                    "sido_nm": Optional[str],
+                    "sgg_nm": Optional[str],
+                    "emd_nm": Optional[str],
+                    "ri_nm": Optional[str],
+                    "full_bjd_nm": Optional[str],
+                    "created_dt": Optional[str],
+                    "deleted_dt": Optional[str],
+                    "base_dt": str,
+                    "msg": str,
+                },
+                "bun": Optional[str],
+                "ji": Optional[str],
+                "base_dt": str,
+                "msg": str
             }
         """
 
@@ -582,45 +730,254 @@ class GenPnu():
         if not re.match("^[가-힣0-9 ]+$", bjd_nm):
             raise ValueError("object('bjd_nm') should consist of only Korean characters and numbers")
 
-        if self._validate_jibun(jibun):
+        try:
             res = self.get_bjd_cd(bjd_nm=bjd_nm)
-            try:
-                if res.get("error") is not True:
-                    return self.generate_pnu(
-                        bjd_cd=res.get("bjd_cd"),
-                        jibun=jibun
+            if res.get("error") is True:
+                return self._create_generate_pnu_result(
+                    error=res.get("error"),
+                    msg=res.get("msg")
+                )
+            else:
+                return self.generate_pnu(
+                    bjd_cd=res.get("bjd_cd"),
+                    jibun=jibun
+                )
+        except Exception as e:
+            return self._create_generate_pnu_result(
+                error=True,
+                msg=str(e)
+            )
+
+
+    def _clean_bracket_and_content(
+        self,
+        string: str
+    ) -> str:
+
+        """
+        주소문자열의 ([]) 와 같은 괄호 및 괄호안 문자 제거하는 기능
+        """
+
+        pattern = r'[\(\[].*?[\)\]]'
+        return re.sub(pattern, '', string).rstrip()
+
+
+    def _split_etc_main_address(
+        self,
+        main_address: str,
+        detail_address: str
+    ) -> Tuple[Optional[str], Optional[str]]:
+
+        """
+        주소문자열에서 주(main) 주소, 주 외(main etc) 주소, 상세(detail) 주소를 추출하여 반환
+        """
+
+        not_a_valid_district_response: Dict[str, Any] = {
+            "error": True,
+            "main_address": None, 
+            "etc_main_address": None,
+            "detail_address": None,
+            "base_dt": self.base_dt_print,
+            "msg": f"'{detail_address}' is failed to split main address and main etc address"
+        }
+        try:
+            if re.sub(ETC_LAND_PATTERN_FOR_SPLIT, "", detail_address):
+                clean_detail_address = re.sub(ETC_LAND_PATTERN_FOR_SPLIT, "", detail_address).strip()
+                etc_main_address = detail_address.replace(clean_detail_address, "")
+                return {
+                    "error": False,
+                    "main_address": main_address,
+                    "etc_main_address": etc_main_address,
+                    "detail_address": clean_detail_address,
+                    "base_dt": self.base_dt_print,
+                    "msg": ""
+                }
+            else:
+                return {
+                    "error": False,
+                    "main_address": main_address,
+                    "etc_main_address": None,
+                    "detail_address": detail_address,
+                    "base_dt": self.base_dt_print,
+                    "msg": ""
+                }
+        except Exception as e:
+            return {**not_a_valid_district_response, "msg": str(e)}
+
+
+    def _split_main_and_detail_address(
+        self,
+        address: str
+    ) -> Dict[str, Any]:
+
+        """
+        주소문자열에서 주(main) 주소, 주 외(main etc) 주소, 상세(detail) 주소를 추출하여 반환
+        """
+
+        not_a_valid_district_response: Dict[str, Any] = {
+            "error": True,
+            "main_address": None, 
+            "etc_main_address": None,
+            "detail_address": None,
+            "base_dt": self.base_dt_print,
+            "msg": f"'{address}' is failed to split main address and detail address"
+        }
+        try:
+            cleaned_address = self._clean_bracket_and_content(string=address)
+            match = re.search(LOAD_PATTERN_FOR_SLICE, cleaned_address)
+            if match:
+                return {**not_a_valid_district_response, "msg": f"'{address}' is load address"}
+
+            match = re.search(JIBUN_PATTERN_FOR_SLICE, cleaned_address)
+            if match:
+                detail_address = address.split(match.group(0))[1].strip()
+                main_address = address.replace(detail_address, "").strip()
+                return self._split_etc_main_address(main_address=main_address, detail_address=detail_address)
+            else:
+                return not_a_valid_district_response
+        except Exception as e:
+            return {**not_a_valid_district_response, "msg": str(e)}
+
+
+    def _is_not_in_smallest_bjd(
+        self,
+        rest_main_address: str
+    ) -> bool:
+
+        """
+        입력된 지번 문자열(법정동명이 제외된 지번 문자열)에서 최소단위 법정동이 포함되어 있는지 확인하여 반환
+        """
+
+        try:
+            check_word = rest_main_address.split()[0]
+        except:
+            check_word = rest_main_address
+        for bjd in self.bjd_smallest_list:
+            if check_word == bjd:
+                return False
+        return True
+
+
+    def _extract_bjd_from_address(
+        self,
+        main_address: str
+    ) -> Union[str, None]:
+
+        """
+        입력된 지번 문자열에서 번지 상세주소가 제외된 지번의 법정동 문자열을 추출하여 반환
+        법정동 딕셔너리에서 입력된 지번 문자열내에 존재하는 법정동이 있는지 조회하고 존재할 경우,
+        입력된 지번 문자열에서 매칭된 법정동을 잘라낸 나머지 문자열에 최소 단위 법정동명이 존재하는지 확인해서 최소 단위 법정동 레벨인지를 확인
+        매칭된 법정동이 최소 단위 법정동이면 반환
+
+        Args:
+            addr (str): The input korean address string.
+
+        Raises:
+            TypeError: If the 'address' object is not of type string.
+
+        Returns:
+            Union[str, None]
+        """
+
+        if not isinstance(main_address, str):
+            raise TypeError("type of object('address') must be string")
+
+        try:
+            for key in self.convert_pnu_dic.keys():
+                if key in main_address and self.convert_pnu_dic[key][5:] != '00000':
+                    rest_main_address = main_address.replace(key, '')
+                    if main_address.split(key)[1][0] == ' ' \
+                    and self._is_not_in_smallest_bjd(rest_main_address=rest_main_address):
+                        return key
+            return None
+
+        except Exception as e:
+            return None
+
+
+    def generate_pnu_from_address(
+        self,
+        address: str,
+    ) -> Dict[str, Any]:
+
+        """
+        입력된 문자열(주소)에서 법정동, 지번을 분리 필지관리번호(pnu)로 변환하여 반환
+
+        Args:
+            bjd_nm (str): The input should be a string consisting of Korean administrative district names.
+            jibun (str): Validates the format of the given address.
+                The address should include '산' and only contain digits except for '산' and '-'.
+                The main and sub numbers should be separated by a hyphen, and both can have a maximum of 4 digits.
+                Examples:
+                    With mountain and sub-number: 산 0000-0000
+                    With mountain and no sub-number: 산 0000
+                    Without mountain and with sub-number: 0000-0000
+                    Without mountain and without sub-number: 0000
+
+        Raises:
+            TypeError: If the 'bjd_nm' object is not of type string.
+            TypeError: If the 'jibun' object is not of type string.
+            ValueError: If the 'bjd_nm' object is not consist of only Korean characters and numbers.
+
+        Returns:
+            Dict[str, Any]: {
+                "error": bool,
+                "pnu": Optional[str],
+                "bjd_cd": Optional[str],
+                "mountain_cd": Optional[str],
+                "bunji_cd": Optional[str],
+                "bjd_datas": {
+                    "error": bool,
+                    "sido_nm": Optional[str],
+                    "sgg_nm": Optional[str],
+                    "emd_nm": Optional[str],
+                    "ri_nm": Optional[str],
+                    "full_bjd_nm": Optional[str],
+                    "created_dt": Optional[str],
+                    "deleted_dt": Optional[str],
+                    "base_dt": str,
+                    "msg": str,
+                },
+                "bun": Optional[str],
+                "ji": Optional[str],
+                "base_dt": str,
+                "msg": str
+            }
+        """
+
+        if not isinstance(address, str):
+            raise TypeError("type of object('address') must be string")
+
+        try:
+            is_split_address = self._split_main_and_detail_address(address=address)
+            if is_split_address.get("error") is True:
+                return self._create_generate_pnu_result(
+                    error=is_split_address.get("error"),
+                    msg=is_split_address.get("msg")
+                )
+
+            else:
+                main_address = is_split_address.get("main_address")
+                bjd_nm = self._extract_bjd_from_address(main_address=main_address)
+                if bjd_nm is None:
+                    return self._create_generate_pnu_result(
+                        error=True,
+                        msg=f"Failed to extract bjd name from address: {address}"
                     )
-                else:
-                    error = res.get("error")
-                    pnu = None
-                    bjd_cd = None
-                    mountain_cd = None
-                    bunji_cd = None
-                    bjd_datas = None
-                    bun = None
-                    ji = None
-                    msg = f"올바르지 않은 법정동명({res.get('msg')})"
-
-            except Exception as e:
-                error = True
-                pnu = None
-                bjd_cd = None
-                mountain_cd = None
-                bunji_cd = None
-                bjd_datas = None
-                bun = None
-                ji = None
-                msg = str(e)
-
-            return {
-                "error": error,
-                "pnu": pnu,
-                "bjd_cd": bjd_cd,
-                "mountain_cd": mountain_cd,
-                "bunji_cd": bunji_cd,
-                "bjd_datas": bjd_datas,
-                "bun": bun,
-                "ji": ji,
-                "msg": msg,
-                "base_dt": self.base_dt_print
-            }
+
+                bjd_nm = bjd_nm.strip()
+                jibun = main_address.replace(bjd_nm, "")
+                if jibun is None: 
+                    return self._create_generate_pnu_result(
+                        error=True,
+                        msg=f"Failed to extract valid jibun from address: {address}"
+                    )
+
+                jibun = jibun.strip()
+                return self.generate_pnu_from_bjd_nm(bjd_nm=bjd_nm, jibun=jibun)
+
+        except Exception as e:
+            return self._create_generate_pnu_result(
+                error=True,
+                msg=str(e)
+            )