vos-data-utils 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

vdutils/tests/test_vid.py

@@ -0,0 +1,247 @@
+import os
+import sys
+import unittest
+import logging
+from typing import Pattern
+sys.path.append(os.getcwd())
+from vdutils.vid import Vid
+
+
+class TestClass(unittest.TestCase):
+
+    @classmethod
+    def setUp(cls):
+        "Hook method for setting fixture before running tests in the class"
+        cls.driver = 'test'
+        cls.instance = Vid()
+
+
+    @classmethod
+    def tearDown(cls):
+        "Hook method for deconstructing the class fixture after running all tests in the class"
+
+
+    def test_class_initialization_type(self):
+        """
+        클래스 인스턴스 초기 생성자 타입 테스트 메소드
+
+        - 클래스 인스턴스 초기 생성자 객체의 값의 타입이 지정된 타입과 일치하는지 확인하는 테스트
+            - __init__.logger 객체 테스트
+            - __init__.is_pnu_valid_regex 객체 테스트
+        """
+
+        self.assertTrue(self.instance.logger, logging.Logger)
+        self.assertTrue(self.instance.is_pnu_valid_regex, Pattern[str]) # default False
+
+
+    def test_class_initialization_not_empty(self):
+        """
+        클래스 인스턴스 초기 생성자 객체 테스트 메소드
+
+        - 클래스 인스턴스 초기 생성자 객체의 값이 None이 아닌지(IsNotNone) 확인하는 테스트
+            - __init__.logger 객체 테스트
+            - __init__.is_pnu_valid_regex 객체 테스트
+
+        - 클래스 인스턴스 초기 생성자 객체의 Length가 0이 아닌지 확인하는 테스트
+            - __init__.logger 객체 테스트 (logging.Logger pass)
+            - __init__.is_pnu_valid_regex 객체 테스트 (pattern pass)
+        """
+
+        self.assertIsNotNone(self.instance.logger)
+        self.assertIsNotNone(self.instance.is_pnu_valid_regex)
+
+        # self.assertNotEqual(len(self.instance.logger), 0)
+        # self.assertNotEqual(len(self.instance.is_pnu_valid_regex), 0)
+
+
+    def test_generate_registration_vid(self):
+        """
+        generate_registration_vid 함수 테스트 메소드
+
+        - generate_registration_vid 함수 리턴값 테스트(올바른 입력값 제공)
+            - generate_registration_vid 함수 리턴값 타입 테스트
+            - generate_registration_vid 함수 리턴값 None 이 아닌지 테스트
+            - generate_registration_vid 함수 리턴값 리스트 첫번째 객체값 타입 테스트
+            - generate_registration_vid 함수 리턴값 리스트 첫번째 객체값 None 이 아닌지 테스트
+            - generate_registration_vid 함수 리턴값 리스트 두번째 객체값 타입 테스트
+            - generate_registration_vid 함수 리턴값 리스트 두번째 객체값 None 이 아닌지 테스트
+            - generate_registration_vid 함수 리턴값 리스트 세번째 객체값 타입 테스트
+            - generate_registration_vid 함수 리턴값 리스트 세번째 객체값 None 이 아닌지 테스트
+            - generate_registration_vid 함수 리턴값 일치 테스트
+
+        - generate_registration_vid 함수 리턴값 테스트(올바르지 않은 입력값 제공)
+            - generate_registration_vid 함수 리턴값 타입 테스트
+            - generate_registration_vid 함수 리턴값 None 이 아닌지 테스트
+            - generate_registration_vid 함수 리턴값 리스트 첫번째 객체값 타입 테스트
+            - generate_registration_vid 함수 리턴값 리스트 첫번째 객체값 None 이 아닌지 테스트
+            - generate_registration_vid 함수 리턴값 리스트 두번째 객체값 타입 테스트 (None pass)
+            - generate_registration_vid 함수 리턴값 리스트 두번째 객체값 None 이 맞는지 테스트
+            - generate_registration_vid 함수 리턴값 리스트 세번째 객체값 타입 테스트 (None pass)
+            - generate_registration_vid 함수 리턴값 리스트 세번째 객체값 None 이 맞는지 테스트
+            - generate_registration_vid 함수 리턴값 일치 테스트
+        """
+
+        res = self.instance.generate_registration_vid(
+            pnu='1234567890123456789',
+            contract_ymd='20240101',
+            price=100,
+            unit_ar=100.1,
+            lot_ar=100.1,
+            seller='seller',
+            buyer='buyer',
+        )
+        self.assertIsInstance(res, list)
+        self.assertIsNotNone(res)
+        self.assertIsInstance(res[0], str)
+        self.assertIsNotNone(res[0])
+        self.assertIsInstance(res[1], str)
+        self.assertIsNotNone(res[1])
+        self.assertIsInstance(res[2], str)
+        self.assertIsNotNone(res[2])
+        self.assertEqual(res, [
+            'R_1234567890_581e28e445_0000',
+            '581e28e4457103048784572e858c5ed1297cf8747169a8454e98a19233036f55',
+            '1234567890123456789_20240101_100_100.1_100.1_seller_buyer'
+        ])
+
+        res = self.instance.generate_registration_vid(
+            pnu='1234567890123456789',
+            contract_ymd='20240101',
+            price='100',
+            unit_ar='100.1',
+            lot_ar='100.1',
+            seller='seller',
+            buyer='buyer',
+        )
+        self.assertIsInstance(res, list)
+        self.assertIsNotNone(res)
+        self.assertIsInstance(res[0], str)
+        self.assertIsNotNone(res[0])
+        self.assertIsInstance(res[1], str)
+        self.assertIsNotNone(res[1])
+        self.assertIsInstance(res[2], str)
+        self.assertIsNotNone(res[2])
+        self.assertEqual(res, [
+            'R_1234567890_581e28e445_0000',
+            '581e28e4457103048784572e858c5ed1297cf8747169a8454e98a19233036f55',
+            '1234567890123456789_20240101_100_100.1_100.1_seller_buyer'
+        ])
+
+        res = self.instance.generate_registration_vid(
+            pnu='12345678901234567890', # 19자리 형식에 맞지 않는 잘못된 입력값 제공
+            contract_ymd='20240101',
+            price=100,
+            unit_ar=100.1,
+            lot_ar=100.1,
+            seller='seller',
+            buyer='buyer',
+        )
+        self.assertIsInstance(res, list)
+        self.assertIsNotNone(res)
+        self.assertIsInstance(res[0], str)
+        self.assertIsNotNone(res[0])
+        # self.assertIsInstance(res[1], None) # (None pass)
+        self.assertIsNone(res[1])
+        # self.assertIsInstance(res[2], None) # (None pass)
+        self.assertIsNone(res[2])
+        self.assertEqual(res, [
+            'R_pnu10dhead_hashstring_0000',
+            None,
+            None
+        ])
+
+        res = self.instance.generate_registration_vid(
+            pnu='1234567890123456789',
+            contract_ymd='2024-01-01',  # YYYYMMDD 형식에 맞지 않는 잘못된 입력값 제공
+            price=100,
+            unit_ar=100.1,
+            lot_ar=100.1,
+            seller='seller',
+            buyer='buyer',
+        )
+        self.assertIsInstance(res, list)
+        self.assertIsNotNone(res)
+        self.assertIsInstance(res[0], str)
+        self.assertIsNotNone(res[0])
+        # self.assertIsInstance(res[1], None) # (None pass)
+        self.assertIsNone(res[1])
+        # self.assertIsInstance(res[2], None) # (None pass)
+        self.assertIsNone(res[2])
+        self.assertEqual(res, [
+            'R_1234567890_hashstring_0000',
+            None,
+            None
+        ])
+
+        res = self.instance.generate_registration_vid(
+            pnu='1234567890123456789',
+            contract_ymd='20240101',
+            price=-100, # 음수 잘못된 입력값 제공
+            unit_ar=100.1,
+            lot_ar=100.1,
+            seller='seller',
+            buyer='buyer',
+        )
+        self.assertIsInstance(res, list)
+        self.assertIsNotNone(res)
+        self.assertIsInstance(res[0], str)
+        self.assertIsNotNone(res[0])
+        # self.assertIsInstance(res[1], None) # (None pass)
+        self.assertIsNone(res[1])
+        # self.assertIsInstance(res[2], None) # (None pass)
+        self.assertIsNone(res[2])
+        self.assertEqual(res, [
+            'R_1234567890_hashstring_0000',
+            None,
+            None
+        ])
+
+        res = self.instance.generate_registration_vid(
+            pnu='1234567890123456789',
+            contract_ymd='20240101',
+            price=100,
+            unit_ar='a', # 숫자 혹은 숫자문자열이 아닌 문자열 입력값 제공
+            lot_ar=100.1,
+            seller='seller',
+            buyer='buyer',
+        )
+        self.assertIsInstance(res, list)
+        self.assertIsNotNone(res)
+        self.assertIsInstance(res[0], str)
+        self.assertIsNotNone(res[0])
+        # self.assertIsInstance(res[1], None) # (None pass)
+        self.assertIsNone(res[1])
+        # self.assertIsInstance(res[2], None) # (None pass)
+        self.assertIsNone(res[2])
+        self.assertEqual(res, [
+            'R_1234567890_hashstring_0000',
+            None,
+            None
+        ])
+
+        res = self.instance.generate_registration_vid(
+            pnu='1234567890123456789',
+            contract_ymd='20240101',
+            price=100,
+            unit_ar=100.1,
+            lot_ar=100.1,
+            seller=1, # 문자열 아닌 숫자 입력값 제공
+            buyer='buyer',
+        )
+        self.assertIsInstance(res, list)
+        self.assertIsNotNone(res)
+        self.assertIsInstance(res[0], str)
+        self.assertIsNotNone(res[0])
+        # self.assertIsInstance(res[1], None) # (None pass)
+        self.assertIsNone(res[1])
+        # self.assertIsInstance(res[2], None) # (None pass)
+        self.assertIsNone(res[2])
+        self.assertEqual(res, [
+            'R_1234567890_hashstring_0000',
+            None,
+            None
+        ])
+
+
+if __name__ == "__main__":
+    unittest.main()

vdutils/tests/tests.py

@@ -1,18 +1,28 @@
 import unittest
-from test_convaddr import TestClass as TestClass1
-from test_cordate import TestClass as TestClass2
+from test_convaddr import TestClass as TestClassConvAddr
+from test_cordate import TestClass as TestClassCordate
+from test_genpnu import TestClass as TestClassGenPnu
+from test_vid import TestClass as TestClassVid
 
 
 def suite():
     test_loader = unittest.TestLoader()
     test_suite = unittest.TestSuite()
 
-    test_suite.addTest(test_loader.loadTestsFromTestCase(TestClass1))
-    test_suite.addTest(test_loader.loadTestsFromTestCase(TestClass2))
+    test_suite.addTest(test_loader.loadTestsFromTestCase(TestClassConvAddr))
+    test_suite.addTest(test_loader.loadTestsFromTestCase(TestClassCordate))
+    test_suite.addTest(test_loader.loadTestsFromTestCase(TestClassGenPnu))
+    test_suite.addTest(test_loader.loadTestsFromTestCase(TestClassVid))
 
     return test_suite
 
-if __name__ == '__main__':
+def __run_test__():
     runner = unittest.TextTestRunner(verbosity=2)
     test_suite = suite()
     result = runner.run(test_suite)
+
+# python -m unittest vdutils.tests.tests 
+if __name__ == '__main__':
+    runner = unittest.TextTestRunner(verbosity=2)
+    test_suite = suite()
+    result = runner.run(test_suite)

vdutils/vid.py

@@ -1,119 +1,177 @@
 import re
 import hashlib
 from datetime import date
-from typing import Union
+from typing import (
+    List,
+    Union
+)
+from dataclasses import dataclass
+from vdutils.library import Log
+
+
+@dataclass
+class Vid():
+
+
+    def __init__(self):
+        self.logger = Log('Vid').stream_handler("INFO")
+        self.is_pnu_valid_regex = re.compile("^\d{19}$")
+
+
+    @staticmethod
+    def _remove_comma(value: str) -> str:
+        return value.replace(",", "")
+
+
+    @staticmethod
+    def _format_float_string(float_str: str) -> str:
+        if float_str:
+            dot_split = float_str.split(".")
+            if len(dot_split) == 1:
+                return float_str
+            elif len(dot_split) == 2:
+                part_int, part_float = dot_split
+                float_numbers = list(part_float)
+                for i in range(len(part_float) - 1, -1, -1):
+                    number = float_numbers[i]
+                    if number != "0":
+                        break
+                    else:
+                        float_numbers.pop()
+                no_trailing_zero_float_part = "".join(float_numbers)
+                if no_trailing_zero_float_part:
+                    return ".".join([part_int, no_trailing_zero_float_part])
+                else:
+                    return part_int
+            else:
+                return float_str
+        else:
+            return ""
 
 
-removeComma = lambda s: s.replace(",", "")
+    def _format_float(
+        self, 
+        float_num: str
+    ) -> str:
+        return self._format_float_string(self._remove_comma(str(float_num)))
 
-formatFloat = lambda float_num: format_float_string(removeComma(str(float_num)))
 
-isPnuValid = lambda pnu: re.compile("^\d{19}$").match(pnu)
+    def _is_number_valid(
+        self, 
+        number: Union[float, int, str, None]
+    ) -> bool:
+        try:
+            ff = self._format_float(number)
+            if (
+                not ff
+                or len(ff.split(".")) > 2
+                or not re.compile("^\d*$").match(ff.replace(".", ""))
+            ):
+                return False
+            else:
+                return True
+        except:
+            return False
 
-def format_float_string(float_str: str) -> str:
-    if float_str:
-        dot_split = float_str.split(".")
-        if len(dot_split) == 1:
-            return float_str
 
-        elif len(dot_split) == 2:
-            part_int, part_float = dot_split
+    def _is_pnu_valid(
+        self, 
+        pnu: str
+    ):
+        return self.is_pnu_valid_regex.match(pnu)
+
+
+    @staticmethod
+    def _is_contract_date_valid(
+        contract_ymd:  Union[str, int, None]
+    ) -> bool:
+        if type(contract_ymd) != str:
+            contract_ymd = str(contract_ymd)
+        if len(contract_ymd) == 8 and re.compile("^\d{8}$").match(contract_ymd):
+            try:
+                d = date.fromisoformat(
+                    f"{contract_ymd[:4]}-{contract_ymd[4:6]}-{contract_ymd[6:]}"
+                )
+                return True
+            except:
+                return False
+        return False
 
-            float_numbers = list(part_float)
 
-            for i in range(len(part_float) - 1, -1, -1):
-                number = float_numbers[i]
-                if number != "0":
-                    break
-                else:
-                    float_numbers.pop()
+    @staticmethod
+    def _is_string_valid(value) -> bool:
+        return isinstance(value, str)
 
-            no_trailing_zero_float_part = "".join(float_numbers)
 
-            if no_trailing_zero_float_part:
-                return ".".join([part_int, no_trailing_zero_float_part])
-            else:
-                return part_int
+    @staticmethod
+    def _validate(validator, value, value_nm):
+        if value and not validator(value):
+            raise Exception(f"invalid {validator}, {value_nm}: {value}")
 
-        else:
-            return float_str
 
-    else:
-        return ""
+    @staticmethod
+    def _get_hash_raw(data_str: str) -> str:
+        return hashlib.sha256(data_str.encode("utf-8")).hexdigest()
 
-def is_contract_date_valid(contract_ymd):
-    if type(contract_ymd) != str:
-        contract_ymd = str(contract_ymd)
-    if len(contract_ymd) == 8 and re.compile("^\d{8}$").match(contract_ymd):
-        try:
-            d = date.fromisoformat(
-                f"{contract_ymd[:4]}-{contract_ymd[4:6]}-{contract_ymd[6:]}"
-            )
-            return True
-        except:
-            return False
-    return False
-
-def is_number_valid(number):
-    try:
-        ff = formatFloat(number)
-        if (
-            not ff
-            or len(ff.split(".")) > 2
-            or not re.compile("^\d*$").match(ff.replace(".", ""))
-        ):
-            return False
-        else:
-            return True
-    except:
-        return False
 
-def validate(validator, value, value_nm):
-    if value and not validator(value):
-        raise Exception(f"invalid {value_nm}: {value}")
-
-def get_hash_raw(data_str: str) -> str:
-    return hashlib.sha256(data_str.encode("utf-8")).hexdigest()
-
-def generate_registration_vid(
-    pnu: str,
-    contract_ymd: str,
-    price: Union[float, int, None] = None,
-    unit_ar: Union[float, int, str, None] = None,
-    lot_ar: Union[float, int, str, None] = None,
-    seller: Union[str, None] = None,
-    buyer: Union[str, None] = None,
-) -> str:
-    try:
-        validate(isPnuValid, pnu, "pnu")
-        validate(is_contract_date_valid, contract_ymd, "contract_ymd")
-        validate(is_number_valid, price, "price")
-        if not unit_ar == "-":
-            validate(is_number_valid, unit_ar, "unit_ar")
-        if not lot_ar == "-":
-            validate(is_number_valid, lot_ar, "lot_ar")
-        validate(lambda seller: type(seller) == str, seller, "seller")
-        validate(lambda buyer: type(buyer) == str, buyer, "buyer")
-
-        data_str = "_".join(
-            [
-                pnu,
-                contract_ymd,
-                formatFloat(price) if price else "",
-                formatFloat(unit_ar) if price else "",
-                formatFloat(lot_ar) if price else "",
-                seller or "",
-                buyer or "",
-            ]
-        )
-
-        h = get_hash_raw(data_str)
-
-        return [f"R_{pnu[:10]}_{h[:10]}_0000", h, data_str]
-    except Exception as e:
-        print(pnu, e)
-        return [
-            f"R_{pnu[:10] if isPnuValid(pnu) else 'pnu10dhead'}_{'hashstring'}_0000",
+    def generate_registration_vid(
+        self,
+        pnu: str,
+        contract_ymd: Union[str, int, None],
+        price: Union[float, int, None] = None,
+        unit_ar: Union[float, int, str, None] = None,
+        lot_ar: Union[float, int, str, None] = None,
+        seller: Union[str, None] = None,
+        buyer: Union[str, None] = None,
+    ) -> List[Union[str, None]]:
+
+        """
+        주어진 입력값들을 문자열로 변환하여 SHA-256 해시값을 생성하여 반환\n 
+        각 입력값들의 타입정의 및 형식이 명확하지 않아, TypeError, ValueError 를 정의하지 않고 모든 오류에 대해 동일한 예외용 응답만을 반환
+
+        Args:
+            pnu (str): Represents the Parcel Numbering Unit, a 19-digit numeric string (10 digits for the administrative district code + 1 digit for the mountain code + 8 digits for the plot number).
+            contract_ymd (str): Transaction date in YYYYMMDD format, an 8-digit numeric string.
+            price (Union[float, int, None]): Transaction price.
+            unit_ar (Union[float, int, str, None]): Transaction unit area.
+            lot_ar (Union[float, int, str, None]): Transaction land area.
+            seller (Union[str, None]): Seller.
+            buyer (Union[str, None]): Buyer.
+
+        Returns: List[Union[str, None]]
+        """
+
+        except_response = [
+            f"R_{pnu[:10] if self._is_pnu_valid(pnu) else 'pnu10dhead'}_{'hashstring'}_0000",
             None,
             None,
         ]
+        try:
+            self._validate(self._is_pnu_valid, pnu, "pnu")
+            self._validate(self._is_contract_date_valid, contract_ymd, "contract_ymd")
+            self._validate(self._is_number_valid, price, "price")
+            if not unit_ar == "-":
+                self._validate(self._is_number_valid, unit_ar, "unit_ar")
+            if not lot_ar == "-":
+                self._validate(self._is_number_valid, lot_ar, "lot_ar")
+            self._validate(self._is_string_valid, seller, "seller")
+            self._validate(self._is_string_valid, buyer, "buyer")
+
+            data_str = "_".join(
+                [
+                    pnu,
+                    contract_ymd,
+                    self._format_float(price) if price else "",
+                    self._format_float(unit_ar) if price else "",
+                    self._format_float(lot_ar) if price else "",
+                    seller or "",
+                    buyer or "",
+                ]
+            )
+            h = self._get_hash_raw(data_str)
+
+            return [f"R_{pnu[:10]}_{h[:10]}_0000", h, data_str]
+
+        except Exception as e:
+            self.logger.info(f"{pnu}, {e}")
+            return except_response

{vos_data_utils-0.0.2.dist-info → vos_data_utils-0.0.4.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: vos-data-utils
-Version: 0.0.2
+Version: 0.0.4
 Summary: description
-Author: vos
+Author: ValueOfSpace
 Author-email: dev@valueofspace.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
@@ -11,6 +11,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: symspellpy
 Requires-Dist: pandas
+Requires-Dist: requests
 
 vos-data-utils <br>
 [![PyPI version](https://badge.fury.io/py/vos-data-utils.svg)](https://pypi.org/project/vos-data-utils/)

vos_data_utils-0.0.4.dist-info/RECORD

@@ -0,0 +1,21 @@
+vdutils/__init__.py,sha256=yNZYpK5OcST5JsiWHL6NBM4HFWcf9__NZTQVy86nuXA,987
+vdutils/bjd.py,sha256=77eqeKogpf7XVjmXlo6j08RGlAKXd7fVDO7nkScy_y4,20936
+vdutils/bjdconnector.py,sha256=QpucOyXQ3mx1qQZXfyJWGkoVxqQZzmy5qG878eUNBVA,29437
+vdutils/convaddr.py,sha256=E7ol9XRAHR10GEM6V8ci0jdW0Y0rBwK369M7hyylpW0,14264
+vdutils/cordate.py,sha256=ednTBnSscr5w8gTDi98ldNtaLfAUAF1BjYV2D2f09so,13638
+vdutils/genpnu.py,sha256=YcpGJ_4msLUP_StWIsdM0IA9nP73Qn6pTzMEtPBSjZc,21663
+vdutils/vid.py,sha256=7ATGsKmXThB74TfENwUY9aF6XVkP6sUKL62TYQfTygg,5734
+vdutils/data/__init__.py,sha256=cDlRzTe-SRJ4VhiQfd7Pi_3cvlnLAiyurA5uqnD7t5U,248
+vdutils/library/__init__.py,sha256=mSEXZfovoMwimrm164NGx1CTXv2ufL-mjvDz_KSyNqk,1204
+vdutils/library/data.py,sha256=tpQHukHuKSXKsyhN3EnqWTCXXWk0LN-ah_r2o7Mi_5E,206956
+vdutils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vdutils/tests/test_convaddr.py,sha256=jRSHAIXrEj8rpV1aWSMVuvS9OdcUMWpz0q7UMQYqyGo,7309
+vdutils/tests/test_cordate.py,sha256=4vNbLugbgmko8a-SKaBvsWrfp_eMBfblLre4027krSQ,11950
+vdutils/tests/test_genpnu.py,sha256=6qHsEm45h6Uzt5gG_DJRKhlCtZTvF87PlFz6DSAl7gU,71218
+vdutils/tests/test_vid.py,sha256=ogyCJ29ac6qEPBp5pIdWZKiP-R103h-6gk8ga_U8xfI,9714
+vdutils/tests/tests.py,sha256=bhwo2nABDatNXcu--EOMg3pONx2lpCvy-dQXEgjp-j0,957
+vos_data_utils-0.0.4.dist-info/METADATA,sha256=VEdY1gvN4IMZpF3G-Sq_WViWZ_tL4oQQbC8hCVBvJZ8,34441
+vos_data_utils-0.0.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+vos_data_utils-0.0.4.dist-info/entry_points.txt,sha256=TPB2LUYp5rOLabatv0O-Bg6bId3UWYUhIVGM0hLZY3g,97
+vos_data_utils-0.0.4.dist-info/top_level.txt,sha256=HHg_xE8RoOT58ELEUeaUMbJaRTq7ry3gLSnC4vB4F4E,8
+vos_data_utils-0.0.4.dist-info/RECORD,,