2020-06-13 00:36:45 +02:00
<!DOCTYPE html>
2020-06-14 21:48:02 +02:00
2020-10-15 01:31:30 +02:00
< html >
2020-06-15 21:52:33 +02:00
< head >
< meta charset = "utf-8" / >
2020-10-15 01:31:30 +02:00
< meta name = "viewport" content = "width=device-width, initial-scale=1.0" / >
2020-06-15 21:52:33 +02:00
< title > django.utils.functional — Evennia 1.0-dev documentation< / title >
< link rel = "stylesheet" href = "../../../_static/nature.css" type = "text/css" / >
< link rel = "stylesheet" href = "../../../_static/pygments.css" type = "text/css" / >
< script id = "documentation_options" data-url_root = "../../../" src = "../../../_static/documentation_options.js" > < / script >
< script src = "../../../_static/jquery.js" > < / script >
< script src = "../../../_static/underscore.js" > < / script >
< script src = "../../../_static/doctools.js" > < / script >
< script src = "../../../_static/language_data.js" > < / script >
< link rel = "shortcut icon" href = "../../../_static/favicon.ico" / >
< link rel = "index" title = "Index" href = "../../../genindex.html" / >
< link rel = "search" title = "Search" href = "../../../search.html" / >
< / head > < body >
< div class = "related" role = "navigation" aria-label = "related navigation" >
< h3 > Navigation< / h3 >
< ul >
< li class = "right" style = "margin-right: 10px" >
< a href = "../../../genindex.html" title = "General Index"
accesskey="I">index< / a > < / li >
< li class = "right" >
< a href = "../../../py-modindex.html" title = "Python Module Index"
>modules< / a > |< / li >
2020-07-14 00:21:00 +02:00
< li class = "nav-item nav-item-0" > < a href = "../../../index.html" > Evennia 1.0-dev< / a > » < / li >
2020-10-15 01:31:30 +02:00
< li class = "nav-item nav-item-1" > < a href = "../../index.html" accesskey = "U" > Module code< / a > » < / li >
< li class = "nav-item nav-item-this" > < a href = "" > django.utils.functional< / a > < / li >
2020-06-15 21:52:33 +02:00
< / ul >
2021-06-23 18:58:26 +02:00
< div class = "develop" > develop branch< / div >
2020-06-15 21:52:33 +02:00
< / div >
< div class = "document" >
2022-10-23 09:04:07 +00:00
2020-06-15 21:52:33 +02:00
< div class = "documentwrapper" >
2022-10-23 09:04:07 +00:00
< div class = "sphinxsidebar" role = "navigation" aria-label = "main navigation" >
< div class = "sphinxsidebarwrapper" >
< p class = "logo" > < a href = "../../../index.html" >
< img class = "logo" src = "../../../_static/evennia_logo.png" alt = "Logo" / >
< / a > < / p >
< div id = "searchbox" style = "display: none" role = "search" >
< h3 id = "searchlabel" > Quick search< / h3 >
< div class = "searchformwrapper" >
< form class = "search" action = "../../../search.html" method = "get" >
< input type = "text" name = "q" aria-labelledby = "searchlabel" / >
< input type = "submit" value = "Go" / >
< / form >
< / div >
< / div >
< script > $ ( '#searchbox' ) . show ( 0 ) ; < / script > < h3 > Links< / h3 >
< ul >
< li > < a href = "https://www.evennia.com" > Home page< / a > < / li >
< li > < a href = "https://github.com/evennia/evennia" > Evennia Github< / a > < / li >
< li > < a href = "http://games.evennia.com" > Game Index< / a > < / li >
< li >
< a href = "https://discord.gg/AJJpcRUhtF" > Discord< / a > -
< a href = "https://github.com/evennia/evennia/discussions" > Discussions< / a > -
< a href = "https://evennia.blogspot.com/" > Blog< / a >
< / li >
< / ul >
< h3 > Versions< / h3 >
< ul >
< li > < a href = "functional.html" > 1.0-dev (develop branch)< / a > < / li >
< li > < a href = "../../../../0.9.5/index.html" > 0.9.5 (v0.9.5 branch)< / a > < / li >
< / ul >
< / div >
< / div >
2020-06-15 21:52:33 +02:00
< div class = "bodywrapper" >
< div class = "body" role = "main" >
2020-06-13 00:36:45 +02:00
< h1 > Source code for django.utils.functional< / h1 > < div class = "highlight" > < pre >
< span > < / span > < span class = "kn" > import< / span > < span class = "nn" > copy< / span >
< span class = "kn" > import< / span > < span class = "nn" > itertools< / span >
< span class = "kn" > import< / span > < span class = "nn" > operator< / span >
2020-12-20 14:36:24 +01:00
< span class = "kn" > from< / span > < span class = "nn" > functools< / span > < span class = "kn" > import< / span > < span class = "n" > total_ordering< / span > < span class = "p" > ,< / span > < span class = "n" > wraps< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > class< / span > < span class = "nc" > cached_property< / span > < span class = "p" > :< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Decorator that converts a method with a single self argument into a< / span >
< span class = "sd" > property cached on the instance.< / span >
< span class = "sd" > A cached property can be made out of an existing method:< / span >
< span class = "sd" > (e.g. ``url = cached_property(get_absolute_url)``).< / span >
2021-05-16 00:06:01 +02:00
< span class = "sd" > The optional ``name`` argument is obsolete as of Python 3.6 and will be< / span >
< span class = "sd" > deprecated in Django 4.0 (#30127).< / span >
2020-06-13 00:36:45 +02:00
< span class = "sd" > " " " < / span >
2022-03-04 23:52:33 +00:00
2020-06-13 00:36:45 +02:00
< span class = "n" > name< / span > < span class = "o" > =< / span > < span class = "kc" > None< / span >
< span class = "nd" > @staticmethod< / span >
< span class = "k" > def< / span > < span class = "nf" > func< / span > < span class = "p" > (< / span > < span class = "n" > instance< / span > < span class = "p" > ):< / span >
< span class = "k" > raise< / span > < span class = "ne" > TypeError< / span > < span class = "p" > (< / span >
2022-03-04 23:52:33 +00:00
< span class = "s2" > " Cannot use cached_property instance without calling " < / span >
< span class = "s2" > " __set_name__() on it." < / span >
2020-06-13 00:36:45 +02:00
< span class = "p" > )< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __init__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > func< / span > < span class = "p" > ,< / span > < span class = "n" > name< / span > < span class = "o" > =< / span > < span class = "kc" > None< / span > < span class = "p" > ):< / span >
2021-05-16 00:06:01 +02:00
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > real_func< / span > < span class = "o" > =< / span > < span class = "n" > func< / span >
2022-03-04 23:52:33 +00:00
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "vm" > __doc__< / span > < span class = "o" > =< / span > < span class = "nb" > getattr< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ,< / span > < span class = "s2" > " __doc__" < / span > < span class = "p" > )< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > def< / span > < span class = "nf" > __set_name__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > owner< / span > < span class = "p" > ,< / span > < span class = "n" > name< / span > < span class = "p" > ):< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > name< / span > < span class = "ow" > is< / span > < span class = "kc" > None< / span > < span class = "p" > :< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > name< / span > < span class = "o" > =< / span > < span class = "n" > name< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > func< / span > < span class = "o" > =< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > real_func< / span >
< span class = "k" > elif< / span > < span class = "n" > name< / span > < span class = "o" > !=< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > name< / span > < span class = "p" > :< / span >
< span class = "k" > raise< / span > < span class = "ne" > TypeError< / span > < span class = "p" > (< / span >
< span class = "s2" > " Cannot assign the same cached_property to two different names " < / span >
< span class = "s2" > " (< / span > < span class = "si" > %r< / span > < span class = "s2" > and < / span > < span class = "si" > %r< / span > < span class = "s2" > )." < / span > < span class = "o" > %< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > name< / span > < span class = "p" > ,< / span > < span class = "n" > name< / span > < span class = "p" > )< / span >
< span class = "p" > )< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __get__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > instance< / span > < span class = "p" > ,< / span > < span class = "bp" > cls< / span > < span class = "o" > =< / span > < span class = "kc" > None< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "sd" > " " " < / span >
< span class = "sd" > Call the function and put the return value in instance.__dict__ so that< / span >
< span class = "sd" > subsequent attribute access on the instance returns the cached value< / span >
< span class = "sd" > instead of calling cached_property.__get__().< / span >
< span class = "sd" > " " " < / span >
< span class = "k" > if< / span > < span class = "n" > instance< / span > < span class = "ow" > is< / span > < span class = "kc" > None< / span > < span class = "p" > :< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span >
< span class = "n" > res< / span > < span class = "o" > =< / span > < span class = "n" > instance< / span > < span class = "o" > .< / span > < span class = "vm" > __dict__< / span > < span class = "p" > [< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > name< / span > < span class = "p" > ]< / span > < span class = "o" > =< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > func< / span > < span class = "p" > (< / span > < span class = "n" > instance< / span > < span class = "p" > )< / span >
< span class = "k" > return< / span > < span class = "n" > res< / span >
2021-05-16 00:06:01 +02:00
< span class = "k" > class< / span > < span class = "nc" > classproperty< / span > < span class = "p" > :< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Decorator that converts a method with a single cls argument into a property< / span >
< span class = "sd" > that can be accessed directly from the class.< / span >
< span class = "sd" > " " " < / span >
2022-03-04 23:52:33 +00:00
2021-05-16 00:06:01 +02:00
< span class = "k" > def< / span > < span class = "fm" > __init__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > method< / span > < span class = "o" > =< / span > < span class = "kc" > None< / span > < span class = "p" > ):< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > fget< / span > < span class = "o" > =< / span > < span class = "n" > method< / span >
< span class = "k" > def< / span > < span class = "fm" > __get__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > instance< / span > < span class = "p" > ,< / span > < span class = "bp" > cls< / span > < span class = "o" > =< / span > < span class = "kc" > None< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > fget< / span > < span class = "p" > (< / span > < span class = "bp" > cls< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > getter< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > method< / span > < span class = "p" > ):< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > fget< / span > < span class = "o" > =< / span > < span class = "n" > method< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > class< / span > < span class = "nc" > Promise< / span > < span class = "p" > :< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Base class for the proxy class created in the closure of the lazy function.< / span >
< span class = "sd" > It' s used to recognize promises in code.< / span >
< span class = "sd" > " " " < / span >
2022-03-04 23:52:33 +00:00
2020-06-13 00:36:45 +02:00
< span class = "k" > pass< / span >
< span class = "k" > def< / span > < span class = "nf" > lazy< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ,< / span > < span class = "o" > *< / span > < span class = "n" > resultclasses< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Turn any callable into a lazy evaluated callable. result classes or types< / span >
< span class = "sd" > is required -- at least one is needed so that the automatic forcing of< / span >
< span class = "sd" > the lazy evaluation code is triggered. Results are not memoized; the< / span >
< span class = "sd" > function is evaluated on every access.< / span >
< span class = "sd" > " " " < / span >
< span class = "nd" > @total_ordering< / span >
< span class = "k" > class< / span > < span class = "nc" > __proxy__< / span > < span class = "p" > (< / span > < span class = "n" > Promise< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Encapsulate a function call and act as a proxy for methods that are< / span >
< span class = "sd" > called on the result of that function. The function is not evaluated< / span >
< span class = "sd" > until one of the methods on the result is called.< / span >
< span class = "sd" > " " " < / span >
2022-03-04 23:52:33 +00:00
2020-06-13 00:36:45 +02:00
< span class = "n" > __prepared< / span > < span class = "o" > =< / span > < span class = "kc" > False< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __init__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "n" > kw< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __args< / span > < span class = "o" > =< / span > < span class = "n" > args< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __kw< / span > < span class = "o" > =< / span > < span class = "n" > kw< / span >
< span class = "k" > if< / span > < span class = "ow" > not< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __prepared< / span > < span class = "p" > :< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __prepare_class__< / span > < span class = "p" > ()< / span >
2021-05-16 00:06:01 +02:00
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "vm" > __class__< / span > < span class = "o" > .< / span > < span class = "n" > __prepared< / span > < span class = "o" > =< / span > < span class = "kc" > True< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > def< / span > < span class = "nf" > __reduce__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "p" > (< / span >
< span class = "n" > _lazy_proxy_unpickle< / span > < span class = "p" > ,< / span >
2022-03-04 23:52:33 +00:00
< span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ,< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __args< / span > < span class = "p" > ,< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __kw< / span > < span class = "p" > )< / span > < span class = "o" > +< / span > < span class = "n" > resultclasses< / span > < span class = "p" > ,< / span >
2020-06-13 00:36:45 +02:00
< span class = "p" > )< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __repr__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > return< / span > < span class = "nb" > repr< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ())< / span >
< span class = "nd" > @classmethod< / span >
< span class = "k" > def< / span > < span class = "nf" > __prepare_class__< / span > < span class = "p" > (< / span > < span class = "bp" > cls< / span > < span class = "p" > ):< / span >
< span class = "k" > for< / span > < span class = "n" > resultclass< / span > < span class = "ow" > in< / span > < span class = "n" > resultclasses< / span > < span class = "p" > :< / span >
< span class = "k" > for< / span > < span class = "n" > type_< / span > < span class = "ow" > in< / span > < span class = "n" > resultclass< / span > < span class = "o" > .< / span > < span class = "n" > mro< / span > < span class = "p" > ():< / span >
< span class = "k" > for< / span > < span class = "n" > method_name< / span > < span class = "ow" > in< / span > < span class = "n" > type_< / span > < span class = "o" > .< / span > < span class = "vm" > __dict__< / span > < span class = "p" > :< / span >
< span class = "c1" > # All __promise__ return the same wrapper method, they< / span >
< span class = "c1" > # look up the correct implementation when called.< / span >
< span class = "k" > if< / span > < span class = "nb" > hasattr< / span > < span class = "p" > (< / span > < span class = "bp" > cls< / span > < span class = "p" > ,< / span > < span class = "n" > method_name< / span > < span class = "p" > ):< / span >
< span class = "k" > continue< / span >
< span class = "n" > meth< / span > < span class = "o" > =< / span > < span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > __promise__< / span > < span class = "p" > (< / span > < span class = "n" > method_name< / span > < span class = "p" > )< / span >
< span class = "nb" > setattr< / span > < span class = "p" > (< / span > < span class = "bp" > cls< / span > < span class = "p" > ,< / span > < span class = "n" > method_name< / span > < span class = "p" > ,< / span > < span class = "n" > meth< / span > < span class = "p" > )< / span >
< span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_bytes< / span > < span class = "o" > =< / span > < span class = "nb" > bytes< / span > < span class = "ow" > in< / span > < span class = "n" > resultclasses< / span >
< span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_text< / span > < span class = "o" > =< / span > < span class = "nb" > str< / span > < span class = "ow" > in< / span > < span class = "n" > resultclasses< / span >
2022-02-05 15:09:22 +00:00
< span class = "k" > if< / span > < span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_bytes< / span > < span class = "ow" > and< / span > < span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_text< / span > < span class = "p" > :< / span >
< span class = "k" > raise< / span > < span class = "ne" > ValueError< / span > < span class = "p" > (< / span >
2022-03-04 23:52:33 +00:00
< span class = "s2" > " Cannot call lazy() with both bytes and text return types." < / span >
2022-02-05 15:09:22 +00:00
< span class = "p" > )< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > if< / span > < span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_text< / span > < span class = "p" > :< / span >
< span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "fm" > __str__< / span > < span class = "o" > =< / span > < span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > __text_cast< / span >
< span class = "k" > elif< / span > < span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_bytes< / span > < span class = "p" > :< / span >
< span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "fm" > __bytes__< / span > < span class = "o" > =< / span > < span class = "bp" > cls< / span > < span class = "o" > .< / span > < span class = "n" > __bytes_cast< / span >
< span class = "nd" > @classmethod< / span >
< span class = "k" > def< / span > < span class = "nf" > __promise__< / span > < span class = "p" > (< / span > < span class = "bp" > cls< / span > < span class = "p" > ,< / span > < span class = "n" > method_name< / span > < span class = "p" > ):< / span >
< span class = "c1" > # Builds a wrapper around some magic method< / span >
< span class = "k" > def< / span > < span class = "nf" > __wrapper__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "n" > kw< / span > < span class = "p" > ):< / span >
< span class = "c1" > # Automatically triggers the evaluation of a lazy value and< / span >
< span class = "c1" > # applies the given magic method of the result type.< / span >
< span class = "n" > res< / span > < span class = "o" > =< / span > < span class = "n" > func< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __kw< / span > < span class = "p" > )< / span >
< span class = "k" > return< / span > < span class = "nb" > getattr< / span > < span class = "p" > (< / span > < span class = "n" > res< / span > < span class = "p" > ,< / span > < span class = "n" > method_name< / span > < span class = "p" > )(< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "n" > kw< / span > < span class = "p" > )< / span >
2022-03-04 23:52:33 +00:00
2020-06-13 00:36:45 +02:00
< span class = "k" > return< / span > < span class = "n" > __wrapper__< / span >
< span class = "k" > def< / span > < span class = "nf" > __text_cast< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "n" > func< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __kw< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > __bytes_cast< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "nb" > bytes< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __kw< / span > < span class = "p" > ))< / span >
< span class = "k" > def< / span > < span class = "nf" > __bytes_cast_encoded< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "n" > func< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __kw< / span > < span class = "p" > )< / span > < span class = "o" > .< / span > < span class = "n" > encode< / span > < span class = "p" > ()< / span >
< span class = "k" > def< / span > < span class = "nf" > __cast< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_bytes< / span > < span class = "p" > :< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __bytes_cast< / span > < span class = "p" > ()< / span >
< span class = "k" > elif< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_text< / span > < span class = "p" > :< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __text_cast< / span > < span class = "p" > ()< / span >
< span class = "k" > else< / span > < span class = "p" > :< / span >
< span class = "k" > return< / span > < span class = "n" > func< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __kw< / span > < span class = "p" > )< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __str__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "c1" > # object defines __str__(), so __prepare_class__() won' t overload< / span >
< span class = "c1" > # a __str__() method from the proxied class.< / span >
< span class = "k" > return< / span > < span class = "nb" > str< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ())< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __eq__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > other< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > if< / span > < span class = "nb" > isinstance< / span > < span class = "p" > (< / span > < span class = "n" > other< / span > < span class = "p" > ,< / span > < span class = "n" > Promise< / span > < span class = "p" > ):< / span >
< span class = "n" > other< / span > < span class = "o" > =< / span > < span class = "n" > other< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ()< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ()< / span > < span class = "o" > ==< / span > < span class = "n" > other< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __lt__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > other< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > if< / span > < span class = "nb" > isinstance< / span > < span class = "p" > (< / span > < span class = "n" > other< / span > < span class = "p" > ,< / span > < span class = "n" > Promise< / span > < span class = "p" > ):< / span >
< span class = "n" > other< / span > < span class = "o" > =< / span > < span class = "n" > other< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ()< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ()< / span > < span class = "o" > < < / span > < span class = "n" > other< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __hash__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > return< / span > < span class = "nb" > hash< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ())< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __mod__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > rhs< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _delegate_text< / span > < span class = "p" > :< / span >
< span class = "k" > return< / span > < span class = "nb" > str< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > )< / span > < span class = "o" > %< / span > < span class = "n" > rhs< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ()< / span > < span class = "o" > %< / span > < span class = "n" > rhs< / span >
2021-05-16 00:06:01 +02:00
< span class = "k" > def< / span > < span class = "fm" > __add__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > other< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ()< / span > < span class = "o" > +< / span > < span class = "n" > other< / span >
< span class = "k" > def< / span > < span class = "fm" > __radd__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > other< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "n" > other< / span > < span class = "o" > +< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > __cast< / span > < span class = "p" > ()< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > def< / span > < span class = "nf" > __deepcopy__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > memo< / span > < span class = "p" > ):< / span >
< span class = "c1" > # Instances of this class are effectively immutable. It' s just a< / span >
< span class = "c1" > # collection of functions. So we don' t need to do anything< / span >
< span class = "c1" > # complicated for copying.< / span >
< span class = "n" > memo< / span > < span class = "p" > [< / span > < span class = "nb" > id< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > )]< / span > < span class = "o" > =< / span > < span class = "bp" > self< / span >
< span class = "k" > return< / span > < span class = "bp" > self< / span >
< span class = "nd" > @wraps< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > __wrapper__< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "n" > kw< / span > < span class = "p" > ):< / span >
< span class = "c1" > # Creates the proxy object, instead of the actual value.< / span >
< span class = "k" > return< / span > < span class = "n" > __proxy__< / span > < span class = "p" > (< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "n" > kw< / span > < span class = "p" > )< / span >
< span class = "k" > return< / span > < span class = "n" > __wrapper__< / span >
< span class = "k" > def< / span > < span class = "nf" > _lazy_proxy_unpickle< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ,< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "n" > kwargs< / span > < span class = "p" > ,< / span > < span class = "o" > *< / span > < span class = "n" > resultclasses< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "n" > lazy< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ,< / span > < span class = "o" > *< / span > < span class = "n" > resultclasses< / span > < span class = "p" > )(< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "n" > kwargs< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > lazystr< / span > < span class = "p" > (< / span > < span class = "n" > text< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Shortcut for the common case of a lazy callable that returns str.< / span >
< span class = "sd" > " " " < / span >
< span class = "k" > return< / span > < span class = "n" > lazy< / span > < span class = "p" > (< / span > < span class = "nb" > str< / span > < span class = "p" > ,< / span > < span class = "nb" > str< / span > < span class = "p" > )(< / span > < span class = "n" > text< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > keep_lazy< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "n" > resultclasses< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > A decorator that allows a function to be called with one or more lazy< / span >
< span class = "sd" > arguments. If none of the args are lazy, the function is evaluated< / span >
< span class = "sd" > immediately, otherwise a __proxy__ is returned that will evaluate the< / span >
< span class = "sd" > function when needed.< / span >
< span class = "sd" > " " " < / span >
< span class = "k" > if< / span > < span class = "ow" > not< / span > < span class = "n" > resultclasses< / span > < span class = "p" > :< / span >
< span class = "k" > raise< / span > < span class = "ne" > TypeError< / span > < span class = "p" > (< / span > < span class = "s2" > " You must pass at least one argument to keep_lazy()." < / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > decorator< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ):< / span >
< span class = "n" > lazy_func< / span > < span class = "o" > =< / span > < span class = "n" > lazy< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ,< / span > < span class = "o" > *< / span > < span class = "n" > resultclasses< / span > < span class = "p" > )< / span >
< span class = "nd" > @wraps< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > wrapper< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "n" > kwargs< / span > < span class = "p" > ):< / span >
2022-03-04 23:52:33 +00:00
< span class = "k" > if< / span > < span class = "nb" > any< / span > < span class = "p" > (< / span >
< span class = "nb" > isinstance< / span > < span class = "p" > (< / span > < span class = "n" > arg< / span > < span class = "p" > ,< / span > < span class = "n" > Promise< / span > < span class = "p" > )< / span >
< span class = "k" > for< / span > < span class = "n" > arg< / span > < span class = "ow" > in< / span > < span class = "n" > itertools< / span > < span class = "o" > .< / span > < span class = "n" > chain< / span > < span class = "p" > (< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "n" > kwargs< / span > < span class = "o" > .< / span > < span class = "n" > values< / span > < span class = "p" > ())< / span >
< span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > return< / span > < span class = "n" > lazy_func< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "n" > kwargs< / span > < span class = "p" > )< / span >
< span class = "k" > return< / span > < span class = "n" > func< / span > < span class = "p" > (< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > ,< / span > < span class = "o" > **< / span > < span class = "n" > kwargs< / span > < span class = "p" > )< / span >
2022-03-04 23:52:33 +00:00
2020-06-13 00:36:45 +02:00
< span class = "k" > return< / span > < span class = "n" > wrapper< / span >
2022-03-04 23:52:33 +00:00
2020-06-13 00:36:45 +02:00
< span class = "k" > return< / span > < span class = "n" > decorator< / span >
< span class = "k" > def< / span > < span class = "nf" > keep_lazy_text< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > A decorator for functions that accept lazy arguments and return text.< / span >
< span class = "sd" > " " " < / span >
< span class = "k" > return< / span > < span class = "n" > keep_lazy< / span > < span class = "p" > (< / span > < span class = "nb" > str< / span > < span class = "p" > )(< / span > < span class = "n" > func< / span > < span class = "p" > )< / span >
< span class = "n" > empty< / span > < span class = "o" > =< / span > < span class = "nb" > object< / span > < span class = "p" > ()< / span >
< span class = "k" > def< / span > < span class = "nf" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ):< / span >
< span class = "k" > def< / span > < span class = "nf" > inner< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > ):< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _setup< / span > < span class = "p" > ()< / span >
< span class = "k" > return< / span > < span class = "n" > func< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "p" > ,< / span > < span class = "o" > *< / span > < span class = "n" > args< / span > < span class = "p" > )< / span >
2022-03-04 23:52:33 +00:00
2020-06-13 00:36:45 +02:00
< span class = "k" > return< / span > < span class = "n" > inner< / span >
< span class = "k" > class< / span > < span class = "nc" > LazyObject< / span > < span class = "p" > :< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > A wrapper for another class that can be used to delay instantiation of the< / span >
< span class = "sd" > wrapped class.< / span >
< span class = "sd" > By subclassing, you have the opportunity to intercept and alter the< / span >
< span class = "sd" > instantiation. If you don' t need to do that, use SimpleLazyObject.< / span >
< span class = "sd" > " " " < / span >
< span class = "c1" > # Avoid infinite recursion when tracing __init__ (#19456).< / span >
< span class = "n" > _wrapped< / span > < span class = "o" > =< / span > < span class = "kc" > None< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __init__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "c1" > # Note: if a subclass overrides __init__(), it will likely need to< / span >
< span class = "c1" > # override __copy__() and __deepcopy__() as well.< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "o" > =< / span > < span class = "n" > empty< / span >
< span class = "fm" > __getattr__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "nb" > getattr< / span > < span class = "p" > )< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __setattr__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > name< / span > < span class = "p" > ,< / span > < span class = "n" > value< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > if< / span > < span class = "n" > name< / span > < span class = "o" > ==< / span > < span class = "s2" > " _wrapped" < / span > < span class = "p" > :< / span >
< span class = "c1" > # Assign to __dict__ to avoid infinite __setattr__ loops.< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "vm" > __dict__< / span > < span class = "p" > [< / span > < span class = "s2" > " _wrapped" < / span > < span class = "p" > ]< / span > < span class = "o" > =< / span > < span class = "n" > value< / span >
< span class = "k" > else< / span > < span class = "p" > :< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _setup< / span > < span class = "p" > ()< / span >
< span class = "nb" > setattr< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "p" > ,< / span > < span class = "n" > name< / span > < span class = "p" > ,< / span > < span class = "n" > value< / span > < span class = "p" > )< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __delattr__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > name< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > if< / span > < span class = "n" > name< / span > < span class = "o" > ==< / span > < span class = "s2" > " _wrapped" < / span > < span class = "p" > :< / span >
< span class = "k" > raise< / span > < span class = "ne" > TypeError< / span > < span class = "p" > (< / span > < span class = "s2" > " can' t delete _wrapped." < / span > < span class = "p" > )< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _setup< / span > < span class = "p" > ()< / span >
< span class = "nb" > delattr< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "p" > ,< / span > < span class = "n" > name< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > _setup< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Must be implemented by subclasses to initialize the wrapped object.< / span >
< span class = "sd" > " " " < / span >
2022-03-04 23:52:33 +00:00
< span class = "k" > raise< / span > < span class = "ne" > NotImplementedError< / span > < span class = "p" > (< / span >
< span class = "s2" > " subclasses of LazyObject must provide a _setup() method" < / span >
< span class = "p" > )< / span >
2020-06-13 00:36:45 +02:00
< span class = "c1" > # Because we have messed with __class__ below, we confuse pickle as to what< / span >
< span class = "c1" > # class we are pickling. We' re going to have to initialize the wrapped< / span >
< span class = "c1" > # object to successfully pickle it, so we might as well just pickle the< / span >
< span class = "c1" > # wrapped object since they' re supposed to act the same way.< / span >
< span class = "c1" > #< / span >
< span class = "c1" > # Unfortunately, if we try to simply act like the wrapped object, the ruse< / span >
< span class = "c1" > # will break down when pickle gets our id(). Thus we end up with pickle< / span >
< span class = "c1" > # thinking, in effect, that we are a distinct object from the wrapped< / span >
< span class = "c1" > # object, but with the same __dict__. This can cause problems (see #25389).< / span >
< span class = "c1" > #< / span >
< span class = "c1" > # So instead, we define our own __reduce__ method and custom unpickler. We< / span >
< span class = "c1" > # pickle the wrapped object as the unpickler' s argument, so that pickle< / span >
< span class = "c1" > # will pickle it normally, and then the unpickler simply returns its< / span >
< span class = "c1" > # argument.< / span >
< span class = "k" > def< / span > < span class = "nf" > __reduce__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _setup< / span > < span class = "p" > ()< / span >
< span class = "k" > return< / span > < span class = "p" > (< / span > < span class = "n" > unpickle_lazyobject< / span > < span class = "p" > ,< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "p" > ,))< / span >
< span class = "k" > def< / span > < span class = "nf" > __copy__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "c1" > # If uninitialized, copy the wrapper. Use type(self), not< / span >
< span class = "c1" > # self.__class__, because the latter is proxied.< / span >
< span class = "k" > return< / span > < span class = "nb" > type< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > )()< / span >
< span class = "k" > else< / span > < span class = "p" > :< / span >
< span class = "c1" > # If initialized, return a copy of the wrapped object.< / span >
< span class = "k" > return< / span > < span class = "n" > copy< / span > < span class = "o" > .< / span > < span class = "n" > copy< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > __deepcopy__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > memo< / span > < span class = "p" > ):< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "c1" > # We have to use type(self), not self.__class__, because the< / span >
< span class = "c1" > # latter is proxied.< / span >
< span class = "n" > result< / span > < span class = "o" > =< / span > < span class = "nb" > type< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > )()< / span >
< span class = "n" > memo< / span > < span class = "p" > [< / span > < span class = "nb" > id< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > )]< / span > < span class = "o" > =< / span > < span class = "n" > result< / span >
< span class = "k" > return< / span > < span class = "n" > result< / span >
< span class = "k" > return< / span > < span class = "n" > copy< / span > < span class = "o" > .< / span > < span class = "n" > deepcopy< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "p" > ,< / span > < span class = "n" > memo< / span > < span class = "p" > )< / span >
< span class = "fm" > __bytes__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "nb" > bytes< / span > < span class = "p" > )< / span >
< span class = "fm" > __str__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "nb" > str< / span > < span class = "p" > )< / span >
< span class = "fm" > __bool__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "nb" > bool< / span > < span class = "p" > )< / span >
< span class = "c1" > # Introspection support< / span >
< span class = "fm" > __dir__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "nb" > dir< / span > < span class = "p" > )< / span >
< span class = "c1" > # Need to pretend to be the wrapped class, for the sake of objects that< / span >
< span class = "c1" > # care about this (especially in equality tests)< / span >
< span class = "vm" > __class__< / span > < span class = "o" > =< / span > < span class = "nb" > property< / span > < span class = "p" > (< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > attrgetter< / span > < span class = "p" > (< / span > < span class = "s2" > " __class__" < / span > < span class = "p" > )))< / span >
< span class = "fm" > __eq__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > eq< / span > < span class = "p" > )< / span >
< span class = "fm" > __lt__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > lt< / span > < span class = "p" > )< / span >
< span class = "fm" > __gt__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > gt< / span > < span class = "p" > )< / span >
< span class = "fm" > __ne__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > ne< / span > < span class = "p" > )< / span >
< span class = "fm" > __hash__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "nb" > hash< / span > < span class = "p" > )< / span >
< span class = "c1" > # List/Tuple/Dictionary methods support< / span >
< span class = "fm" > __getitem__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > getitem< / span > < span class = "p" > )< / span >
< span class = "fm" > __setitem__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > setitem< / span > < span class = "p" > )< / span >
< span class = "fm" > __delitem__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > delitem< / span > < span class = "p" > )< / span >
< span class = "fm" > __iter__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "nb" > iter< / span > < span class = "p" > )< / span >
< span class = "fm" > __len__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "nb" > len< / span > < span class = "p" > )< / span >
< span class = "fm" > __contains__< / span > < span class = "o" > =< / span > < span class = "n" > new_method_proxy< / span > < span class = "p" > (< / span > < span class = "n" > operator< / span > < span class = "o" > .< / span > < span class = "n" > contains< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > unpickle_lazyobject< / span > < span class = "p" > (< / span > < span class = "n" > wrapped< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Used to unpickle lazy objects. Just return its argument, which will be the< / span >
< span class = "sd" > wrapped object.< / span >
< span class = "sd" > " " " < / span >
< span class = "k" > return< / span > < span class = "n" > wrapped< / span >
< span class = "k" > class< / span > < span class = "nc" > SimpleLazyObject< / span > < span class = "p" > (< / span > < span class = "n" > LazyObject< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > A lazy object initialized from any function.< / span >
< span class = "sd" > Designed for compound objects of unknown type. For builtins or objects of< / span >
< span class = "sd" > known type, use django.utils.functional.lazy.< / span >
< span class = "sd" > " " " < / span >
2022-03-04 23:52:33 +00:00
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __init__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > func< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "sd" > " " " < / span >
< span class = "sd" > Pass in a callable that returns the object to be wrapped.< / span >
< span class = "sd" > If copies are made of the resulting SimpleLazyObject, which can happen< / span >
< span class = "sd" > in various circumstances within Django, then you must ensure that the< / span >
< span class = "sd" > callable can be safely run more than once and will return the same< / span >
< span class = "sd" > value.< / span >
< span class = "sd" > " " " < / span >
2022-03-04 23:52:33 +00:00
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "vm" > __dict__< / span > < span class = "p" > [< / span > < span class = "s2" > " _setupfunc" < / span > < span class = "p" > ]< / span > < span class = "o" > =< / span > < span class = "n" > func< / span >
2020-06-13 00:36:45 +02:00
< span class = "nb" > super< / span > < span class = "p" > ()< / span > < span class = "o" > .< / span > < span class = "fm" > __init__< / span > < span class = "p" > ()< / span >
< span class = "k" > def< / span > < span class = "nf" > _setup< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "o" > =< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _setupfunc< / span > < span class = "p" > ()< / span >
< span class = "c1" > # Return a meaningful representation of the lazy object for debugging< / span >
< span class = "c1" > # without evaluating the wrapped object.< / span >
2020-12-20 14:36:24 +01:00
< span class = "k" > def< / span > < span class = "fm" > __repr__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "n" > repr_attr< / span > < span class = "o" > =< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _setupfunc< / span >
< span class = "k" > else< / span > < span class = "p" > :< / span >
< span class = "n" > repr_attr< / span > < span class = "o" > =< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span >
2022-03-04 23:52:33 +00:00
< span class = "k" > return< / span > < span class = "s2" > " < < / span > < span class = "si" > %s< / span > < span class = "s2" > : < / span > < span class = "si" > %r< / span > < span class = "s2" > > " < / span > < span class = "o" > %< / span > < span class = "p" > (< / span > < span class = "nb" > type< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > )< / span > < span class = "o" > .< / span > < span class = "vm" > __name__< / span > < span class = "p" > ,< / span > < span class = "n" > repr_attr< / span > < span class = "p" > )< / span >
2020-06-13 00:36:45 +02:00
< span class = "k" > def< / span > < span class = "nf" > __copy__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ):< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "c1" > # If uninitialized, copy the wrapper. Use SimpleLazyObject, not< / span >
< span class = "c1" > # self.__class__, because the latter is proxied.< / span >
< span class = "k" > return< / span > < span class = "n" > SimpleLazyObject< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _setupfunc< / span > < span class = "p" > )< / span >
< span class = "k" > else< / span > < span class = "p" > :< / span >
< span class = "c1" > # If initialized, return a copy of the wrapped object.< / span >
< span class = "k" > return< / span > < span class = "n" > copy< / span > < span class = "o" > .< / span > < span class = "n" > copy< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > __deepcopy__< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > ,< / span > < span class = "n" > memo< / span > < span class = "p" > ):< / span >
< span class = "k" > if< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "ow" > is< / span > < span class = "n" > empty< / span > < span class = "p" > :< / span >
< span class = "c1" > # We have to use SimpleLazyObject, not self.__class__, because the< / span >
< span class = "c1" > # latter is proxied.< / span >
< span class = "n" > result< / span > < span class = "o" > =< / span > < span class = "n" > SimpleLazyObject< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _setupfunc< / span > < span class = "p" > )< / span >
< span class = "n" > memo< / span > < span class = "p" > [< / span > < span class = "nb" > id< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "p" > )]< / span > < span class = "o" > =< / span > < span class = "n" > result< / span >
< span class = "k" > return< / span > < span class = "n" > result< / span >
< span class = "k" > return< / span > < span class = "n" > copy< / span > < span class = "o" > .< / span > < span class = "n" > deepcopy< / span > < span class = "p" > (< / span > < span class = "bp" > self< / span > < span class = "o" > .< / span > < span class = "n" > _wrapped< / span > < span class = "p" > ,< / span > < span class = "n" > memo< / span > < span class = "p" > )< / span >
< span class = "k" > def< / span > < span class = "nf" > partition< / span > < span class = "p" > (< / span > < span class = "n" > predicate< / span > < span class = "p" > ,< / span > < span class = "n" > values< / span > < span class = "p" > ):< / span >
< span class = "sd" > " " " < / span >
< span class = "sd" > Split the values into two sets, based on the return value of the function< / span >
< span class = "sd" > (True/False). e.g.:< / span >
< span class = "sd" > > > > partition(lambda x: x > 3, range(5))< / span >
< span class = "sd" > [0, 1, 2, 3], [4]< / span >
< span class = "sd" > " " " < / span >
< span class = "n" > results< / span > < span class = "o" > =< / span > < span class = "p" > ([],< / span > < span class = "p" > [])< / span >
< span class = "k" > for< / span > < span class = "n" > item< / span > < span class = "ow" > in< / span > < span class = "n" > values< / span > < span class = "p" > :< / span >
< span class = "n" > results< / span > < span class = "p" > [< / span > < span class = "n" > predicate< / span > < span class = "p" > (< / span > < span class = "n" > item< / span > < span class = "p" > )]< / span > < span class = "o" > .< / span > < span class = "n" > append< / span > < span class = "p" > (< / span > < span class = "n" > item< / span > < span class = "p" > )< / span >
< span class = "k" > return< / span > < span class = "n" > results< / span >
< / pre > < / div >
< / div >
< / div >
< / div >
2020-06-15 21:52:33 +02:00
< / div >
< div class = "related" role = "navigation" aria-label = "related navigation" >
< h3 > Navigation< / h3 >
< ul >
< li class = "right" style = "margin-right: 10px" >
< a href = "../../../genindex.html" title = "General Index"
>index< / a > < / li >
< li class = "right" >
< a href = "../../../py-modindex.html" title = "Python Module Index"
>modules< / a > |< / li >
2020-07-14 00:21:00 +02:00
< li class = "nav-item nav-item-0" > < a href = "../../../index.html" > Evennia 1.0-dev< / a > » < / li >
2020-10-15 01:31:30 +02:00
< li class = "nav-item nav-item-1" > < a href = "../../index.html" > Module code< / a > » < / li >
< li class = "nav-item nav-item-this" > < a href = "" > django.utils.functional< / a > < / li >
2020-06-15 21:52:33 +02:00
< / ul >
2021-06-23 18:58:26 +02:00
< div class = "develop" > develop branch< / div >
2020-06-15 21:52:33 +02:00
< / div >
< div class = "footer" role = "contentinfo" >
© Copyright 2020, The Evennia developer community.
2020-10-15 01:31:30 +02:00
Created using < a href = "https://www.sphinx-doc.org/" > Sphinx< / a > 3.2.1.
2020-06-15 21:52:33 +02:00
< / div >
< / body >
2020-06-13 00:36:45 +02:00
< / html >
