UnityManager 0.0.1a1__tar.gz

unitymanager-0.0.1a1/.github/workflows/python-package.yml

@@ -0,0 +1,40 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python package
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install flake8 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        pytest

unitymanager-0.0.1a1/.gitignore

@@ -0,0 +1,224 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+.env-*
+.env*
+.venv-*
+.venv*
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+.docs/*

unitymanager-0.0.1a1/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.

unitymanager-0.0.1a1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,200 @@
+# 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/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-0.0.1a1/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-0.0.1a1/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-0.0.1a1/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-0.0.1a1/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"
+]

unitymanager-0.0.1a1/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"
+]

unitymanager-0.0.1a1/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, ""),
+]

unitymanager-0.0.1a1/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/pyproject.toml

@@ -0,0 +1,54 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "UnityManager"
+dynamic = ["version"]
+author = "PlayGames-2020"
+description = "Utilities for formatting common units."
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+    { name = "PlayGames-2020", email = "playgames16.01.2020@gmail.com" },
+]
+license = { file = "LICENSE" }
+keywords = ["units", "formatting", "bytes", "length", "mass", "volume", "games", "money"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.4.2"
+]
+
+[project.urls]
+Homepage = "https://github.com/PlayGames-2020/UnityManager"
+Repository = "https://github.com/PlayGames-2020/UnityManager.git"
+Documentation = "https://github.com/PlayGames-2020/UnityManager/blob/main/README.md"
+Authors = "https://github.com/PlayGames-2020"
+
+[tool.hatch.version]
+path = "UnityManager/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["UnityManager", "games"]
+exclude = [
+    "*.pyc"
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

unitymanager-0.0.1a1/tests/test_formatters.py

@@ -0,0 +1,25 @@
+from UnityManager import (
+    format_bytes,
+    format_capacity,
+    format_length,
+    format_mass,
+    format_volume,
+)
+
+
+def test_public_api_formats_units():
+    assert format_bytes(1024) == "1.00 KB"
+    assert format_length(1000) == "1.00 km"
+    assert format_capacity(1000) == "1.00 kl"
+    assert format_mass(1000) == "1.00 kg"
+    assert format_volume(1) == "1.00 m³"
+
+
+def test_formatters_support_names_and_case_modes():
+    assert format_length(1, "n") == "1.00 metre"
+    assert format_mass(1, "nupper") == "1.00 GRAM"
+
+
+def test_non_numeric_values_are_returned_as_text():
+    assert format_bytes("unknown") == "unknown"
+    assert format_length(None) == "None"

unitymanager-0.0.1a1/tests/test_money.py

@@ -0,0 +1,14 @@
+from games import format_money
+
+
+def test_money_uses_compact_game_currency_symbols():
+    assert format_money(999) == "999.00"
+    assert format_money(1_500) == "1.50 K"
+    assert format_money(2_000_000) == "2.00 M"
+    assert format_money(3_000_000_000) == "3.00 B"
+
+
+def test_money_supports_names_and_original_value_mode():
+    assert format_money(1_500, "n") == "1.50 thousand"
+    assert format_money(1_500, "v") == "1.50 (1500 gold)"
+    assert format_money(1_500, "nsupper") == "1.50 THOUSAND K"