cannect 1.0.0__py3-none-any.whl

cannect/schema/datadictionary.py

@@ -0,0 +1,60 @@
+from pathlib import Path
+import pprint, os
+
+
+
+class DataDictionary(dict):
+    """
+    데이터 저장 Dictionary
+    built-in: dict의 확장으로 저장 요소에 대해 attribute 접근 방식을 허용
+    기본 제공 Alias (별칭): dD, dDict
+
+    사용 예시)
+        myData = DataDictionary(name='JEHYEUK', age=34, division='Vehicle Solution Team')
+        print(myData.name, myData['name'], myData.name == myData['name'])
+
+        /* ----------------------------------------------------------------------------------------
+        | 결과
+        -------------------------------------------------------------------------------------------
+        | JEHYEUK JEHYEUK True
+        ---------------------------------------------------------------------------------------- */
+    """
+    def __init__(self, data=None, **kwargs):
+        super().__init__()
+
+        data = data or {}
+        data.update(kwargs)
+        for key, value in data.items():
+            if isinstance(value, dict):
+                self[key] = DataDictionary(**value)
+                continue
+            if isinstance(value, list):
+                self[key] = value
+                continue
+            try:
+                if os.path.isdir(value) or os.path.isfile(value):
+                    value = Path(value)
+            except TypeError:
+                pass
+            self[key] = value
+        return
+
+    def __getattr__(self, attr):
+        if attr in self:
+            return self[attr]
+        return super().__getattribute__(attr)
+
+    def __setattr__(self, attr, value):
+        if isinstance(value, dict):
+            self[attr] = DataDictionary(**value)
+        else:
+            try:
+                if os.path.isdir(value) or os.path.isfile(value):
+                    value = Path(value)
+            except TypeError:
+                pass
+            self[attr] = value
+        return
+
+    def __str__(self) -> str:
+        return pprint.pformat(self)

cannect/utils/__init__.py

@@ -0,0 +1,3 @@
+from .excel import ComExcel
+from .logger import Logger
+from cannect.utils import tools

cannect/utils/excel.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from pywintypes import com_error
+from typing import Union
+import win32com.client as win32
+
+
+class ComExcel:
+
+    app = None
+    app_close  :bool = False
+    app_visible:bool = False
+    def __new__(cls, *args, **kwargs):
+        try:
+            cls.app = win32.GetActiveObject("Excel.Application")
+        except com_error:
+            cls.app = win32.Dispatch("Excel.Application")
+            cls.app_close = True
+        cls.app_visible = False
+        return super().__new__(cls)
+
+    def __init__(self, path:Union[str, Path]):
+        self.wb = wb = self.app.Workbooks.Open(path)
+        self.ws = wb.ActiveSheet
+        return
+
+    # def __del__(self):
+    #     if self.app_close:
+    #         self.wb.Close()
+    #         self.app.Quit()

cannect/utils/logger.py

@@ -0,0 +1,81 @@
+from io import StringIO
+import logging, time, os
+
+
+class Logger(logging.Logger):
+
+    _timer = None
+
+    @classmethod
+    def kst(cls, *args):
+        return time.localtime(time.mktime(time.gmtime()) + 9 * 3600)
+
+    def __init__(self, file:str='', clean_record:bool=False):
+
+        formatter = logging.Formatter(
+            fmt=f"%(asctime)s %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        formatter.converter = self.kst
+
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_handler.setFormatter(formatter)
+
+        self._buffer = StringIO()
+        memory = logging.StreamHandler(stream=self._buffer)
+        memory.setLevel(logging.INFO)
+        memory.setFormatter(formatter)
+
+        super().__init__(name='pyems', level=logging.DEBUG)
+
+        self.file = file
+        self.propagate = False
+        self.addHandler(console_handler)
+        self.addHandler(memory)
+        if file:
+            if os.path.exists(file) and clean_record:
+                os.remove(file)
+            file_handler = logging.FileHandler(file, encoding="utf-8")
+            file_handler.setLevel(logging.DEBUG)
+            file_handler.setFormatter(formatter)
+            self.addHandler(file_handler)
+        self._held = ''
+        return
+
+    def __call__(self, io:str):
+        return self.info(io)
+
+    @property
+    def stream(self) -> str:
+        return self._buffer.getvalue()
+
+    def log(self, msg:str='', *args, **kwargs):
+        if self._held:
+            msg = self._held + msg
+        super().info(msg, *args, **kwargs)
+        self._held = ''
+        return
+
+    def read(self, file:str=''):
+        if not file:
+            file = self.file
+        with open(file, 'r', encoding="utf-8") as f:
+            return f.read()
+
+    def hold(self, msg:str):
+        self._held += msg
+
+    def run(self, context:str=''):
+        if context:
+            self.info(context)
+        self._timer = time.perf_counter()
+        return
+
+    def end(self, context:str=''):
+        try:
+            context = f'{context} {time.perf_counter() - self._timer:.2f}s'
+            self.info(context)
+        except (AttributeError, TypeError, Exception):
+            raise RuntimeError('Logger is not started. Please call .run() method first.')
+        return

cannect/utils/ppt.py

@@ -0,0 +1,236 @@
+from pywintypes import com_error
+from typing import Generator, List
+import win32com.client as win32
+import os
+
+
+# def add_OLE(
+#     ppt_win32,
+#     obj:str,
+#     slide:int=1,
+#     left:int=475,
+#     top:int=192,
+#     width:int=100,
+#     height:int=100,
+#     close:bool=True,
+# ):
+#     slide = ppt_win32.Slides.Item(slide)
+#
+#     # 아이콘으로 표시 여부 / 링크 여부
+#     display_as_icon = True
+#     link = False  # True면 링크, False면 프레젠테이션에 임베드
+#
+#     # AddOLEObject (파일 확장자에 따라 ProgID 자동 판단; 명시 가능)
+#     shape = slide.Shapes.AddOLEObject(
+#         Left=left, Top=top, Width=width, Height=height,
+#         ClassName="",  # 예: "Excel.Sheet.12" (Office 2007+)
+#         FileName=obj,
+#         DisplayAsIcon=display_as_icon,
+#         IconFileName=" ",  # 아이콘 파일 지정 가능(생략 시 기본)
+#         IconIndex=0,
+#         # IconLabel=os.path.basename(obj),
+#         IconLabel='',
+#         Link=link
+#     )
+#
+#     if close:
+#         ppt_win32.SaveAs(ppt_path)
+#         ppt_win32.close()
+#     return
+
+
+class PptRW:
+
+    app = None
+    app_close:bool = False
+    def __new__(cls, *args, **kwargs):
+        try:
+            cls.app = win32.GetActiveObject("PowerPoint.Application")
+        except com_error:
+            cls.app = win32.Dispatch("PowerPoint.Application")
+            cls.app_close = True
+        cls.app.Visible = True
+        return super().__new__(cls)
+
+    def __init__(self, path:str, logger=None):
+        if logger is not None:
+            logger.log(f'[WRITE PPT ON "{os.path.basename(path)}"]')
+        if self.app.Presentations.Count > 0:
+            for n in range(1, self.app.Presentations.Count + 1):
+                _ppt = self.app.Presentations.Item(n)
+                if os.path.join(_ppt.Path, _ppt.Name) == path:
+                    self.ppt = _ppt
+                    return
+        self.ppt = self.app.Presentations.Open(path)
+        self.log = logger
+        return
+
+    def __iter__(self) -> Generator[win32.CDispatch, None, None]:
+        for i in range(1, self.ppt.Slides.Count + 1):
+            yield self.ppt.Slides.Item(i)
+
+    def _get_table(self, n_slide:int, n_table:int):
+        slide = self.ppt.Slides.Item(n_slide)
+        n = 0
+        for shape in slide.Shapes:
+            if shape.HasTable:
+                n += 1
+                if not n == n_table:
+                    continue
+                return shape.Table
+        raise com_error(f'Table Not Found')
+
+    def get_slide_n(self, title:str) -> List:
+        ns = []
+        for n, slide in enumerate(self, start=1):
+            if slide.Shapes.Count == 0:
+                continue
+            for m in range(1, slide.Shapes.Count + 1):
+                shape = slide.Shapes.Item(1)
+                if not shape.HasTextFrame:
+                    continue
+                text = shape.TextFrame.TextRange.Text
+                if (title.lower() in text.lower()) and (not n in ns):
+                    ns.append(n)
+        return ns
+
+    def set_shape(self, n_slide:int, n_shape:int, width:float=None, height:float=None, left=None, top=None):
+        if width:
+            self.ppt.Slides.Item(n_slide).Shapes(n_shape).Width = width
+        if height:
+            self.ppt.Slides.Item(n_slide).Shapes(n_shape).Height = height
+        if left:
+            self.ppt.Slides.Item(n_slide).Shapes(n_shape).Left = left
+        if top:
+            self.ppt.Slides.Item(n_slide).Shapes(n_shape).Top = top
+        return
+
+    def set_table_height(self, n_slide:int, n_table:int, row:int, height:float):
+        self._get_table(n_slide, n_table).Rows(row).Height = height
+        return
+
+    def set_table_text_align(
+        self,
+        n_slide:int,
+        n_table:int,
+        cell:tuple,
+        horizontal:int=1,
+        vertical:int=1
+    ):
+        cell = self._get_table(n_slide, n_table).Cell(*cell)
+        # text_frame =
+        # text_range = text_frame.TextRange
+
+        cell.Shape.TextFrame.TextRange.ParagraphFormat.Alignment = horizontal
+        cell.Shape.TextFrame.VerticalAnchor = vertical
+        return
+
+    def set_table_font(
+        self,
+        n_slide:int,
+        n_table:int,
+        cell:tuple,
+        name:str=None,
+        size:int=None,
+        bold:bool=None,
+        color:str=None,
+    ):
+        font = self._get_table(n_slide, n_table).Cell(*cell).Shape.TextFrame.TextRange.Font
+        if name is not None:
+            font.Name = name
+        if size is not None:
+            font.Size = size
+        if bold is not None:
+            font.Bold = bold
+        if color is not None:
+            font.Color.RGB = color
+        return
+
+    def set_text(
+        self,
+        n_slide:int,
+        n_shape:int,
+        text:str,
+        pos:str='new',
+    ):
+        shape = self.ppt.Slides.Item(n_slide).Shapes(n_shape)
+        if shape.HasTextFrame:
+            if pos.lower() == 'after':
+                shape.TextFrame.TextRange.InsertAfter(text) # Error
+            elif pos.lower() == 'before':
+                shape.TextFrame.TextRange.InsertBefore(text)
+            else:
+                shape.TextFrame.TextRange.Text = text
+        return
+
+    def set_text_font(
+        self,
+        n_slide:int,
+        n_shape:int,
+        name:str=None,
+        size:int=None,
+        bold:bool=None,
+        color:str=None,
+    ):
+        font = self.ppt.Slides.Item(n_slide).Shapes(n_shape).TextFrame.TextRange.Font
+        if name is not None:
+            font.Name = name
+        if size is not None:
+            font.Size = size
+        if bold is not None:
+            font.Bold = bold
+        if color is not None:
+            font.Color.RGB = color
+        return
+
+    def set_text_in_table(
+        self,
+        n_slide:int,
+        n_table:int,
+        cell:tuple,
+        text:str,
+        pos:str='new'
+    ):
+        table = self._get_table(n_slide, n_table)
+        if pos.lower() == 'after':
+            table.Cell(cell[0], cell[1]).Shape.TextFrame.TextRange.InsertAfter(text)
+        elif pos.lower() == 'before':
+            table.Cell(cell[0], cell[1]).Shape.TextFrame.TextRange.InsertBefore(text)
+        else:
+            table.Cell(cell[0], cell[1]).Shape.TextFrame.TextRange.Text = text
+        return
+
+    def replace_text_in_table(
+        self,
+        n_slide:int,
+        n_table:int,
+        cell:tuple,
+        prev:str,
+        post:str
+    ):
+        self._get_table(n_slide, n_table) \
+            .Cell(cell[0], cell[1]) \
+            .Shape \
+            .TextFrame \
+            .TextRange \
+            .Replace(prev, post)
+        return
+
+    def close(self):
+        self.ppt.Save()
+        self.ppt.Close()
+        if self.app_close:
+            self.app.Quit()
+        return
+
+
+
+
+if __name__ == "__main__":
+    # ppt = PptRW(r"D:\Archive\00_프로젝트\2017 통신개발-\2025\DS1229 CR10785896 CNG PIO\0000_변경내역서 양식.pptx")
+    # ppt.set_text(1, 1, "Hello World", insert=False)
+    # ppt.set_text_in_table(2, (2, 1), "Testing", insert=False)
+    # ppt.close()
+
+    print(win32.constants)
+    print(win32.constants.msoAnchorTop)

cannect/utils/tools.py

@@ -0,0 +1,207 @@
+from pathlib import Path
+from typing import AnyStr, Callable, Iterable, List, Union
+from xml.etree.ElementTree import Element, ElementTree
+from xml.dom import minidom
+import os, zipfile, shutil, io, re
+
+
+def unzip(src: Union[str, Path], to: Union[str, Path] = "") -> bool:
+    """
+    압축(.zip) 해제
+    :param src: 압축파일 경로
+    :param to : [optional] 압축파일을 풀 경로
+    :return:
+    """
+    if not to:
+        to = os.path.dirname(src)
+    else:
+        os.makedirs(to, exist_ok=True)
+
+    src = str(src)
+    if not os.path.isfile(src):
+        raise KeyError(f"src: {src}는 경로가 포함된 파일(Full-Directory)이어야 합니다.")
+    if src.endswith('.zip'):
+        zip_obj = zipfile.ZipFile(src)
+        zip_obj.extractall(to)
+    # elif src.endswith('.7z'):
+    #     with py7zr.SevenZipFile(src, 'r') as arc:
+    #         arc.extractall(path=to)
+    else:
+        # raise KeyError(f"src: {src}는 .zip 또는 .7z 압축 파일만 입력할 수 있습니다.")
+        raise KeyError(f"src: {src}는 .zip 압축 파일만 입력할 수 있습니다.")
+    return True
+
+def zip(path:Union[str, Path]):
+    name = os.path.basename(path)
+    shutil.make_archive(name, "zip", root_dir=path)
+    shutil.move(f'{name}.zip', path)
+    return
+
+def copy_to(file:Union[str, Path], dst:Union[str, Path]) -> str:
+    shutil.copy(file, dst)
+    # if '.' in os.path.basename(file):
+    #     shutil.copy(file, dst)
+    # else:
+    #     shutil.move(file, dst)
+    return os.path.join(dst, os.path.basename(file))
+
+def find_file(root:Union[str, Path], filename:Union[str, Path]) -> Union[str, List[str]]:
+    """
+    @filename: 확장자까지 포함한 단일 파일 이름
+    """
+    found = []
+    for _root, _dir, _files in os.walk(root):
+        for _file in _files:
+            if _file == filename:
+                found.append(os.path.join(_root, _file))
+    if not found:
+        return ""
+    if len(found) == 1:
+        return found[0]
+    return found
+
+
+def clear(path: str, leave_path: bool = True):
+    """
+    지정한 경로의 파일 및 하위 디렉토리를 모두 삭제
+
+    :param path: 삭제 대상이 될 폴더 경로
+    :param leave_path: True면 폴더를 남기고 내용만 삭제, False면 폴더 자체도 삭제
+    """
+    if not os.path.exists(path):
+        return
+
+    try:
+        if leave_path:
+            for item in os.listdir(path):
+                item_path = os.path.join(path, item)
+                if os.path.isfile(item_path) or os.path.islink(item_path):
+                    os.unlink(item_path)
+                elif os.path.isdir(item_path):
+                    shutil.rmtree(item_path)
+        else:
+            shutil.rmtree(path)
+    except Exception as e:
+        print(f"Error occurs while clearing directory: {e}")
+
+def path_abbreviate(path: Union[str, Path]) -> str:
+    sep = os.path.sep
+    split = str(path).split(sep)
+    return f"{sep.join(split[:2])}{sep} ... {sep}{sep.join(split[-3:])}"
+
+
+class xml:
+
+    @classmethod
+    def to_str(cls, xml: Union[Element, ElementTree], xml_declaration: bool = False) -> str:
+        """
+        xml 요소(태그) 및 그 하위 요소를 소스 문자열로 변환
+
+        :param xml:
+        :param xml_declaration:
+
+        :return:
+        """
+        if isinstance(xml, Element):
+            xml = ElementTree(xml)
+
+        stream = io.StringIO()
+        xml.write(
+            file_or_filename=stream,
+            encoding='unicode',
+            xml_declaration=False,
+            method='xml',
+        )
+        dom = f'{minidom.parseString(stream.getvalue()).toprettyxml()}' \
+            .replace('<?xml version="1.0" ?>', '<?xml version="1.0" encoding="UTF-8"?>') \
+            .replace("<CodeBlock/>", "<CodeBlock></CodeBlock>") \
+            .replace("<Comment/>", "<Comment></Comment>") \
+            .replace("ns0:", "") \
+            .replace('xmlns:ns0="http://www.w3.org/2000/09/xmldsig#" ', '') \
+            .replace('<Signature>', '<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">')
+        # if not xml.getroot().tag == 'Specifications':
+        dom = "\n".join([l for l in dom.split("\n") if "<" in l or ';' in l or '=' in l or not l.startswith("\t")])        # dom = '\n'.join([line for line in dom.split('\n') if line.strip()])
+        if not xml_declaration:
+            dom = dom.replace('<?xml version="1.0" encoding="UTF-8"?>\n', '')
+        return dom
+
+    @classmethod
+    def to_dict(cls, xml:Union[Element, ElementTree], target:str='ascet', depth:str='recursive') -> dict:
+        """
+        xml 요소(태그) 및 그 하위 요소의 text 및 attribute를 dictionary로 변환
+
+        :param xml:
+        :param target:
+        :param depth:
+        :return:
+        """
+        if isinstance(xml, Element):
+            xml = ElementTree(xml)
+
+        if not depth == 'recursive':
+            return xml.getroot().attrib
+
+        attr = {}
+        for elem in xml.iter():
+            copy = elem.attrib.copy()
+            if target == "ascet":
+                if elem.tag == 'PhysicalInterval' and 'min' in copy:
+                    copy['physMin'] = copy['min']
+                    copy['physMax'] = copy['max']
+                    del copy['min'], copy['max']
+                if elem.tag == 'ImplementationInterval' and 'min' in copy:
+                    copy['implMin'] = copy['min']
+                    copy['implMax'] = copy['max']
+                    del copy['min'], copy['max']
+
+                if (elem.tag == 'Comment' and elem.text is not None) or elem.tag == 'CodeBlock':
+                    attr[elem.tag.lower()] = elem.text
+
+            attr.update(copy)
+        return attr
+
+
+
+class KeywordSearch:
+    """
+    Dataset에 대한 키워드 검색
+    """
+    logger:Callable = print
+    def __init__(self, *samples):
+        self._samples = list(samples)
+        return
+
+    def __getitem__(self, item:str)-> str:
+        result = self.search(self._samples, item)
+        if not result:
+            self.logger(f"NOT FOUND: '{item}' IN THE MODEL")
+        return result
+
+    @classmethod
+    def search(cls, samples: Iterable[str], keyword: str) -> Union[str, List[str]]:
+        """
+        간단한 와일드카드 검색 함수.
+        - '*' 는 0글자 이상 임의의 문자열과 매칭됩니다.
+        - 대소문자를 구분하지 않습니다.
+        - 결과가 1개이면 str을, 그 외(0개 또는 2개 이상)면 List[str]를 반환합니다.
+        """
+        samples = list(samples)
+        if keyword is None:
+            return ""
+
+        kw = keyword.strip()
+        regex_fragments = []
+        for ch in kw:
+            if ch == '*':
+                regex_fragments.append(".*")
+            else:
+                regex_fragments.append(re.escape(ch))
+        regex_body = "".join(regex_fragments)
+        pattern = re.compile(f"^{regex_body}$", flags=re.IGNORECASE)
+        matches = [s for s in samples if pattern.match(s)]
+        if not matches:
+            return ""
+        elif len(matches) == 1:
+            return matches[0]
+        else:
+            return matches