UnityManager 0.0.1a1__py3-none-any.whl

UnityManager/__init__.py

@@ -0,0 +1,41 @@
+"""Utilities for formatting common units.
+
+The package exposes byte, length, capacity, mass and volume formatters at the
+package level for convenient imports.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+
+from .bytes import format_bytes
+from .length import format_length
+from .measure import format_capacity, format_mass, format_volume
+
+__version__ = "0.0.1-alpha1"
+__author__ = "PlayGames-2020"
+__summary__ = "Utilities for formatting common units."
+
+_match = re.match(r"(\d+)\.(\d+)\.(\d+)(?:-(.+))?", __version__)
+
+if _match: major, minor, patch, tag = _match.groups() 
+else: major, minor, patch, tag = 0, 0, 0, "unknown"
+
+VERSION_INFO = (int(major), int(minor), int(patch), tag or "release")
+
+NAME = __name__
+
+_REQUIRED_PY = (3, 9)
+if sys.version_info < (3, 9):
+    runtime = ".".join(str(v) for v in (_REQUIRED_PY))
+    info = f"{__name__} requires Python {runtime} or higher" \
+    f"(current: {sys.version.split()[0]})"
+    print(info)
+    raise RuntimeError(info)
+
+
+__all__ = [
+    "__version__", "VERSION_INFO", "NAME", 
+    "format_volume", "format_mass", "format_capacity", "format_length", "format_bytes"
+]

UnityManager/_units.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import List, Literal, Tuple, Union
+
+_Mode = Union[str, Literal["n", "s", "d", "v", "lower", "upper", "title"]]
+_TextMode = _Mode
+_MeasureTextMode = _TextMode
+_BytesTextMode = Union[str, Literal["s", "n", "d", "upper", "lower", "title", "byte", "bit"]]
+
+_BYTES_TABLE: List[Tuple[str, str, Union[int, float], str]] = [
+    ("zettabyte", "ZB", 1024**7, ""),
+    ("exabyte", "EB", 1024**6, ""),
+    ("petabyte", "PB", 1024**5, ""),
+    ("terabyte", "TB", 1024**4, ""),
+    ("gigabyte", "GB", 1024**3, ""),
+    ("megabyte", "MB", 1024**2, ""),
+    ("kilobyte", "KB", 1024, ""),
+    ("byte", "B", 1, ""),
+    ("bit", "b", 1 / 8, ""),
+]
+
+_LENGTH_TABLE: List[Tuple[str, str, float, str]] = [
+    ("kilometre", "km", 1000.0, ""),
+    ("hectometre", "hm", 100.0, ""),
+    ("decametre", "dam", 10.0, ""),
+    ("metre", "m", 1.0, ""),
+    ("decimetre", "dm", 0.1, ""),
+    ("centimetre", "cm", 0.01, ""),
+    ("millimetre", "mm", 0.001, ""),
+]
+
+_CAPACITY_TABLE: List[Tuple[str, str, float, str]] = [
+    ("kilolitre", "kl", 1000.0, ""),
+    ("hectolitre", "hl", 100.0, ""),
+    ("decalitre", "dal", 10.0, ""),
+    ("litre", "l", 1.0, ""),
+    ("decilitre", "dl", 0.1, ""),
+    ("centilitre", "cl", 0.01, ""),
+    ("millilitre", "ml", 0.001, ""),
+]
+
+_MASS_TABLE: List[Tuple[str, str, float, str]] = [
+    ("kilogram", "kg", 1000.0, ""),
+    ("hectogram", "hg", 100.0, ""),
+    ("decagram", "dag", 10.0, ""),
+    ("gram", "g", 1.0, ""),
+    ("decigram", "dg", 0.1, ""),
+    ("centigram", "cg", 0.01, ""),
+    ("milligram", "mg", 0.001, ""),
+]
+
+_VOLUME_TABLE: List[Tuple[str, str, Union[int, float], str]] = [
+    ("kilometre cubic", "km³", 1_000_000_000.0, ""),
+    ("hectometre cubic", "hm³", 1_000_000.0, ""),
+    ("decametre cubic", "dam³", 1_000.0, ""),
+    ("metre cubic", "m³", 1.0, ""),
+    ("decimetre cubic", "dm³", 0.001, ""),
+    ("centimetre cubic", "cm³", 0.000_001, ""),
+    ("millimetre cubic", "mm³", 0.000_000_001, ""),
+]

UnityManager/bytes.py

@@ -0,0 +1,55 @@
+""""""
+
+from typing import Union, Any, List
+from decimal import Decimal
+
+from ._units import _BYTES_TABLE, _BytesTextMode
+
+def format_bytes(n: Union[int, Any], mode: _BytesTextMode = "s") -> str:
+    """Format a byte value using binary units.
+
+    Values are divided by powers of 1024 and rounded to two decimals. The
+    default mode, ``"s"``, displays the unit symbol. ``"n"`` displays the
+    unit name, ``"d"`` its description, and ``"byte"`` or ``"bit"`` adds a
+    conversion note. Case modifiers can be combined with these modes.
+
+    Non-numeric values are returned as text.
+
+    Examples:
+        >>> format_bytes(1024)
+        '1.00 KB'
+        >>> format_bytes(1024, "n")
+        '1.00 kilobyte'
+    """
+    if not isinstance(n, (int, float, Decimal)): return str(n)
+    
+    amount = Decimal(str(n))
+    abs_n = abs(amount)
+    unit_name: str
+    unit_symbol: str
+    unit_description: str
+    unit_name, unit_symbol, unit_description = "bit", "b", ""
+    for name, symbol, limit, description in _BYTES_TABLE:
+        _limit = Decimal(str(limit))
+        if abs_n >= limit:
+            amount = amount / _limit
+            unit_name, unit_symbol, unit_description = name, symbol, description
+            break
+
+    parts: List[str] = []
+
+    if "s" in mode: parts.append(unit_symbol)
+    if "n" in mode: parts.append(unit_name)
+    if "d" in mode: parts.append(unit_description)
+    if "upper" in mode: parts = [p.upper() for p in parts]
+    if "lower" in mode: parts = [p.lower() for p in parts]
+    if "title" in mode: parts = [p.title() for p in parts]
+    if "byte" in mode: parts.append(f"({n} bytes)")
+    if "bit" in mode: parts.append(f"({n / 8} bits)")
+
+    suffix = " ".join(parts)
+    return f"{amount:.2f}{f' {suffix}' if suffix else ''}"
+
+__all__ = [
+    "format_bytes"
+]

UnityManager/length.py

@@ -0,0 +1,49 @@
+"""Format metric length quantities for display."""
+from typing import Any, List, Literal, Union
+from decimal import Decimal
+
+from ._units import _LENGTH_TABLE, _TextMode
+_LengthTextMode = _TextMode
+
+def format_length(n: Union[int, Any], mode: _LengthTextMode = "s") -> str:
+    """Format a length in metric units, from millimetres to kilometres.
+
+    The input is interpreted as metres. The largest suitable unit is selected
+    automatically and the result is rounded to two decimal places. Use
+    ``"s"`` for the symbol, ``"n"`` for the name, ``"v"`` for the original
+    value, and combine these with ``"upper"``, ``"lower"`` or ``"title"``.
+
+    Non-numeric values are returned as text.
+    """
+    if not isinstance(n, (int, float, Decimal)): return str(n)
+
+    abs_n = abs(Decimal(str(n)))
+    amount = Decimal(str(n))
+    name, symbol, description = "metre", "m", ""
+
+    for name_item, symbol_item, limit, desc_item in _LENGTH_TABLE:
+        if limit >= 1 and abs_n >= Decimal(str(limit)):
+            amount = Decimal(str(n)) / Decimal(str(limit))
+            name, symbol, description = name_item, symbol_item, desc_item
+            break
+        elif limit < 1 and abs_n >= Decimal(str(limit)):
+            amount = Decimal(str(n)) / Decimal(str(limit))
+            name, symbol, description = name_item, symbol_item, desc_item
+            break
+
+    parts: List[str] = []
+    if "n" in mode: parts.append(name)
+    if "s" in mode: parts.append(symbol)
+    if "d" in mode: parts.append(description)
+    if "v" in mode: parts.append(f"({float(n)} m)")
+    if "lower" in mode: parts = [p.lower() for p in parts]
+    if "upper" in mode: parts = [p.upper() for p in parts]
+    if "title" in mode: parts = [p.title() for p in parts]
+    
+    suffix = " ".join(parts).strip()
+    return f"{amount:.2f}{f' {suffix}' if suffix else ''}"
+
+
+__all__ = [
+    "format_length"
+]

UnityManager/measure.py

@@ -0,0 +1,49 @@
+"""Format capacity, mass and volume quantities for display."""
+from typing import Any, List, Literal, Union, Tuple
+from decimal import Decimal
+
+from ._units import (
+    _CAPACITY_TABLE, _MASS_TABLE, _VOLUME_TABLE, _MeasureTextMode
+)
+
+def _generic_formatter(n: Union[int, Any], table: List[Tuple], default_unit: Tuple, base_symbol: str, mode: _MeasureTextMode = "s") -> str:
+    """Format a numeric measurement using the supplied unit table."""
+    if not isinstance(n, (int, float, Decimal)): return str(n)
+
+    abs_n = abs(Decimal(str(n)))
+    amount = Decimal(str(n))
+    name, symbol, description = default_unit
+
+    for name_item, symbol_item, limit, desc_item in table:
+        if abs_n >= Decimal(str(limit)):
+            amount = Decimal(str(n)) / Decimal(str(limit))
+            name, symbol, description = name_item, symbol_item, desc_item
+            break
+
+    parts: List[str] = []
+    if "n" in mode: parts.append(name)
+    if "s" in mode: parts.append(symbol)
+    if "d" in mode: parts.append(description)
+    if "v" in mode: parts.append(f"({float(n)} {base_symbol})")
+    if "lower" in mode: parts = [p.lower() for p in parts]
+    if "upper" in mode: parts = [p.upper() for p in parts]
+    if "title" in mode: parts = [p.title() for p in parts]
+
+    suffix = " ".join(parts).strip()
+    return f"{amount:.2f}{f' {suffix}' if suffix else ''}"
+
+def format_capacity(n: Union[int, Any], mode: _MeasureTextMode = "s") -> str:
+    """Format a capacity expressed in litres."""
+    return _generic_formatter(n, _CAPACITY_TABLE, ("litre", "l", ""), "l", mode)
+
+def format_mass(n: Union[int, Any], mode: _MeasureTextMode = "s") -> str:
+    """Format a mass expressed in grams."""
+    return _generic_formatter(n, _MASS_TABLE, ("gram", "g", ""), "g", mode)
+
+def format_volume(n: Union[int, Any], mode: _MeasureTextMode = "s") -> str:
+    """Format a volume expressed in cubic metres."""
+    return _generic_formatter(n, _VOLUME_TABLE, ("metre cubic", "m³", ""), "m³", mode)
+
+__all__ = [
+    "format_capacity", "format_mass", "format_volume"
+]

games/__init__.py

@@ -0,0 +1,11 @@
+"""Game-specific formatting helpers.
+
+The public API currently provides :func:`format_money`, which formats large
+in-game currency values using compact suffixes such as ``K`` and ``M``.
+"""
+
+from .monetary import format_money
+
+__all__ = [
+    "format_money"
+]

games/_units.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import List, Tuple, Union
+from UnityManager._units import _TextMode
+
+_MoneyTextMode = _TextMode
+
+_MONEY_TABLE: List[Tuple[str, str, Union[int, float], str]] = [
+    ("quadrillion", "Q", 10 ** 15, ""),
+    ("trillion", "T", 10 ** 12, ""),
+    ("billion", "B", 10 ** 9, ""),
+    ("million", "M", 10 ** 6, ""),
+    ("thousand", "K", 10 ** 3, ""),
+    ("", "", 1, ""),
+]

games/monetary.py

@@ -0,0 +1,58 @@
+"""Formatting helpers for in-game monetary values."""
+from typing import Any, List, Literal, Union
+from decimal import Decimal
+
+from ._units import _MONEY_TABLE, _MoneyTextMode
+
+def format_money(n: Union[int, Any], mode: _MoneyTextMode = "s") -> str:
+    """Format an in-game currency amount with a compact suffix.
+
+    Args:
+        n: Numeric amount in the base currency (gold by default). Non-numeric
+            values are returned unchanged as text.
+        mode: Controls the text appended to the formatted number. ``"s"``
+            adds the suffix symbol, ``"n"`` adds its name, ``"d"`` adds the
+            description, and ``"v"`` shows the original amount as gold.
+            Case modifiers ``"upper"``, ``"lower"`` and ``"title"`` can be
+            combined with the other modes.
+
+    Returns:
+        A string containing the amount rounded to two decimal places and the
+        requested currency text.
+
+    Examples:
+        >>> format_money(1500)
+        '1.50 K'
+        >>> format_money(2_000_000, "n")
+        '2.00 million'
+        >>> format_money(1500, "nsupper")
+        '1.50 THOUSAND K'
+    """
+    if not isinstance(n, (int, float, Decimal)): return str(n)
+
+    abs_n = abs(Decimal(str(n)))
+    amount = Decimal(str(n))
+    name, symbol, description = "", "", ""
+    
+    for name_item, symbol_item, limit, desc_item in _MONEY_TABLE:
+        if abs_n >= Decimal(str(limit)):
+            amount = Decimal(str(n)) / Decimal(str(limit))
+            name, symbol, description = name_item, symbol_item, desc_item
+            break
+
+    parts: List[str] = []
+
+    if "n" in mode: parts.append(name)
+    if "s" in mode: parts.append(symbol)
+    if "d" in mode: parts.append(description)
+    if "v" in mode: parts.append(f"({n} gold)")
+    if "lower" in mode: parts = [p.lower() for p in parts]
+    if "upper" in mode: parts = [p.upper() for p in parts]
+    if "title" in mode: parts = [p.title() for p in parts]
+
+    suffix = " ".join(part for part in parts if part)
+    return f"{amount:.2f}{f' {suffix}' if suffix else ''}"
+
+__all__ = [
+    "format_money"
+]

unitymanager-0.0.1a1.dist-info/METADATA

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: UnityManager
+Version: 0.0.1a1
+Summary: Utilities for formatting common units.
+Project-URL: Homepage, https://github.com/PlayGames-2020/UnityManager
+Project-URL: Repository, https://github.com/PlayGames-2020/UnityManager.git
+Project-URL: Documentation, https://github.com/PlayGames-2020/UnityManager/blob/main/README.md
+Project-URL: Authors, https://github.com/PlayGames-2020
+Author-email: PlayGames-2020 <playgames16.01.2020@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 PlayGames-2020
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: bytes,formatting,games,length,mass,money,units,volume
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=8.4.2; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# UnityManager
+
+Utilities for formatting common units without runtime dependencies.
+
+> **Status:** alpha (`0.0.1-alpha`). The API is still subject to change.
+
+## Requirements
+
+- Python **3.9 or later**
+- No runtime dependencies
+
+## Installation
+
+### GitHub
+
+``` bash
+pip install git+https://github.com/PlayGames-2020/UnityManager.git
+```
+
+or
+
+``` bash
+pip install git+https://github.com/PlayGames-2020/UnityManager.git@master
+```
+
+### PyPI
+
+``` bash
+pip install UnityManager
+```
+
+To install the development dependencies:
+
+```bash
+pip install "unitymanager[dev]"
+```
+
+## Quick start
+
+```python
+from UnityManager import (
+    format_bytes,
+    format_capacity,
+    format_length,
+    format_mass,
+    format_volume,
+)
+from games import format_money
+
+print(format_bytes(1024))       # 1.00 KB
+print(format_length(1500))      # 1.50 km
+print(format_capacity(2.5))     # 2.50 l
+print(format_mass(2500))        # 2.50 kg
+print(format_volume(1))         # 1.00 m³
+print(format_money(1500))       # 1.50 K
+```
+
+Each formatter accepts a text mode. The default mode `"s"` displays the unit symbol. Use `"n"` for the unit name, combine modes such as `"ns"`, or add `"upper"`, `"lower"`, `"title"` and `"v"` as needed.
+
+## Games package
+
+The optional game-oriented API is available from the `games` package:
+
+```python
+from games import format_money
+
+format_money(999)                  # "999.00"
+format_money(1_500)                # "1.50 K"
+format_money(2_000_000)            # "2.00 M"
+format_money(1_500, "n")            # "1.50 thousand"
+format_money(1_500, "ns")           # "1.50 thousand K"
+format_money(1_500, "v")            # "1.50 (1500 gold)"
+format_money(1_500, "nsupper")      # "1.50 THOUSAND K"
+```
+
+### `format_money(value, mode="s")`
+
+Formats a numeric amount in the base game currency, assumed to be gold. Values
+are rounded to two decimal places and use the largest applicable suffix:
+
+| Range | Name | Symbol |
+| ---: | --- | :--- |
+| 1,000 | thousand | `K` |
+| 1,000,000 | million | `M` |
+| 1,000,000,000 | billion | `B` |
+| 1,000,000,000,000 | trillion | `T` |
+| 1,000,000,000,000,000 | quadrillion | `Q` |
+
+Supported mode components:
+
+- `s`: append the compact symbol.
+- `n`: append the full unit name.
+- `d`: append the unit description (reserved for future descriptions).
+- `v`: append the original value as gold.
+- `upper`, `lower`, `title`: change the case of the appended text.
+
+Modes can be combined, for example `"nsupper"`. Non-numeric values are returned
+as text instead of raising an exception.
+
+The formatter is intentionally currency-neutral in its arithmetic: it only
+compacts the amount. The displayed base-currency label is currently `gold` and
+can be extended in a future API version if games need coins, gems, credits or
+other currencies.
+
+## UnityManager API
+
+All public formatters return a string rounded to two decimal places. Numeric
+inputs use the base unit described below; non-numeric inputs are returned using
+`str(value)`.
+
+### `format_bytes(value, mode="s")`
+
+Formats binary quantities using powers of 1024. The base input is bytes and the
+available symbols include `B`, `KB`, `MB`, `GB`, `TB`, `PB`, `EB` and `ZB`.
+The mode `"byte"` adds the original value in bytes, while `"bit"` adds its
+corresponding bit value.
+
+```python
+format_bytes(1024)             # "1.00 KB"
+format_bytes(1024, "n")        # "1.00 kilobyte"
+format_bytes(2048, "sbyte")   # "2.00 KB (2048 bytes)"
+```
+
+### `format_length(value, mode="s")`
+
+Formats a value expressed in metres using metric units from millimetres to
+kilometres.
+
+```python
+format_length(1_500)            # "1.50 km"
+format_length(1, "n")           # "1.00 metre"
+format_length(1, "nv")          # "1.00 metre (1.0 m)"
+```
+
+### `format_capacity(value, mode="s")`
+
+Formats a value expressed in litres, from millilitres to kilolitres.
+
+```python
+format_capacity(2.5)            # "2.50 l"
+format_capacity(1_000, "n")     # "1.00 kilolitre"
+```
+
+### `format_mass(value, mode="s")`
+
+Formats a value expressed in grams, from milligrams to kilograms.
+
+```python
+format_mass(2_500)              # "2.50 kg"
+format_mass(1, "n")             # "1.00 gram"
+```
+
+### `format_volume(value, mode="s")`
+
+Formats a value expressed in cubic metres, from cubic millimetres to cubic
+kilometres.
+
+```python
+format_volume(1)                # "1.00 m³"
+format_volume(0.000001)         # "1.00 cm³"
+```
+
+### Text modes
+
+The general formatters support these mode components:
+
+- `s`: append the unit symbol (the default).
+- `n`: append the full unit name.
+- `d`: append the unit description, when available.
+- `v`: append the original value in the base unit.
+- `upper`, `lower`, `title`: change the case of the appended text.
+
+Modes can be combined as a string, for example `"nsupper"`.
+
+## Supported formatters
+
+- `format_bytes`: binary byte units (`B`, `KB`, `MB`, and so on).
+- `format_length`: metric lengths from millimetres to kilometres.
+- `format_capacity`: metric capacities from millilitres to kilolitres.
+- `format_mass`: metric masses from milligrams to kilograms.
+- `format_volume`: cubic metric units from cubic millimetres to cubic kilometres.
+- `games.format_money`: compact game currency values (`K`, `M`, `B`, `T`, `Q`).
+
+## Development and testing
+
+```bash
+git clone https://github.com/PlayGames-2020/UnityManager.git
+cd UnityManager
+pip install -e ".[dev]"
+python -m pytest
+```
+
+## License
+
+Distributed under the [MIT License](LICENSE).
+
+## Links
+
+- [Repository](https://github.com/PlayGames-2020/UnityManager)
+- [Documentation](https://github.com/PlayGames-2020/UnityManager/blob/main/README.md)

unitymanager-0.0.1a1.dist-info/RECORD

@@ -0,0 +1,12 @@
+UnityManager/__init__.py,sha256=yGRnZMu8ccizXL8TVSKvu0iFIs_KLnALSgo44XKZOGM,1175
+UnityManager/_units.py,sha256=3Bv4iPU7vnT8c5lvMxxhGwvdQBmeLDBqzJ6xbzqIhdg,1980
+UnityManager/bytes.py,sha256=oSGeFyrBcJ6M_5KmeOMuDDJke9xe80ScHaXG9GaxWG0,1850
+UnityManager/length.py,sha256=IMkX0DXop12Js6-GT3isbne7IPHLj5PVniP7jt1tAJo,1924
+UnityManager/measure.py,sha256=IYjF_wVCSNYWy1EORjzQfrVi8I3hn1ByEEQ6h5EZppQ,2098
+games/__init__.py,sha256=T_D3bbhYzGxXAF4EKoEoggXklKIhKBJcDWzIBoQprqU,269
+games/_units.py,sha256=VvnaXZKetTYqt5RO42s__MH9Du9uQCvApXcN-lc64a8,428
+games/monetary.py,sha256=GtRM3ZkoSSfKz13wZxs6xeIew4h8PId8W4NcgGHoLgw,2137
+unitymanager-0.0.1a1.dist-info/METADATA,sha256=iAvV2ogade5KqGHZEpEO7m0fC6dTulza2m6hQdFekjQ,8091
+unitymanager-0.0.1a1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+unitymanager-0.0.1a1.dist-info/licenses/LICENSE,sha256=KJecc8txDD4yvhnS_h5Hm9byqN6NgUFYiTpa0jd9eYA,1092
+unitymanager-0.0.1a1.dist-info/RECORD,,

unitymanager-0.0.1a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

unitymanager-0.0.1a1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PlayGames-2020
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.