zerohertzLib.util ¶

def __get_keys(self, data: Any, key: str = "", front: str = "") -> None:
    if isinstance(data, dict):
        for idx, (key_, val_) in enumerate(data.items()):
            if idx + 1 == len(data):
                self.map.append(front + "└── " + str(key_))
                front_ = " "
            else:
                self.map.append(front + "├── " + str(key_))
                front_ = "│"
            if key:
                self.keys.append(f"{key}/{key_}")
                self.__get_keys(val_, f"{key}/{key_}", front + f"{front_}   ")
            else:
                self.keys.append(f"{key_}")
                self.__get_keys(val_, f"{key_}", front + f"{front_}   ")
    elif isinstance(data, list):
        self.map.append(front + "└── " + "LIST")
        if data:
            if key:
                self.__get_keys(data[0], f"{key}/LIST", front + "    ")
            else:
                self.__get_keys(data[0], "LIST", front + "    ")

def __getitem__(self, key: int | str) -> Any:
    """JSON file에서 key에 해당하는 값을 반환

    Args:
        key: 읽어온 JSON file에서 불러올 key 값

    Returns:
        Key에 따른 value 값
    """
    return self.data[key]

def __len__(self) -> int:
    """JSON file의 길이를 반환

    Returns:
        읽어온 JSON file의 길이
    """
    return len(self.data)

def _get_key(self, key: str) -> str:
    """
    Key의 경로를 찾아주는 method

    Args:
        key: 읽어온 JSON file에서 불러올 key 값 (깊이 무관)

    Returns:
        `/` 으로 깊이를 표시한 key 값
    """
    keys = self._get_keys()
    if key in keys:
        return key
    if "/" not in key:
        for key_ in keys:
            if key_.endswith(key):
                key = key_
                break
    return key

def _get_keys(self) -> list[str]:
    if not self.keys and not self.map:
        self.__get_keys(self.data)
    return self.keys

def _get_value(self, key: str) -> Any:
    """
    `Json._get_key` 로 생성된 key 값을 입력 받아 value return

    Args:
        key: `Json._get_key` 로 생성된 key 값

    Returns:
        Key에 따른 value
    """
    value = self.data
    for key_ in key.split("/"):
        if key_ == "LIST":
            value = value[0]
        else:
            value = value.get(key_)
    return value

def get(self, key: str) -> Any:
    """`Json._get_key` 로 생성된 key 값을 입력 받아 value return

    Args:
        key: 읽어온 JSON file에서 불러올 key 값 (깊이 무관)

    Returns:
        Key에 따른 value

    Examples:
        >>> js["title"]
        '[v0.2.3] Release'
        >>> js.get("title")
        '[v0.2.3] Release'
        >>> js["color"]
        Traceback:
          File "<stdin>", line 1, in <module>
          File "/home/zerohertz/Zerohertz/zerohertzLib/zerohertzLib/util/json.py", line 107, in __getitem__
        KeyError: 'color'
        >>> js.get("color")
        'd73a4a'
    """
    return self._get_value(self._get_key(key))

def tree(self) -> None:
    """JSON의 구조를 출력하는 method

    Examples:
        >>> js.tree()
        ├── url
        ...
        ├── user
        │   ├── login
        ...
        │   └── site_admin
        ├── body
        ...
        ├── assignee
        │   ├── login
        ...
        │   └── site_admin
        ├── assignees
        │   └── LIST
        │       ├── login
        ...
        │       └── site_admin
        ...
        └── active_lock_reason
    """
    self._get_keys()
    print("\n".join(self.map))

def __getitem__(self, idx: int) -> Json:
    """Index를 사용하여 JSON file에 접근

    Args:
        idx: 입력 index

    Returns:
        Index에 따른 `Json` instance
    """
    return self.data[self.name[idx]]

def __len__(self) -> int:
    """JSON file의 길이를 반환

    Returns:
        읽어온 JSON file들의 수
    """
    return len(self.data)

def _get_key(self, key: str) -> str:
    """
    Key의 경로를 찾아주는 method

    Args:
        key: 읽어온 JSON file에서 불러올 key 값 (깊이 무관)

    Returns:
        `/` 으로 깊이를 표시한 key 값
    """
    return self[0]._get_key(key)

def tree(self) -> None:
    """JSON의 구조를 출력하는 method

    Examples:
        >>> jsd.tree()
        ├── url
        ...
        ├── user
        │   ├── login
        ...
        │   └── site_admin
        ├── body
        ...
        ├── assignee
        │   ├── login
        ...
        │   └── site_admin
        ├── assignees
        │   └── LIST
        │       ├── login
        ...
        │       └── site_admin
        ...
        └── active_lock_reason
    """
    self[0].tree()

def unique(self, key: str) -> set[str]:
    """읽어온 JSON data들의 유일한 값을 return하는 method

    Args:
        key: 읽어온 JSON file에서 불러올 key 값

    Returns:
        Key에 따른 유일한 값들의 집합

    Examples:
        >>> jsd.unique("label")
        {'Zerohertz:docs', 'Zerohertz:dev-v0.2.3', 'Zerohertz:docs-v0.2.2'}
        >>> jsd.unique("sha")
        {'dfd53a0bfc73221dbe96d5e44a49c524d5a8596b', 'bc33235424e89cbbf23434b2a824ea068d167c7d', '97f52f9b81ba885fe69b9726632e580f5cba94be', '768c7711f94af0be00cd55e0ce7b892465cfa64a', '97e103788359f0361f4ec0e138a14218f28eddd4'}
    """
    key = self._get_key(key)
    uniq = set()
    for json_instance in self:
        data = json_instance._get_value(key)
        uniq.add(str(data))
    return uniq

@abstractmethod
def condition(self, json_instance: Json) -> bool:
    """Data 구축 시 filtering 될 조건

    Args:
        json_instance: `Json` instance

    Returns:
        Data 포함 여부

    아래와 같이 상속을 통해 조건을 설정할 수 있다.

    Examples:
        Condition:
            ```python
            class MakeDataCar(zz.util.MakeData):
                def condition(self, json_instance):
                    key = json_instance._get_key("supercategory_name")
                    category = json_instance._get_value(key)
                    return category == "CityCar" or category == "Mid-size car"
            ```

        Condition & Make Data:
            ```python
            class MakeDataCarDamage(zz.util.MakeData):
                def condition(self, json_instance):
                    annotations = json_instance.get("annotations")
                    return (annotations[0]["color"] in ["White", "Black"]) and (
                        json_instance.get("supercategory_name") == "CityCar"
                    )
                def make_data(self, json_instance, data_name):
                    img = cv2.imread(os.path.join(self.start_data_path, data_name))
                    for i, ant in enumerate(json_instance["annotations"]):
                        label = ant["damage"]
                        if not label is None:
                            poly = ant["segmentation"]
                            poly = np.array(poly[0][0])
                            tmp = zz.vision.cutout(img, poly)
                            h, w, _ = tmp.shape
                            if 100 <= h <= 300 and 100 <= w <= 300:
                                file_name = ".".join(data_name.split(".")[:-1]) + f"_{i}"
                                xm, ym = poly[:, 0].min(), poly[:, 1].min()
                                poly -= (xm, ym)
                                cv2.imwrite(
                                    os.path.join(
                                        self.end_data_path,
                                        f"{file_name}.png",
                                    ),
                                    tmp,
                                )
                                zz.util.write_json(
                                    {"name": f"{file_name}.png", "poly": poly.tolist()},
                                    os.path.join(self.end_json_path, file_name),
                                )
            ```

        Make Data:
            ```python
            class MakeDataCarAugment(zz.util.MakeData):
                def make_data(self, json_instance, data_name):
                    img = cv2.imread(
                        random.choice(glob("*"))
                    )
                    target = cv2.imread(
                        os.path.join(self.start_data_path, data_name), cv2.IMREAD_UNCHANGED
                    )
                    H, W, _ = img.shape
                    h, w, _ = target.shape
                    x, y = random.randrange(100, W - w - 100), random.randrange(100, H - h - 100)
                    box = [x, y, x + w, y + h]
                    img = zz.vision.paste(img, target, box, False, False)
                    file_name = ".".join(data_name.split(".")[:-1])
                    cv2.imwrite(
                        os.path.join(
                            self.end_data_path,
                            f"{file_name}.png",
                        ),
                        img,
                    )
            ```
    """
    return True

def make(self) -> None:
    """Data 구축 실행

    .. warning::

        실행 시 `target_path` 삭제 후 구축 진행

    Examples:
        >>> md = MakeData(start_data_path, start_json_path, json_key, target_path)
        >>> md.make()
        100%|█████████████| 403559/403559 [00:54<00:00, 7369.96it/s]
        ====================================================================================================
        DATA PATH:       /.../data
        JSON PATH:       /.../json
        ====================================================================================================
        100%|█████████████| 403559/403559 [01:04<00:00, 6292.39it/s]
    """
    rmtree(self.target_path)
    print("=" * 100)
    print("DATA PATH:\t", self.end_data_path)
    print("JSON PATH:\t", self.end_json_path)
    print("=" * 100)
    os.makedirs(self.end_data_path, exist_ok=True)
    os.makedirs(self.end_json_path, exist_ok=True)
    for json_instance in tqdm(self.json):
        data_name = json_instance._get_value(self.json_key)
        if self.condition(json_instance):
            self.make_data(json_instance, data_name)

def make_data(self, json_instance: Json, data_name: str) -> None:
    """Data 구축 방법 정의

    Args:
        json_instance: `Json` instance
        data_name: `json_key` 에 의해 출력된 data의 이름

    Returns:
        `end_data_path`, `end_json_path` 와 본 method를 통해 data 구축
    """
    try:
        shutil.copy(
            os.path.join(self.start_data_path, data_name),
            os.path.join(self.end_data_path, data_name),
        )
        shutil.copy(
            os.path.join(self.start_json_path, json_instance.name),
            os.path.join(self.end_json_path, json_instance.name),
        )
    except FileNotFoundError:
        print("Missing:\t", os.path.join(self.start_data_path, data_name))