feat: .tpl support

Author: beskep

ECO2/__main__.py

@@ -0,0 +1,4 @@
+from ECO2.cli import cli
+
+if __name__ == '__main__':
+    cli()

ECO2/cli.py

@@ -1,61 +1,115 @@
+from itertools import chain
+from pathlib import Path
+import sys
+
 import click
+from loguru import logger
 
 from ECO2.eco2 import Eco2
 
+_log_format = ('<green>{time:HH:mm:ss}</green> | '
+               '<level>{level: <8}</level> | '
+               '<cyan>{module}</cyan>:<cyan>{line}</cyan> '
+               '<level>{message}</level>')
+
 
 @click.group()
-def cli():
-    pass
+@click.option('-d', '--debug', is_flag=True, help='Show debug message')
+def cli(debug: bool):
+    """
+    \b
+    사용 방법 안내: 다음 명령어 입력
+    `ECO2 --help`
+    `ECO2 encrypt --help`
+    `ECO2 decrypt --help`
+    """
+    logger.remove()
+    logger.add(sys.stdout,
+               level=(10 if debug else 20),
+               format=_log_format,
+               backtrace=False)
 
 
 @cli.command()
-@click.argument('eco')
-@click.option('-s',
-              '--savedir',
-              help=('해석한 header와 value 파일의 저장 경로. '
-                    '미설정 시 eco 파일과 동일 경로에 저장.'))
-@click.option('-h',
-              '--header',
-              default='header',
-              help='header 파일 이름. 미설정 시 `header`로 지정.')
-@click.option('-v',
-              '--value',
-              help=('value 파일 이름. '
-                    '미설정 시 eco 파일과 동일 이름으로 저장.'))
-def decrypt(eco, savedir, header, value):
+@click.argument('inputs', nargs=-1, required=True)
+@click.option('-o',
+              '--output',
+              help=('저장할 파일 경로. 확장자를 `.header`, `.xml`로 바꾼 경로에 '
+                    '각각 header와 value를 저장함. INPUT이 여러 개일 경우 무시됨.'))
+def decrypt(inputs: tuple, output):
     """
     \b
-    eco 파일을 해석해서 header와 value 파일로 나눠 저장.
-        header: eco의 버전, 생성 날짜 등 정보를 담은 바이너리 파일.
-        value : 해석 설정 정보를 담은 xml 파일.
+    ECO2 저장 파일 (`.eco`, `.tpl`)을 해석해서 header와 value 파일로 나눠 저장.
+    header: ECO2 저장 파일의 버전, 생성 날짜 등 정보를 담은 바이너리 파일.
+            `output.header` 형식.
+    value : 해석 설정 정보를 담은 xml 파일. `output.xml` 형식.
 
     \b
     Argument:
-        ECO: 해석할 eco 파일 경로
+        INPUTS: 해석할 ECO2 저장 파일의 경로.
+                폴더를 지정하는 경우 해당 폴더 내 모든 저장 파일을 대상으로 함.
     """
-    Eco2.decrypt(path=eco,
-                 save_dir=savedir,
-                 header_name=header,
-                 value_name=value)
+    paths = [Path(x) for x in inputs]
+
+    op = None
+    if len(paths) == 1:
+        if paths[0].is_dir():
+            paths = chain(paths[0].glob('*.eco'), paths[0].glob('*.tpl'))
+        elif output:
+            op = Path(output)
+
+    for path in paths:
+        header_path = op.with_suffix(Eco2.header_ext) if op else None
+        value_path = op.with_suffix(Eco2.value_ext) if op else None
+
+        try:
+            Eco2.decrypt(path=path,
+                         header_path=header_path,
+                         value_path=value_path)
+        except (ValueError, OSError) as e:
+            logger.exception(e)
 
 
 @cli.command()
-@click.argument('header')
-@click.argument('value')
-@click.option('-s',
-              '--savedir',
-              help=('해석한 header와 value 파일의 저장 경로. '
-                    '미설정 시 value 파일과 동일 경로에 저장.'))
-def encrypt(header, value, savedir):
+@click.argument('inputs', nargs=-1, required=True)
+@click.option('-h',
+              '--header',
+              help=('header 파일 경로. 미지정 시 value 파일과 동일한 경로·이름에 '
+                    '확장자가 `.header`인 파일로 추정. INPUT이 폴더일 경우 무시됨.'))
+@click.option('-o',
+              '--output',
+              help=('저장할 eco 파일의 경로. '
+                    'INPUT이 여러 개일 경우 무시됨.'))
+def encrypt(inputs: tuple, header, output):
     """
     header와 value를 암호화해서 eco 파일로 변환
 
     \b
-    Arguments:
-        HEADER: header 파일 경로.
-        VALUE : value 파일 경로. 폴더 경로를 지정하면 해당 폴더에 존재하는 모든 .xml 파일을 변환.
+    Argument:
+        INPUTS: 해석할 value 파일의 경로.
+                폴더를 지정하는 경우 해당 폴더 내 모든 xml 파일을 대상으로 함.
     """
-    Eco2.encrypt_dir(header_path=header, value_path=value, save_dir=savedir)
+    paths = [Path(x) for x in inputs]
+
+    header_path = None
+    output_path = None
+    if len(paths) == 1:
+        if paths[0].is_dir():
+            paths = paths[0].glob(f'*{Eco2.value_ext}')
+        else:
+            if header:
+                header_path = Path(header)
+            if output:
+                output_path = Path(output)
+
+    for path in paths:
+        hp = header_path if header_path else path.with_suffix(Eco2.header_ext)
+        op = output_path if output_path else path.with_suffix('.eco')
+
+        try:
+            Eco2.encrypt(header_path=hp, value_path=path, save_path=op)
+        except (ValueError, OSError) as e:
+            logger.exception(e)
 
 
 if __name__ == '__main__':

ECO2/cx_setup.py

@@ -4,11 +4,8 @@
 if __name__ == '__main__':
     options = {
         'build_exe': {
-            'optimize':
-                1,
-            'excludes': [
-                'email', 'html', 'http', 'logging', 'tkinter', 'unittest'
-            ]
+            'optimize': 1,
+            'excludes': ['email', 'html', 'http', 'tkinter', 'unittest']
         }
     }
 

ECO2/eco2.py

@@ -1,6 +1,8 @@
 from itertools import cycle
 from pathlib import Path
 
+from loguru import logger
+
 
 class Eco2:
     header = (
@@ -11,12 +13,14 @@ class Eco2:
         (256, 'Desc'),
         (19, 'Make time'),
         (19, 'Edit time'),
-        (8, 'unknown'),
+        (8, 'password'),
     )
     key = (172, 41, 85, 66)
     header_encoding = 'EUC-KR'
     value_encoding = 'UTF-8'
+    header_ext = '.header'
     value_ext = '.xml'
+    ds = '</DS>'
 
     @classmethod
     def decrypt_bytes(cls, data: bytes):
@@ -57,13 +61,11 @@ def _decode_header(cls, data: bytes):
     def _print_header_info(cls, header: bytes):
         header_dict = cls._decode_header(header)
 
-        print('Header info:')
-
         for key, value in header_dict.items():
-            if key == 'unknown':
+            if key == 'password':
                 continue
 
-            print(f'    {key:10s}: {value}')
+            logger.info('[HEADER] {:10s}: {}', key, value)
 
     @classmethod
     def _write_value(cls, path: Path, value: str):
@@ -75,78 +77,82 @@ def _read_value(cls, path: Path):
         return path.read_text(encoding=cls.value_encoding).replace('\n', '\r\n')
 
     @classmethod
-    def _decrypt_eco2_data(cls, data: bytes):
-        decrypted = cls.decrypt_bytes(data)
+    def _decrypt(cls, data: bytes, decrypt: bool):
+        if decrypt:
+            data = cls.decrypt_bytes(data)
+
         hl = cls.header_length()
+        header_bytes = data[:hl]
+        value_bytes = data[hl:]
 
-        header_bytes = decrypted[:hl]
-        value_bytes = decrypted[hl:]
-        value = value_bytes.decode()
+        try:
+            value = value_bytes.decode(cls.value_encoding)
+        except ValueError:
+            # 케이스 설정 부분 (<DS>...</DS>)만 추출하고
+            # 결과부 (<DSR>...</DSR>)은 버림
+            logger.debug('ECO2 파일의 결과부 (DSR)를 제외합니다.')
+            value = value_bytes.decode(cls.value_encoding, 'replace')
+
+            if cls.ds not in value:
+                raise ValueError('인코딩 에러')
+
+            value = value[:(value.find(cls.ds) + len(cls.ds))]
 
         return header_bytes, value
 
     @classmethod
-    def decrypt(cls, path, save_dir=None, header_name=None, value_name=None):
+    def decrypt(cls, path, header_path=None, value_path=None):
         path = Path(path)
-        save_dir = path.parent if save_dir is None else Path(save_dir)
-        if not save_dir.exists():
-            raise FileNotFoundError(save_dir)
 
-        if header_name is None:
-            header_name = 'header'
-        if value_name is None:
-            value_name = path.stem
+        if header_path is None:
+            header_path = path.with_suffix(cls.header_ext)
+        else:
+            header_path = Path(header_path)
+
+        if value_path is None:
+            value_path = path.with_suffix(cls.value_ext)
+        else:
+            value_path = Path(value_path)
 
-        data = path.read_bytes()
-        bheader, value = cls._decrypt_eco2_data(data)
+        logger.info('Input: {}', path)
+        logger.debug('Header: {}', header_path)
+        logger.debug('Value: {}', value_path)
 
-        cls._print_header_info(bheader)
+        data = path.read_bytes()
+        decrypt = (path.suffix == '.eco')
+        try:
+            header, value = cls._decrypt(data=data, decrypt=decrypt)
+        except ValueError:
+            header, value = cls._decrypt(data=data, decrypt=(not decrypt))
 
-        header_path = save_dir.joinpath(header_name)
-        header_path.write_bytes(bheader)
+        cls._print_header_info(header)
 
-        value_path = save_dir.joinpath(value_name + cls.value_ext)
+        header_path.write_bytes(header)
         cls._write_value(path=value_path, value=value)
 
     @classmethod
-    def _encrypt(cls, header: bytes, value_path: str, save_path: Path):
-        value = cls._read_value(path=value_path)
-        bvalue = value.encode(cls.value_encoding)
-        encrypted = cls.encrypt_bytes(header + bvalue)
+    def _encrypt(cls, header: bytes, value: bytes, save_path: Path):
+        encrypted = cls.encrypt_bytes(header + value)
         save_path.write_bytes(encrypted)
 
     @classmethod
     def encrypt(cls, header_path, value_path, save_path=None):
-        if save_path is None:
-            save_path = 'output.eco'
-
         header_path = Path(header_path)
         value_path = Path(value_path)
-        save_path = Path(save_path)
 
-        header = header_path.read_bytes()
-        cls._print_header_info(header)
+        if save_path:
+            save_path = Path(save_path)
+        else:
+            save_path = value_path.with_suffix('.eco')
 
-        cls._encrypt(header=header, value_path=value_path, save_path=save_path)
-
-    @classmethod
-    def encrypt_dir(cls, header_path, value_path, save_dir=None):
-        header_path = Path(header_path)
-        value_path = Path(value_path)
+        logger.info('Value: {}', value_path)
+        logger.info('Header: {}', header_path)
+        logger.debug('Output: {}', save_path)
 
         header = header_path.read_bytes()
         cls._print_header_info(header)
 
-        save_dir = value_path if save_dir is None else Path(save_dir)
-        if not save_dir.is_dir():
-            save_dir = save_dir.parent
-
-        if value_path.is_dir():
-            vps = value_path.glob(f'*{cls.value_ext}')
-        else:
-            vps = [value_path]
+        value = cls._read_value(path=value_path)
+        value_bytes = value.encode(cls.value_encoding)
 
-        for vp in vps:
-            cls._encrypt(header=header,
-                         value_path=vp,
-                         save_path=save_dir.joinpath(f'{vp.stem}.eco'))
+        cls._encrypt(header=header, value=value_bytes, save_path=save_path)