koro 1.0.7__py3-none-any.whl → 1.1.0__py3-none-any.whl

koro/file/__init__.py

@@ -2,6 +2,10 @@ from os import remove
 from os.path import abspath, exists
 from shutil import rmtree
 
+from . import bin, dir, lvl, zip
+
+__all__ = ["bin", "dir", "Location", "lvl", "zip"]
+
 
 class Location:
     __match_args__ = ("path",)

koro/file/bin.py

@@ -0,0 +1,178 @@
+from itertools import chain
+from typing import Final
+
+from ..item.level import Level, LevelNotFoundError
+from . import Location
+
+__all__ = ["BinLevel", "BinLevelNotFoundError"]
+
+
+class BinLevelNotFoundError(FileNotFoundError, LevelNotFoundError):
+    pass
+
+
+class BinLevel(Location, Level):
+    __slots__ = ()
+
+    @staticmethod
+    def compress(data: bytes, /) -> bytes:
+        """Compress the given level data into the game's format."""
+        buffer: bytearray = bytearray(1024)
+        buffer_index: int = 958
+        chunk: bytearray
+        data_index: int = 0
+        output: Final[bytearray] = bytearray(
+            b"\x00\x00\x00\x01\x00\x00\x00\x08"
+            + len(data).to_bytes(4, byteorder="big")
+            + b"\x00\x00\x00\x01"
+        )
+        reference_indices: list[int]
+        test_buffer: bytearray
+        test_length: int
+        test_reference_indicies: list[int]
+        while data_index < len(data):
+            chunk = bytearray(b"\x00")
+            for _ in range(8):
+                if data_index >= len(data):
+                    output.extend(chunk)
+                    return output
+                if len(data) - data_index <= 2:
+                    buffer[buffer_index] = data[data_index]
+                    buffer_index = buffer_index + 1 & 1023
+                    chunk[0] = chunk[0] >> 1 | 128
+                    chunk.append(data[data_index])
+                    data_index += 1
+                    continue
+                reference_indices = []
+                for i in chain(range(buffer_index, 1024), range(buffer_index)):
+                    if data[data_index] == buffer[i]:
+                        reference_indices.append(i)
+                if not reference_indices:
+                    buffer[buffer_index] = data[data_index]
+                    buffer_index = buffer_index + 1 & 1023
+                    chunk[0] = chunk[0] >> 1 | 128
+                    chunk.append(data[data_index])
+                    data_index += 1
+                    continue
+                test_buffer = buffer.copy()
+                test_buffer[buffer_index] = data[data_index]
+                for i in reference_indices.copy():
+                    if data[data_index + 1] != test_buffer[i - 1023]:
+                        reference_indices.remove(i)
+                if not reference_indices:
+                    buffer[buffer_index] = data[data_index]
+                    buffer_index = buffer_index + 1 & 1023
+                    chunk[0] = chunk[0] >> 1 | 128
+                    chunk.append(data[data_index])
+                    data_index += 1
+                    continue
+                test_buffer[buffer_index - 1023] = data[data_index + 1]
+                for i in reference_indices.copy():
+                    if data[data_index + 2] != test_buffer[i - 1022]:
+                        reference_indices.remove(i)
+                if not reference_indices:
+                    buffer[buffer_index] = data[data_index]
+                    buffer_index = buffer_index + 1 & 1023
+                    chunk[0] = chunk[0] >> 1 | 128
+                    chunk.append(data[data_index])
+                    data_index += 1
+                    continue
+                test_length = 4
+                test_reference_indicies = reference_indices.copy()
+                while test_length <= min(66, len(data) - data_index):
+                    test_buffer[buffer_index + test_length - 1025] = data[
+                        data_index + test_length - 1
+                    ]
+                    for i in test_reference_indicies.copy():
+                        if (
+                            data[data_index + test_length - 1]
+                            != test_buffer[i + test_length - 1025]
+                        ):
+                            test_reference_indicies.remove(i)
+                    if test_reference_indicies:
+                        reference_indices = test_reference_indicies.copy()
+                    else:
+                        break
+                    test_length += 1
+                chunk[0] >>= 1
+                test_length -= 1
+                if buffer_index + test_length >= 1024:
+                    buffer[buffer_index:] = data[
+                        data_index : data_index + 1024 - buffer_index
+                    ]
+                    buffer[: buffer_index + test_length - 1024] = data[
+                        data_index + 1024 - buffer_index : data_index + test_length
+                    ]
+                else:
+                    buffer[buffer_index : buffer_index + test_length] = data[
+                        data_index : data_index + test_length
+                    ]
+                buffer_index = buffer_index + test_length & 1023
+                chunk.extend(
+                    (
+                        reference_indices[0] & 255,
+                        reference_indices[0] >> 2 & 192 | test_length - 3,
+                    )
+                )
+                data_index += test_length
+            output.extend(chunk)
+        return output + b"\x00"
+
+    @staticmethod
+    def decompress(data: bytes, /) -> bytes:
+        """Decompress the given data into raw level data."""
+        buffer: Final[bytearray] = bytearray(1024)
+        buffer_index: int = 958
+        handle: int | bytearray
+        flags: int
+        offset: int
+        raw: Final[bytearray] = bytearray(data[:15:-1])
+        ref: bytes
+        result: Final[bytearray] = bytearray()
+        result_size: Final[int] = int.from_bytes(data[8:12], byteorder="big")
+        while len(result) < result_size:
+            flags = raw.pop()
+            for _ in range(8):
+                if flags & 1:
+                    handle = raw.pop()
+                    buffer[buffer_index] = handle
+                    buffer_index = buffer_index + 1 & 1023
+                    result.append(handle)
+                else:
+                    if len(raw) < 2:
+                        return result
+                    ref = bytes((raw.pop() for _ in range(2)))
+                    offset = (ref[1] << 2 & 768) + ref[0]
+                    handle = bytearray()
+                    for i in range((ref[1] & 63) + 3):
+                        handle.append(buffer[offset + i - 1024])
+                        buffer[buffer_index] = handle[-1]
+                        buffer_index = buffer_index + 1 & 1023
+                    result.extend(handle)
+                flags >>= 1
+        return result.replace(b"<EDITUSER> 3 </EDITUSER>", b"<EDITUSER> 2 </EDITUSER>")
+
+    def delete(self) -> None:
+        try:
+            return super().delete()
+        except FileNotFoundError as e:
+            raise BinLevelNotFoundError(*e.args)
+
+    def __len__(self) -> int:
+        try:
+            with open(self.path, "rb") as f:
+                f.seek(8)
+                return int.from_bytes(f.read(4), byteorder="big")
+        except FileNotFoundError as e:
+            BinLevelNotFoundError(*e.args)
+
+    def read(self) -> bytes:
+        try:
+            with open(self.path, "rb") as f:
+                return self.decompress(f.read())
+        except FileNotFoundError as e:
+            raise BinLevelNotFoundError(*e.args)
+
+    def write(self, new_content: bytes, /) -> None:
+        with open(self.path, "wb") as f:
+            f.write(self.compress(new_content))

koro/file/dir.py

@@ -7,14 +7,19 @@ from typing import Final, Optional, SupportsIndex, TypeGuard, overload
 from ..item.group import Group
 from ..item.level import Level, LevelNotFoundError
 from ..item.save import Page, Save
-
 from . import Location
 
+__all__ = ["DirGroup", "DirLevel", "DirLevelNotFoundError", "DirSave"]
+
 _BLOCK_SIZE: Final[int] = 2048
 _EMPTY_BLOCK: Final[bytes] = b"\x00" * _BLOCK_SIZE
 _LEVEL_ALLOCATION_SIZE: Final[int] = 156864
 
 
+class DirLevelNotFoundError(LevelNotFoundError):
+    pass
+
+
 class DirLevel(Level):
     __match_args__ = ("path", "page", "id")
     __slots__ = ("_offset", "_path")
@@ -45,7 +50,7 @@ class DirLevel(Level):
                     f.write(_EMPTY_BLOCK)
                     more = f.read(1) != b"\x00"
             else:
-                raise LevelNotFoundError
+                raise DirLevelNotFoundError
 
     def __eq__(self, other: object, /) -> bool:
         return (
@@ -62,23 +67,26 @@ class DirLevel(Level):
         return int(self._path[-5]) % 5 << 2 | self._offset // _LEVEL_ALLOCATION_SIZE
 
     def __len__(self) -> int:
-        with open(self._path, "rb") as f:
-            f.seek(self._offset)
-            block: Final[bytearray] = bytearray(f.read(_BLOCK_SIZE))
-            block_offset: int = 0
-            while block[-1]:
-                f.readinto(block)
-                block_offset += _BLOCK_SIZE
-            hi: int = _BLOCK_SIZE - 1
-            lo: int = 0
-            test: int
-            while hi != lo:
-                test = (hi - lo >> 1) + lo
-                if block[test]:
-                    lo = test + 1
-                else:
-                    hi = test
-            return block_offset + hi
+        if self:
+            with open(self._path, "rb") as f:
+                f.seek(self._offset)
+                block: Final[bytearray] = bytearray(f.read(_BLOCK_SIZE))
+                block_offset: int = 0
+                while block[-1]:
+                    f.readinto(block)
+                    block_offset += _BLOCK_SIZE
+                hi: int = _BLOCK_SIZE - 1
+                lo: int = 0
+                test: int
+                while hi != lo:
+                    test = (hi - lo >> 1) + lo
+                    if block[test]:
+                        lo = test + 1
+                    else:
+                        hi = test
+                return block_offset + hi
+        else:
+            raise DirLevelNotFoundError
 
     @property
     def page(self) -> Page:
@@ -108,7 +116,7 @@ class DirLevel(Level):
                         hi = test
                 return bytes(result + block[:hi])
             else:
-                raise LevelNotFoundError
+                raise DirLevelNotFoundError
 
     def __repr__(self) -> str:
         return f"{type(self).__name__}({self.path!r}, {self.page!r}, {self.id!r})"

koro/file/lvl.py

@@ -1,10 +1,10 @@
 from os.path import getsize
+from warnings import warn
 
 from ..item.level import Level, LevelNotFoundError
-
 from . import Location
 
-__all__ = ["LvlLevel"]
+__all__ = ["LvlLevel", "LvlLevelNotFoundError"]
 
 
 class LvlLevelNotFoundError(FileNotFoundError, LevelNotFoundError):
@@ -14,6 +14,14 @@ class LvlLevelNotFoundError(FileNotFoundError, LevelNotFoundError):
 class LvlLevel(Location, Level):
     __slots__ = ()
 
+    def __init__(self, path: str, /) -> None:
+        super().__init__(path)
+        warn(
+            FutureWarning(
+                "The LVL format for storing level data is deprecated. Level data should be converted to the BIN format using BinLevel for better compression and compatibility."
+            )
+        )
+
     def delete(self) -> None:
         try:
             return super().delete()

koro/file/zip.py

@@ -4,17 +4,22 @@ from operator import index
 from os.path import abspath
 from re import fullmatch
 from typing import Final, Optional, SupportsIndex, TypeGuard, overload
+from warnings import warn
 from zipfile import ZipFile, ZipInfo
 
 from ..item.group import Group
 from ..item.level import Level, LevelNotFoundError
-
 from . import Location
+from .bin import BinLevel
 
-__all__ = ["ZipGroup", "ZipLevel"]
+__all__ = ["ZipGroup", "ZipLevel", "ZipLevelNotFoundError"]
 
 
 def _id_to_fn(id: SupportsIndex, /) -> str:
+    return f"{str(index(id) + 1).zfill(2)}.bin"
+
+
+def _id_to_old_fn(id: SupportsIndex, /) -> str:
     return f"{str(index(id) + 1).zfill(2)}.lvl"
 
 
@@ -43,11 +48,12 @@ class ZipLevel(Level):
 
     def delete(self) -> None:
         with ZipFile(self.path) as a:
-            if self.fn not in a.namelist():
+            if self.fn not in a.namelist() and self.old_fn not in a.namelist():
                 raise ZipLevelNotFoundError
             contents: Final[dict[ZipInfo, bytes]] = {}
             for info in filterfalse(
-                lambda info: info.filename == self.fn, a.infolist()
+                lambda info: info.filename == self.fn or info.filename == self.old_fn,
+                a.infolist(),
             ):
                 contents[info] = a.read(info)
         with ZipFile(self.path, "w") as a:
@@ -73,22 +79,38 @@ class ZipLevel(Level):
         return self._id
 
     def __len__(self) -> int:
-        try:
-            with ZipFile(self.path) as a:
-                return a.getinfo(self.fn).file_size
-        except KeyError as e:
-            raise ZipLevelNotFoundError(*e.args)
+        with ZipFile(self.path) as a:
+            try:
+                a.getinfo(self.fn)
+            except KeyError:
+                try:
+                    return a.getinfo(self.old_fn).file_size
+                except KeyError:
+                    raise ZipLevelNotFoundError
+            else:
+                return int.from_bytes(a.read(self.fn)[8:12], byteorder="big")
+
+    @property
+    def old_fn(self) -> str:
+        return _id_to_old_fn(self.id)
 
     @property
     def path(self) -> str:
         return self._path
 
     def read(self) -> bytes:
-        try:
-            with ZipFile(self.path) as a:
-                return a.read(self.fn)
-        except KeyError as e:
-            raise ZipLevelNotFoundError(*e.args)
+        with ZipFile(self.path) as a:
+            try:
+                a.getinfo(self.fn)
+            except KeyError:
+                try:
+                    a.getinfo(self.old_fn)
+                except KeyError:
+                    raise ZipLevelNotFoundError
+                else:
+                    return a.read(self.old_fn)
+            else:
+                return BinLevel.decompress(a.read(self.fn))
 
     def __repr__(self) -> str:
         return f"{type(self).__name__}({self.path!r}, {self.id!r})"
@@ -97,18 +119,31 @@ class ZipLevel(Level):
         contents: Final[dict[ZipInfo, bytes]] = {}
         with ZipFile(self.path, "a") as a:
             for info in filterfalse(
-                lambda info: info.filename == self.fn, a.infolist()
+                lambda info: info.filename == self.fn or info.filename == self.old_fn,
+                a.infolist(),
             ):
                 contents[info] = a.read(info)
         with ZipFile(self.path, "w") as a:
             for x in contents.items():
                 a.writestr(*x)
-            a.writestr(self.fn, new_content)
+            a.writestr(self.fn, BinLevel.compress(new_content))
 
 
-class ZipGroup(Group[ZipLevel], Location):
+class ZipGroup(Location, Group[ZipLevel]):
     __slots__ = ()
 
+    def __init__(self, path: str) -> None:
+        super().__init__(path)
+        with ZipFile(self.path) as a:
+            for id in range(20):
+                if _id_to_old_fn(id) in a.namelist():
+                    warn(
+                        FutureWarning(
+                            "This ZipGroup contains levels using the deprecated LVL format. Update this file by writing to it or by using the update function."
+                        )
+                    )
+                    break
+
     def __contains__(self, value: object, /) -> TypeGuard[ZipLevel]:
         return isinstance(value, ZipLevel) and value.path == self.path
 
@@ -139,28 +174,40 @@ class ZipGroup(Group[ZipLevel], Location):
         else:
             raise ValueError
 
-    def init(self) -> None:
-        with ZipFile(self.path, "x") as a:
-            pass
-
     def fill_mask(self) -> Sequence[bool]:
         with ZipFile(self.path) as a:
-            return [_id_to_fn(i) in a.namelist() for i in range(20)]
+            return [
+                _id_to_fn(i) in a.namelist() or _id_to_old_fn in a.namelist()
+                for i in range(20)
+            ]
 
     def read(self) -> Iterable[Optional[bytes]]:
         with ZipFile(self.path) as a:
-            name_list: Final[list[str]] = a.namelist()
             return [
-                a.read(fn) if fn in name_list else None
-                for fn in map(_id_to_fn, range(20))
+                BinLevel.decompress(a.read(_id_to_fn(id)))
+                if _id_to_fn(id) in a.namelist()
+                else a.read(_id_to_old_fn(id))
+                if _id_to_old_fn(id) in a.namelist()
+                else None
+                for id in range(20)
             ]
 
+    def update(self) -> None:
+        self.write(self.read())
+        warn(
+            FutureWarning(
+                "This function will be removed alongside support for the LVL format, and exists soley as a convienient way of converting existing ZIP files to the new BIN format."
+            )
+        )
+
     def write(self, new_content: Iterable[Optional[bytes]], /) -> None:
         contents: Final[dict[ZipInfo, bytes]] = {}
         if self:
             with ZipFile(self.path) as a:
                 for info in filterfalse(
-                    lambda info: fullmatch(r"(0[1-9]|1\d|20)\.lvl", info.filename),
+                    lambda info: fullmatch(
+                        r"(0[1-9]|1\d|20)\.(bin|lvl)", info.filename
+                    ),
                     a.infolist(),
                 ):
                     contents[info] = a.read(info)
@@ -170,4 +217,4 @@ class ZipGroup(Group[ZipLevel], Location):
             for id, content in filterfalse(
                 lambda x: x[1] is None, enumerate(new_content)
             ):
-                a.writestr(_id_to_fn(id), content)
+                a.writestr(_id_to_fn(id), BinLevel.compress(content))

koro/item/__init__.py

@@ -0,0 +1,3 @@
+from .group import *
+from .level import *
+from .save import *

koro/item/group.py

@@ -0,0 +1,47 @@
+from abc import ABC
+from collections.abc import Iterable, Sequence
+from typing import Final, Generic, Optional, TypeVar
+
+from .level import Level, LevelNotFoundError
+
+__all__ = ["Group"]
+
+_L = TypeVar("_L", bound=Level)
+
+
+class Group(ABC, Generic[_L], Sequence[_L]):
+    """A group of 20 levels.
+    Note that levels are 0-indexed within this interface, but 1-indexed in-game.
+    """
+
+    __slots__ = ()
+
+    def fill_mask(self) -> Sequence[bool]:
+        """Return which level IDs within this Group exist."""
+        return [bool(l) for l in self]
+
+    def __len__(self) -> int:
+        return 20
+
+    def read(self) -> Iterable[Optional[bytes]]:
+        """Read all of the levels within this Group. Empty slots yield None."""
+        content: Optional[bytes]
+        result: Final[list[Optional[bytes]]] = []
+        for level in self:
+            try:
+                content = level.read()
+            except LevelNotFoundError:
+                content = None
+            result.append(content)
+        return result
+
+    def write(self, new_content: Iterable[Optional[bytes]], /) -> None:
+        """Replace the contents of this Group with the specified new content. None values will empty the slot they correspond to."""
+        for src, dest in zip(new_content, self, strict=True):
+            if src is None:
+                try:
+                    dest.delete()
+                except LevelNotFoundError:
+                    pass
+            else:
+                dest.write(src)

koro/item/level.py

@@ -0,0 +1,108 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sized
+from dataclasses import dataclass
+from enum import Enum, unique
+from typing import Final
+from warnings import warn
+
+__all__ = ["Level", "LevelNotFoundError", "LevelStatistics", "Theme"]
+
+
+@unique
+class Theme(Enum):
+    THE_EMPTY_LOT = 0
+    NEIGHBORS_HOUSE = 1
+    SIZZLIN_DESERT = 2
+    CHILL_MOUNTAIN = 3
+    OCEAN_TREASURE = 4
+    SPACE_STATION = 5
+    STUMP_TEMPLE = 6
+    CANDY_ISLAND = 7
+    HAUNTED_HOUSE = 8
+    CITY = 9
+    TUTORIAL = 11
+    HAUNTED_HOUSE_DARKNESS = 12
+    NIGHT_CITY = 13
+
+    def __str__(self) -> str:
+        return (
+            "The Empty Lot",
+            "Neighbor's House",
+            "Sizzlin' Desert",
+            "Chill Mountain",
+            "Ocean Treasure",
+            "Space Station",
+            "Stump Temple",
+            "Candy Island",
+            "Haunted House",
+            "City",
+            None,
+            "Tutorial",
+            "Haunted House Darkness",
+            "Night City",
+        )[self.value]
+
+
+@dataclass(frozen=True, match_args=False, kw_only=True, slots=True)
+class LevelStatistics:
+    crystals: int
+    filesize: int
+    theme: Theme
+
+
+class LevelNotFoundError(LookupError):
+    pass
+
+
+class Level(ABC, Sized):
+    __slots__ = ()
+
+    def about(self) -> LevelStatistics:
+        content: Final[bytes] = self.read()
+        return LevelStatistics(
+            crystals=content.count(b"<anmtype> 49 </anmtype>"),
+            filesize=len(content),
+            theme=Theme(int(content[87:89])),
+        )
+
+    @abstractmethod
+    def __bool__(self) -> bool:
+        """Return whether this level exists."""
+
+    @abstractmethod
+    def delete(self) -> None:
+        """Delete this level if it exists, otherwise raise LevelNotFoundError."""
+        pass
+
+    def encode(self) -> bytes:
+        """Return a bytes object that when written to a file can overwrite an official level."""
+        warn(
+            FutureWarning(
+                "The use of this function is deprecated as the new BIN format is compatible with the official levels and can be substituted into the game directly."
+            )
+        )
+        data: Final[bytearray] = bytearray(self.read())
+        header: Final[bytes] = (
+            b"\x00\x00\x00\x01\x00\x00\x00\x08"
+            + len(data).to_bytes(4, byteorder="big")
+            + b"\x00\x00\x00\x01"
+        )
+        i: int = 0
+        while i < len(data):
+            data.insert(i, 255)
+            i += 9
+        return header + data + b"\x00"
+
+    def __len__(self) -> int:
+        """The file size of this level."""
+        return len(self.read())
+
+    @abstractmethod
+    def read(self) -> bytes:
+        """Return the contents of this level if it exists, otherwise raise LevelNotFoundError."""
+        pass
+
+    @abstractmethod
+    def write(self, new_content: bytes, /) -> None:
+        """Replace the contents of this level, or create it if it doesn't exist."""
+        pass

koro/item/save.py

@@ -0,0 +1,29 @@
+from abc import ABC
+from collections.abc import Iterator, Mapping
+from enum import Enum, unique
+from typing import Generic, TypeGuard, TypeVar
+
+from .group import Group
+
+__all__ = ["Save", "Page"]
+
+_G = TypeVar("_G", bound=Group)
+
+
+@unique
+class Page(Enum):
+    ORIGINAL = 0
+    FRIEND = 1
+
+
+class Save(ABC, Generic[_G], Mapping[Page, _G]):
+    __slots__ = ()
+
+    def __contains__(self, key: object, /) -> TypeGuard[Page]:
+        return isinstance(key, Page)
+
+    def __iter__(self) -> Iterator[Page]:
+        return iter(Page)
+
+    def __len__(self) -> int:
+        return 2

{koro-1.0.7.dist-info → koro-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: koro
-Version: 1.0.7
+Version: 1.1.0
 Summary: Tools for manipulating levels made in Marble Saga: Kororinpa
 Home-page: https://github.com/DigitalDetective47/koro
 Author: DigitalDetective47

koro-1.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+koro/__init__.py,sha256=clmcgzd33gY_tOC3U5U-010NYVZZrC-9Og6AYAovIjo,176
+koro/file/__init__.py,sha256=rrsPxeKSG6WXprbO-xDZR1E9GdQ2xuzPvoZ08C3QSQc,1038
+koro/file/bin.py,sha256=2rV6BQN-6HH-ilV8WpInI5xWjds9Mo3_4kzQLEDPmqU,7482
+koro/file/dir.py,sha256=pnMQJAQRlzcm_MC14goDeKlQ3llKhywM1FdADHM8xds,6632
+koro/file/lvl.py,sha256=lrVpQyZFj1JlVPYx-OkcCne8VdjHCWQIuOX0pls1Dto,1130
+koro/file/zip.py,sha256=hFV3rnro0pTeg7mpoKEvQnO-Oo93_DgnxJQCJupkVI8,7332
+koro/item/__init__.py,sha256=3RXQS-HSN6EDGLk6sY4xip-oy8JiV31XshsCWVCgie8,65
+koro/item/group.py,sha256=lwmx_1FMD4LdOxxuqPDN2Dl_8MZD9OJcy259SS8Apzk,1538
+koro/item/level.py,sha256=KXiOK3RGC72WK4lduf3RO9Cs1zXaJRk0EfJCDndA4bs,3068
+koro/item/save.py,sha256=LUV79vW3gY__jVVVG1kcYW-wzsGCRlYq126nulbT37Y,607
+koro-1.1.0.dist-info/LICENSE,sha256=Q2ptU2E48gOsMzhYz_kqVovmJ5d1KzrblLyqD2_-fvY,1235
+koro-1.1.0.dist-info/METADATA,sha256=5Tt71Gav-Itj_GMxWkdYMaMCxssxWLpHmqiRxdfojY0,628
+koro-1.1.0.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+koro-1.1.0.dist-info/top_level.txt,sha256=Msq6ssMwv56hnBQqwaTdJJkxM7x7BZ-3JfQbkepQAEY,5
+koro-1.1.0.dist-info/RECORD,,

{koro-1.0.7.dist-info → koro-1.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.41.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

koro-1.0.7.dist-info/RECORD

@@ -1,10 +0,0 @@
-koro/__init__.py,sha256=clmcgzd33gY_tOC3U5U-010NYVZZrC-9Og6AYAovIjo,176
-koro/file/__init__.py,sha256=_UIx5h1YBoheqQeorBV5XrbZXusAOipbFsesqUeLJwk,948
-koro/file/dir.py,sha256=sxNM_COlADES3oVnlutApXPd2SvWuANRnxMC6RdQ448,6348
-koro/file/lvl.py,sha256=cxOJGuzzs3yVTAdi-clhXPn1A7-TU3p-FJW3JLZBTyY,752
-koro/file/zip.py,sha256=hK8XemvmM3dhyNPevCt9lXm0p24HYbzyHp40yA5O5cg,5472
-koro-1.0.7.dist-info/LICENSE,sha256=Q2ptU2E48gOsMzhYz_kqVovmJ5d1KzrblLyqD2_-fvY,1235
-koro-1.0.7.dist-info/METADATA,sha256=crpDh19AkPI1uTIzGUGA1Qr84CvGVhNVUc5DIJchWYI,628
-koro-1.0.7.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-koro-1.0.7.dist-info/top_level.txt,sha256=Msq6ssMwv56hnBQqwaTdJJkxM7x7BZ-3JfQbkepQAEY,5
-koro-1.0.7.dist-info/RECORD,,