hf-mem 0.2.2__py3-none-any.whl

hf_mem/cli.py

@@ -0,0 +1,231 @@
+import argparse
+import asyncio
+import json
+import os
+import struct
+from dataclasses import asdict
+from functools import reduce
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from hf_mem.metadata import parse_safetensors_metadata
+from hf_mem.print import print_report
+
+# NOTE: Defines the bytes that will be fetched per safetensors file, but the metadata
+# can indeed be larger than that
+MAX_METADATA_SIZE = 100_000
+REQUEST_TIMEOUT = float(os.getenv("REQUEST_TIMEOUT", 10.0))
+MAX_CONCURRENCY = int(os.getenv("MAX_WORKERS", min(32, (os.cpu_count() or 1) + 4)))
+
+
+# NOTE: Return type-hint set to `Any`, but it will only be a JSON-compatible object
+async def get_json_file(client: httpx.AsyncClient, url: str, headers: Optional[Dict[str, str]] = None) -> Any:
+    response = await client.get(url, headers=headers, timeout=REQUEST_TIMEOUT)
+    response.raise_for_status()
+    return response.json()
+
+
+async def fetch_safetensors_metadata(
+    client: httpx.AsyncClient, url: str, headers: Optional[Dict[str, str]] = None
+) -> Dict[str, Any]:
+    headers = {"Range": f"bytes=0-{MAX_METADATA_SIZE}", **(headers or {})}
+    response = await client.get(url, headers=headers, timeout=REQUEST_TIMEOUT)
+    response.raise_for_status()
+
+    metadata = response.read()
+    # NOTE: Parse the first 8 bytes as a little-endian uint64 (size of the metadata)
+    metadata_size = struct.unpack("<Q", metadata[:8])[0]
+
+    if metadata_size < MAX_METADATA_SIZE:
+        metadata = metadata[8 : metadata_size + 8]
+        return json.loads(metadata)
+
+    # NOTE: Given that by default we just fetch the first 100_000 bytes, if the content is larger
+    # then we simply fetch the remainder again
+    metadata = metadata[8 : MAX_METADATA_SIZE + 8]
+    headers["Range"] = f"bytes={MAX_METADATA_SIZE + 1}-{metadata_size + 7}"
+
+    response = await client.get(url, headers=headers, timeout=REQUEST_TIMEOUT)
+    response.raise_for_status()
+
+    metadata += response.read()
+    return json.loads(metadata)
+
+
+async def run(
+    model_id: str,
+    revision: str,
+    json_output: bool = False,
+    ignore_table_width: bool = False,
+) -> Dict[str, Any] | None:
+    headers = {}
+    # NOTE: Read from `HF_TOKEN` if provided, then fallback to reading from `$HF_HOME/token`
+    if token := os.getenv("HF_TOKEN"):
+        headers["Authorization"] = f"Bearer {token}"
+    elif "Authorization" not in headers:
+        path = os.getenv("HF_HOME", ".cache/huggingface")
+        filename = (
+            os.path.join(os.path.expanduser("~"), path, "token")
+            if not os.path.isabs(path)
+            else os.path.join(path, "token")
+        )
+
+        if os.path.exists(filename):
+            with open(filename, "r", encoding="utf-8") as f:
+                headers["Authorization"] = f"Bearer {f.read().strip()}"
+
+    client = httpx.AsyncClient(
+        limits=httpx.Limits(
+            max_keepalive_connections=MAX_CONCURRENCY,
+            max_connections=MAX_CONCURRENCY,
+        ),
+        timeout=httpx.Timeout(REQUEST_TIMEOUT),
+        http2=True,
+        follow_redirects=True,
+    )
+
+    # TODO: `recursive=true` shouldn't really be required unless it's a Diffusers
+    # models... I don't think this adds extra latency anyway
+    url = f"https://huggingface.co/api/models/{model_id}/tree/{revision}?recursive=true"
+    files = await get_json_file(client=client, url=url, headers=headers)
+    file_paths = [f["path"] for f in files if f.get("path") and f.get("type") == "file"]
+
+    if "model.safetensors" in file_paths:
+        url = f"https://huggingface.co/{model_id}/resolve/{revision}/model.safetensors"
+        raw_metadata = await fetch_safetensors_metadata(client=client, url=url, headers=headers)
+
+        # NOTE: Given that at the moment for Sentence Transformers only the Transformers module is considered, we
+        # set the default component name to `0_Transformer` as defined in modules.json
+        if "config_sentence_transformers.json" in file_paths:
+            raw_metadata = {"0_Transformer": raw_metadata}
+        else:
+            # NOTE: If the model is a transformers model, then we simply set the component name to `Transformer`, to
+            # make sure that we provide the expected input to the `parse_safetensors_metadata`
+            raw_metadata = {"Transformer": raw_metadata}
+
+        metadata = parse_safetensors_metadata(raw_metadata=raw_metadata)
+    elif "model.safetensors.index.json" in file_paths:
+        # TODO: We could eventually skip this request in favour of a greedy approach on trying to pull all the
+        # files following the formatting `model-00000-of-00000.safetensors`
+        url = f"https://huggingface.co/{model_id}/resolve/{revision}/model.safetensors.index.json"
+        files_index = await get_json_file(client=client, url=url, headers=headers)
+
+        urls = {
+            f"https://huggingface.co/{model_id}/resolve/{revision}/{f}"
+            for f in set(files_index["weight_map"].values())
+        }
+
+        semaphore = asyncio.Semaphore(MAX_CONCURRENCY)
+
+        async def fetch_with_semaphore(url: str) -> Dict[str, Any]:
+            async with semaphore:
+                return await fetch_safetensors_metadata(client=client, url=url, headers=headers)
+
+        tasks = [asyncio.create_task(fetch_with_semaphore(url)) for url in urls]
+        metadata_list: List[Dict[str, Any]] = await asyncio.gather(*tasks, return_exceptions=False)
+
+        raw_metadata = reduce(lambda acc, metadata: acc | metadata, metadata_list, {})
+
+        # NOTE: Given that at the moment for Sentence Transformers only the Transformers module is considered, we
+        # set the default component name to `0_Transformer` as defined in modules.json
+        if "config_sentence_transformers.json" in file_paths:
+            raw_metadata = {"0_Transformer": raw_metadata}
+        else:
+            # NOTE: If the model is a transformers model, then we simply set the component name to `Transformer`, to
+            # make sure that we provide the expected input to the `parse_safetensors_metadata`
+            raw_metadata = {"Transformer": raw_metadata}
+
+        metadata = parse_safetensors_metadata(raw_metadata=raw_metadata)
+    elif "model_index.json" in file_paths:
+        url = f"https://huggingface.co/{model_id}/resolve/{revision}/model_index.json"
+        files_index = await get_json_file(client=client, url=url, headers=headers)
+        paths = {k for k, _ in files_index.items() if not k.startswith("_")}
+
+        path_urls: Dict[str, List[str]] = {}
+        for path in paths:
+            if f"{path}/diffusion_pytorch_model.safetensors" in file_paths:
+                path_urls[path] = [
+                    f"https://huggingface.co/{model_id}/resolve/{revision}/{path}/diffusion_pytorch_model.safetensors"
+                ]
+            elif f"{path}/model.safetensors" in file_paths:
+                path_urls[path] = [
+                    f"https://huggingface.co/{model_id}/resolve/{revision}/{path}/model.safetensors"
+                ]
+            elif f"{path}/diffusion_pytorch_model.safetensors.index.json" in file_paths:
+                url = f"https://huggingface.co/{model_id}/resolve/{revision}/{path}/diffusion_pytorch_model.safetensors.index.json"
+                files_index = await get_json_file(client=client, url=url, headers=headers)
+                path_urls[path] = [
+                    f"https://huggingface.co/{model_id}/resolve/{revision}/{path}/{f}"
+                    for f in set(files_index["weight_map"].values())
+                ]
+            elif f"{path}/model.safetensors.index.json" in file_paths:
+                url = (
+                    f"https://huggingface.co/{model_id}/resolve/{revision}/{path}/model.safetensors.index.json"
+                )
+                files_index = await get_json_file(client=client, url=url, headers=headers)
+                path_urls[path] = [
+                    f"https://huggingface.co/{model_id}/resolve/{revision}/{path}/{f}"
+                    for f in set(files_index["weight_map"].values())
+                ]
+
+        semaphore = asyncio.Semaphore(MAX_CONCURRENCY)
+
+        async def fetch_with_semaphore(url: str) -> Dict[str, Any]:
+            async with semaphore:
+                return await fetch_safetensors_metadata(client=client, url=url, headers=headers)
+
+        raw_metadata = {}
+        for path, urls in path_urls.items():
+            tasks = [asyncio.create_task(fetch_with_semaphore(url)) for url in urls]
+            metadata_list: List[Dict[str, Any]] = await asyncio.gather(*tasks, return_exceptions=False)
+            raw_metadata[path] = reduce(lambda acc, metadata: acc | metadata, metadata_list, {})
+
+        metadata = parse_safetensors_metadata(raw_metadata=raw_metadata)
+    else:
+        raise RuntimeError(
+            "NONE OF `model.safetensors`, `model.safetensors.index.json`, `model_index.json` HAS BEEN FOUND"
+        )
+
+    if json_output:
+        out = {"model_id": model_id, "revision": revision, **asdict(metadata)}
+        print(json.dumps(out))
+    else:
+        print_report(
+            model_id=model_id,
+            revision=revision,
+            metadata=metadata,
+            ignore_table_width=ignore_table_width,
+        )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-id", required=True, help="Model ID on the Hugging Face Hub")
+    parser.add_argument(
+        "--revision",
+        default="main",
+        help="Model revision on the Hugging Face Hub",
+    )
+    parser.add_argument(
+        "--json-output",
+        action="store_true",
+        help="Whether to provide the output as a JSON instead of printed as table.",
+    )
+    parser.add_argument(
+        "--ignore-table-width",
+        action="store_true",
+        help="Whether to ignore the maximum recommended table width, in case the `--model-id` and/or `--revision` cause a row overflow when printing those.",
+    )
+
+    args = parser.parse_args()
+
+    asyncio.run(
+        run(
+            model_id=args.model_id,
+            revision=args.revision,
+            # NOTE: Below are the arguments that affect the output format
+            json_output=args.json_output,
+            ignore_table_width=args.ignore_table_width,
+        )
+    )

hf_mem/metadata.py

@@ -0,0 +1,61 @@
+import math
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from hf_mem.types import SafetensorsDtypes, get_safetensors_dtype_bytes
+
+
+@dataclass
+class DtypeMetadata:
+    param_count: int
+    bytes_count: int
+
+
+@dataclass
+class ComponentMetadata:
+    dtypes: Dict[SafetensorsDtypes, DtypeMetadata]
+    param_count: int
+    bytes_count: int
+
+
+@dataclass
+class SafetensorsMetadata:
+    components: Dict[str, ComponentMetadata]
+    param_count: int
+    bytes_count: int
+
+
+def parse_safetensors_metadata(
+    raw_metadata: Dict[str, Dict[str, Any]],
+) -> SafetensorsMetadata:
+    components = {}
+    total_param_count, total_bytes_count = 0, 0
+
+    for name, metadata in raw_metadata.items():
+        component = ComponentMetadata(dtypes={}, param_count=0, bytes_count=0)
+        for key, value in metadata.items():
+            if key in {"__metadata__"}:
+                continue
+
+            dtype = value["dtype"]
+            if dtype not in component.dtypes:
+                component.dtypes[dtype] = DtypeMetadata(param_count=0, bytes_count=0)
+
+            dtype_bytes = get_safetensors_dtype_bytes(dtype)
+            current_shape = math.prod(value["shape"])
+            current_shape_bytes = current_shape * dtype_bytes
+
+            component.dtypes[dtype].param_count += current_shape
+            component.dtypes[dtype].bytes_count += current_shape_bytes
+            component.param_count += current_shape
+            component.bytes_count += current_shape_bytes
+            total_param_count += current_shape
+            total_bytes_count += current_shape_bytes
+
+        components[name] = component
+
+    return SafetensorsMetadata(
+        components=components,
+        param_count=total_param_count,
+        bytes_count=total_bytes_count,
+    )

hf_mem/print.py

@@ -0,0 +1,196 @@
+import warnings
+from typing import Literal, Optional
+
+from hf_mem.metadata import SafetensorsMetadata
+
+MIN_NAME_LEN = 5
+MAX_NAME_LEN = 14
+MIN_DATA_LEN = 20
+MAX_DATA_LEN = 64
+BORDERS_AND_PADDING = 7
+
+BOX = {
+    "tl": "┌",
+    "tr": "┐",
+    "bl": "└",
+    "br": "┘",
+    "ht": "─",
+    "vt": "│",
+    "tsep": "┬",
+    "bsep": "┴",
+    "lm": "├",
+    "rm": "┤",
+    "mm": "┼",
+}
+
+
+def _print_with_color(content: str) -> None:
+    print(f"\x1b[38;2;244;183;63m{content}\x1b[0m")
+
+
+def _print_header(current_len: int) -> None:
+    length = current_len + MAX_NAME_LEN + BORDERS_AND_PADDING
+    top = BOX["tl"] + (BOX["tsep"] * (length - 2)) + BOX["tr"]
+    _print_with_color(top)
+
+    bottom = BOX["lm"] + (BOX["bsep"] * (length - 2)) + BOX["rm"]
+    _print_with_color(bottom)
+
+
+def _print_centered(text: str, current_len: int) -> None:
+    max_len = current_len + MAX_NAME_LEN - BORDERS_AND_PADDING
+    total_width = max_len + 12
+    text_len = len(text)
+    pad_left = (total_width - text_len) // 2
+    pad_right = total_width - text_len - pad_left
+    _print_with_color(f"{BOX['vt']}{' ' * pad_left}{text}{' ' * pad_right}{BOX['vt']}")
+
+
+def _print_divider(
+    current_len: int,
+    side: Optional[Literal["top", "top-continue", "bottom", "bottom-continue"]] = None,
+) -> None:
+    match side:
+        case "top":
+            left, mid, right = BOX["lm"], BOX["tsep"], BOX["rm"]
+        case "top-continue":
+            left, mid, right = BOX["lm"], BOX["bsep"], BOX["rm"]
+        case "bottom":
+            left, mid, right = BOX["bl"], BOX["bsep"], BOX["br"]
+        case "bottom-continue":
+            left, mid, right = BOX["lm"], BOX["bsep"], BOX["rm"]
+        case _:
+            left, mid, right = BOX["lm"], BOX["mm"], BOX["rm"]
+
+    name_col_inner = MAX_NAME_LEN + 2
+    data_col_inner = current_len + 1
+
+    line = left
+    line += BOX["ht"] * name_col_inner
+    line += mid
+    line += BOX["ht"] * data_col_inner
+    line += right
+    _print_with_color(line)
+
+
+def _format_name(name: str) -> str:
+    if len(name) < MIN_NAME_LEN:
+        return f"{name:<{MIN_NAME_LEN}}"
+    if len(name) > MAX_NAME_LEN:
+        return name[: MAX_NAME_LEN - 3] + "..."
+    return f"{name:<{MAX_NAME_LEN}}"
+
+
+def _print_row(name: str, text: str, current_len: int) -> None:
+    name_fmt = _format_name(name)
+    data_fmt = f"{str(text):<{current_len}}"
+    _print_with_color(f"{BOX['vt']} {name_fmt} {BOX['vt']} {data_fmt} {BOX['vt']}")
+
+
+def _make_bar(used: float, total: float, width: int) -> str:
+    if total <= 0:
+        return "░" * width
+    frac = min(max(used / total, 0.0), 1.0)
+    filled = int(round(frac * width))
+    filled = max(0, min(width, filled))
+    return "█" * filled + "░" * (width - filled)
+
+
+def _format_short_number(n: float) -> str:
+    n = float(n)
+    for unit in ("", "K", "M", "B", "T"):
+        if abs(n) < 1000.0:
+            return f"{int(n)}" if unit == "" else f"{n:.2f}{unit}"
+        n /= 1000.0
+    return f"{n:.2f}P"
+
+
+def _bytes_to_gb(nbytes: int) -> float:
+    return nbytes / (1024**3)
+
+
+def print_report(
+    model_id: str,
+    revision: str,
+    metadata: SafetensorsMetadata,
+    ignore_table_width: bool = False,
+) -> None:
+    rows = [
+        "INFERENCE MEMORY ESTIMATE FOR",
+        f"https://hf.co/{model_id} @ {revision}",
+        "TOTAL MEMORY",
+        "REQUIREMENTS",
+    ]
+
+    for name, nested_metadata in metadata.components.items():
+        if len(metadata.components) > 1:
+            rows.append(name)
+
+        for dtype, dtype_metadata in nested_metadata.dtypes.items():
+            rows.append(f"{dtype} {dtype_metadata.param_count} {dtype_metadata.bytes_count}")
+
+    max_len = max(len(str(r)) for r in rows)
+
+    if max_len > MAX_DATA_LEN and ignore_table_width is False:
+        warnings.warn(
+            f"Given that the provided `--model-id {model_id}` (with `--revision {revision}`) is longer than {MAX_DATA_LEN} characters, the table width will be expanded to fit the provided values within their row, but it might lead to unexpected table views. If you'd like to ignore the limit, then provide the `--ignore-table-width` flag to ignore the {MAX_DATA_LEN} width limit, to simply accommodate to whatever the longest text length is."
+        )
+
+    current_len = min(max_len, MAX_DATA_LEN) if ignore_table_width is False else max_len
+
+    _print_header(current_len)
+    _print_centered("INFERENCE MEMORY ESTIMATE FOR", current_len)
+    _print_centered(f"https://hf.co/{model_id} @ {revision}", current_len)
+    _print_divider(current_len + 1, "top")
+
+    total_text = (
+        f"{_bytes_to_gb(metadata.bytes_count):.2f} GB ({_format_short_number(metadata.param_count)} params)"
+    )
+    _print_row("TOTAL MEMORY", total_text, current_len)
+
+    total_bar = _make_bar(metadata.bytes_count, metadata.bytes_count, current_len)
+    _print_row("REQUIREMENTS", total_bar, current_len)
+
+    for key, value in metadata.components.items():
+        if len(metadata.components) > 1:
+            _print_divider(current_len + 1, "top-continue")
+            _print_centered(
+                f"{key.upper()} ({_bytes_to_gb(value.bytes_count):.2f} GB)",
+                current_len,
+            )
+
+            _print_divider(current_len + 1, "top")
+        else:
+            _print_divider(current_len + 1)
+
+        max_length = max(
+            [
+                len(f"{_format_short_number(dtype_metadata.param_count)} PARAMS")
+                for _, dtype_metadata in value.dtypes.items()
+            ]
+        )
+        for idx, (dtype, dtype_metadata) in enumerate(value.dtypes.items()):
+            gb_text = (
+                f"{_bytes_to_gb(dtype_metadata.bytes_count):.2f} / {_bytes_to_gb(metadata.bytes_count):.2f} GB"
+            )
+            _print_row(
+                dtype.upper() + " " * (max_length - len(dtype)),
+                gb_text,
+                current_len,
+            )
+
+            bar = _make_bar(
+                _bytes_to_gb(dtype_metadata.bytes_count),
+                _bytes_to_gb(metadata.bytes_count),
+                current_len,
+            )
+            _print_row(
+                f"{_format_short_number(dtype_metadata.param_count)} PARAMS",
+                bar,
+                current_len,
+            )
+
+            if idx < len(value.dtypes) - 1:
+                _print_divider(current_len + 1)
+
+    _print_divider(current_len + 1, "bottom")

hf_mem/types.py

@@ -0,0 +1,32 @@
+from typing import Literal
+
+SafetensorsDtypes = Literal[
+    "F64",
+    "I64",
+    "U64",
+    "F32",
+    "I32",
+    "U32",
+    "F16",
+    "BF16",
+    "I16",
+    "U16",
+    "F8_E5M2",
+    "F8_E4M3",
+    "I8",
+    "U8",
+]
+
+
+def get_safetensors_dtype_bytes(dtype: str) -> int:
+    match dtype:
+        case "F64" | "I64" | "U64":
+            return 8
+        case "F32" | "I32" | "U32":
+            return 4
+        case "F16" | "BF16" | "I16" | "U16":
+            return 2
+        case "F8_E5M2" | "F8_E4M3" | "I8" | "U8":
+            return 1
+        case _:
+            raise RuntimeError(f"DTYPE={dtype} NOT HANDLED")

hf_mem-0.2.2.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: hf-mem
+Version: 0.2.2
+Summary: A CLI to estimate inference memory requirements for Hugging Face models, written in Python
+Author: Alvaro Bartolome
+Author-email: Alvaro Bartolome <36760800+alvarobartt@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: httpx[http2]>=0.28.1
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<img src="https://github.com/user-attachments/assets/509a8244-8a91-4051-b337-41b7b2fe0e2f" />
+
+---
+
+`hf-mem` is an experimental CLI to estimate inference memory requirements for Hugging Face models, written in Python. `hf-mem` is lightweight, only depends on `httpx`. It's recommended to run with [`uv`](https://github.com/astral-sh/uv) for a better experience.
+
+`hf-mem` lets you estimate the inference requirements to run any model from the Hugging Face Hub, including Transformers, Diffusers and Sentence Transformers models, as well as any model that contains [Safetensors](https://github.com/huggingface/safetensors) compatible weights.
+
+Read more information about `hf-mem` in [this short-form post](https://alvarobartt.com/hf-mem).
+
+## Usage
+
+```bash
+uvx hf-mem --model-id MiniMaxAI/MiniMax-M2
+```
+
+<img src="https://github.com/user-attachments/assets/530f8b14-a415-4fd6-9054-bcd81cafae09" />
+
+```bash
+uvx hf-mem --model-id Qwen/Qwen-Image
+```
+
+<img src="https://github.com/user-attachments/assets/cd4234ec-bdcc-4db4-8b01-0ac9b5cd390c" />
+
+## References
+
+- [Safetensors Metadata parsing](https://huggingface.co/docs/safetensors/en/metadata_parsing)
+- [usgraphics - TR-100 Machine Report](https://github.com/usgraphics/usgc-machine-report)

hf_mem-0.2.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+hf_mem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hf_mem/cli.py,sha256=SV6HvN1emkm_fWoEq_V14RNXUwer0Y5wTmVqOtsc5Ns,10233
+hf_mem/metadata.py,sha256=yWamwZg-zc7luhvZx8tqIe8cjA9o44qrboi8DZ83lIg,1769
+hf_mem/print.py,sha256=TJvDFPzhYVDpjgyw4yxU91BuEb9k6x_5WdkIDW9p1_8,6365
+hf_mem/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hf_mem/types.py,sha256=GLs8S3lIP9JkwdoDc8cwHn3IlBOAIbH-NihtzDsmzyI,619
+hf_mem-0.2.2.dist-info/licenses/LICENSE,sha256=TUO4cSlmwlYsHZfepsmo1zLoYhmT0RImXoRihVYNHhw,1060
+hf_mem-0.2.2.dist-info/WHEEL,sha256=KSLUh82mDPEPk0Bx0ScXlWL64bc8KmzIPNcpQZFV-6E,79
+hf_mem-0.2.2.dist-info/entry_points.txt,sha256=p6o2afl5zELLNtkKwQxfLdOpal2nRlcshDZSfV02pOY,44
+hf_mem-0.2.2.dist-info/METADATA,sha256=AF2JzRasS5OPzualhbHkPvxmeHo6w7AKN6l0bOFpYQc,1647
+hf_mem-0.2.2.dist-info/RECORD,,

hf_mem-0.2.2.dist-info/WHEEL

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

hf_mem-0.2.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+hf-mem = hf_mem.cli:main
+

hf_mem-0.2.2.dist-info/licenses/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2025 Alvaro Bartolome
+
+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.