lazy-static 1.0.0__tar.gz

lazy_static-1.0.0/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/PKG-INFO

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

@@ -0,0 +1,127 @@
+[![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/lazy_static.egg-info/PKG-INFO

@@ -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/lazy_static.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+lazy_static.py
+setup.cfg
+setup.py
+lazy_static.egg-info/PKG-INFO
+lazy_static.egg-info/SOURCES.txt
+lazy_static.egg-info/dependency_links.txt
+lazy_static.egg-info/top_level.txt

lazy_static-1.0.0/lazy_static.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lazy_static-1.0.0/lazy_static.egg-info/top_level.txt

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

lazy_static-1.0.0/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']

lazy_static-1.0.0/setup.cfg

@@ -0,0 +1,42 @@
+[metadata]
+name = lazy_static
+version = 1.0.0
+description = lazy module constants -- think lazy imports but for assignments
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/asottile/lazy-static
+author = Anthony Sottile
+author_email = asottile@umich.edu
+license = MIT
+license_files = LICENSE
+classifiers = 
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
+	Programming Language :: Python :: Implementation :: CPython
+	Programming Language :: Python :: Implementation :: PyPy
+
+[options]
+py_modules = lazy_static
+python_requires = >=3.15
+
+[coverage:run]
+plugins = covdefaults
+
+[mypy]
+check_untyped_defs = true
+disallow_any_generics = true
+disallow_incomplete_defs = true
+disallow_untyped_defs = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+
+[mypy-testing.*]
+disallow_untyped_defs = false
+
+[mypy-tests.*]
+disallow_untyped_defs = false
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

lazy_static-1.0.0/setup.py

@@ -0,0 +1,2 @@
+from setuptools import setup
+setup()