lazy-static 1.0.0__py3-none-any.whl

lazy_static-1.0.0.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: lazy_static
+Version: 1.0.0
+Summary: lazy module constants -- think lazy imports but for assignments
+Home-page: https://github.com/asottile/lazy-static
+Author: Anthony Sottile
+Author-email: asottile@umich.edu
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.15
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+[![build status](https://github.com/asottile/lazy-static/actions/workflows/main.yml/badge.svg)](https://github.com/asottile/lazy-static/actions/workflows/main.yml)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/asottile/lazy-static/main.svg)](https://results.pre-commit.ci/latest/github/asottile/lazy-static/main)
+
+lazy-static
+===========
+
+lazy module constants -- think lazy imports but for assignments
+
+roughly named after the (deprecated) rust [crate lazy_static]
+
+[crate lazy_static]: https://docs.rs/lazy_static/latest/lazy_static/
+
+## installation
+
+```bash
+pip install lazy-static
+```
+
+## why ?
+
+python 3.15 adds [lazy imports] which are neat but are a little too easy to
+accidentally make eager.
+
+[lazy imports]: https://peps.python.org/pep-0810/
+
+take this small example for a little wrapper around `pyyaml`:
+
+```python
+import functools
+
+lazy import yaml
+
+loads = functools.partial(yaml.load, Loader=yaml.CSafeLoader)
+```
+
+did you catch the bug?  yeah that import isn't lazy due to accessing attributes!
+
+it would be great if I could do:
+
+```
+lazy loads = functools.partial(yaml.load, Loader=yaml.CSafeLoader)
+```
+
+but there's no such thing...[^1] unless...
+
+[^1]: yes yes you can do stuff with `@functools.cache` but that adds an ugly function call!
+
+## Usage
+
+`lazy-static` adds a single api: `@lazy_static.lazy`
+
+taking a simple example:
+
+```python
+import argparse
+from lazy_static import lazy
+
+@lazy
+def computed_once() -> int:
+    print('computing!')
+    return 5 * 5 * 5
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.parse_args()  # just for `--help`
+    print(f'got {computed_once}')
+    return 0
+
+if __name__ == '__main__':
+    raise SystemExit(main())
+```
+
+the lazy attribute is deferred when not accessed:
+
+```console
+$ python3 t.py --help
+usage: t.py [-h]
+
+options:
+  -h, --help  show this help message and exit
+```
+
+but acts like a normal variable otherwise!
+
+```console
+$ python3 t.py
+computing!
+got 125
+```
+
+it even works with static typing!
+
+```diff
+$ diff -u t.py.bak t.py
+--- t.py.bak    2026-07-24 17:47:14.278681851 -0400
++++ t.py    2026-07-24 17:47:22.759961815 -0400
+@@ -10,6 +10,7 @@
+     parser = argparse.ArgumentParser()
+     parser.parse_args()  # just for `--help`
+     print(f'got {computed_once}')
++    reveal_type(computed_once)
+     return 0
+
+ if __name__ == '__main__':
+```
+
+```console
+$ mypy t.py
+t.py:13: note: Revealed type is "int"
+Success: no issues found in 1 source file
+```
+___
+
+if we take the earlier example we can define our `loads` partial lazily while
+preserving the `lazy` import!
+
+
+```python
+import functools
+
+from lazy_static import lazy
+lazy import yaml
+
+@lazy
+def loads():
+    return functools.partial(yaml.loads, Loader=yaml.CSafeLoader)
+```

lazy_static-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+lazy_static.py,sha256=J4HRY0h1PsE0I3-sjcHsL2zc_9U_c11O1BBsY_WDIUM,1225
+lazy_static-1.0.0.dist-info/licenses/LICENSE,sha256=8VC67N75H-PlrFgJkcqutXaQpE-gNWIH4dwPt4OmyRc,1059
+lazy_static-1.0.0.dist-info/METADATA,sha256=3Y5HnTiM4BaiM8YWObmBJD9Kf3TxQg3JplTzQpXujLo,3350
+lazy_static-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lazy_static-1.0.0.dist-info/top_level.txt,sha256=61kD7OSa4FU45IrnzGDt8zpYC22m8fXf2blhvEarurk,12
+lazy_static-1.0.0.dist-info/RECORD,,

lazy_static-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lazy_static-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2026 Anthony Sottile
+
+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.

lazy_static-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lazy_static

lazy_static.py

@@ -0,0 +1,47 @@
+import functools
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import sys
+import types
+from collections.abc import Callable
+
+
+class _LazyStaticFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    def __init__(self) -> None:
+        self._funcs: dict[str, Callable[[], object]] = {}
+
+    def find_spec(
+            self,
+            fullname: str,
+            path: object,
+            target: object = None,
+    ) -> importlib.machinery.ModuleSpec | None:
+        if fullname in self._funcs:
+            return importlib.util.spec_from_loader(fullname, self)
+        else:
+            return None
+
+    def create_module(self, spec: object) -> None:
+        return None
+
+    def exec_module(self, mod: types.ModuleType) -> None:
+        mod.V = self._funcs[mod.__name__]()  # type: ignore[attr-defined]
+
+
+@functools.cache
+def _insert_finder() -> _LazyStaticFinder:
+    finder = _LazyStaticFinder()
+    sys.meta_path.append(finder)
+    return finder
+
+
+def lazy[T](f: Callable[[], T]) -> T:
+    name = f'{__name__}___{f.__module__}___{f.__name__}'.replace('.', '__')
+
+    g: dict[str, T] = {}
+    exec(f'lazy from {name} import V', g)
+
+    _insert_finder()._funcs[name] = f
+
+    return g['V']