7450289140

Committed 08 Jan 2024 04:26PM UTC coverage: 83.401% (+0.1%) from 83.299%

Build # 7450289140

Build Type

push

github

Committed by

web-flow

Commit Message

add django-geojson template filter to the documentation (#369)

Run Details

412 of 494 relevant lines covered (83.4%)

13.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/leaflet/utils.py

from collections.abc import Sequence

from django.utils.functional import Promise


class memoized_lazy_function(Promise):
    """
    Represents a lazy value which is calculated by calling
    func(*args, **kwargs) and then is memoized.

    >>> f = memoized_lazy_function(lambda a: print('.') or a, 'hello')
    >>> f()
    .
    'hello'
    >>> f()
    'hello'
    """

    def __init__(self, func, *args, **kwargs):
        self._func = func
        self._args = args
        self._kwargs = kwargs

    def __call__(self):
        if not hasattr(self, '_result'):
            self._result = self._func(*self._args, **self._kwargs)
        return self._result


class ListWithLazyItems(Sequence):
    """
    Mimics a lazy list.

    It keeps items in lazy state and evaluates them when they're
    returned.

    An item is considered lazy when it is
    a `django.utils.functional.Promise` instance.
    """

    def __init__(self, iterable=()):
        if isinstance(iterable, ListWithLazyItems):
            iterable = iterable._list
        self._list = list(iterable)

    def __iter__(self):
        for item in self._list:
            yield self._resolve_lazy_item(item)

    def __len__(self):
        return len(self._list)

    def __getitem__(self, index):
        return self._resolve_lazy_item(self._list[index])

    def extend(self, iterable):
        if isinstance(iterable, ListWithLazyItems):
            iterable = iterable._list
        self._list.extend(iterable)

    def __radd__(self, iterable):
        lazy_list = type(self)(iterable)  # copy
        lazy_list.extend(self)
        return lazy_list

    def __add__(self, iterable):
        lazy_list = type(self)(self)  # copy
        lazy_list.extend(iterable)
        return lazy_list

    @classmethod
    def _resolve_lazy_item(cls, item):
        if cls.is_lazy_item(item):
            item = item()

        return item

    @classmethod
    def is_lazy_item(cls, item):
        return isinstance(item, Promise)


class ListWithLazyItemsRawIterator(ListWithLazyItems):
    """
    This lazy list yields raw items (i.e. Promises are not resolved)
    when iterated.
    """

    def __iter__(self):
        return iter(self._list)

1	from collections.abc import Sequence	×
2
3	from django.utils.functional import Promise	×
4
5
6	class memoized_lazy_function(Promise):	×
7	"""
8	Represents a lazy value which is calculated by calling
9	func(args, *kwargs) and then is memoized.
10
11	>>> f = memoized_lazy_function(lambda a: print('.') or a, 'hello')
12	>>> f()
13	.
14	'hello'
15	>>> f()
16	'hello'
17	"""
18
19	def __init__(self, func, args, *kwargs):	×
20	self._func = func	×
21	self._args = args	×
22	self._kwargs = kwargs	×
23
24	def __call__(self):	×
25	if not hasattr(self, '_result'):	×
26	self._result = self._func(self._args, *self._kwargs)	×
27	return self._result	×
28
29
30	class ListWithLazyItems(Sequence):	×
31	"""
32	Mimics a lazy list.
33
34	It keeps items in lazy state and evaluates them when they're
35	returned.
36
37	An item is considered lazy when it is
38	a `django.utils.functional.Promise` instance.
39	"""
40
41	def __init__(self, iterable=()):	×
42	if isinstance(iterable, ListWithLazyItems):	×
43	iterable = iterable._list	×
44	self._list = list(iterable)	×
45
46	def __iter__(self):	×
47	for item in self._list:	×
48	yield self._resolve_lazy_item(item)	×
49
50	def __len__(self):	×
51	return len(self._list)	×
52
53	def __getitem__(self, index):	×
54	return self._resolve_lazy_item(self._list[index])	×
55
56	def extend(self, iterable):	×
57	if isinstance(iterable, ListWithLazyItems):	×
58	iterable = iterable._list	×
59	self._list.extend(iterable)	×
60
61	def __radd__(self, iterable):	×
62	lazy_list = type(self)(iterable) # copy	×
63	lazy_list.extend(self)	×
64	return lazy_list	×
65
66	def __add__(self, iterable):	×
67	lazy_list = type(self)(self) # copy	×
68	lazy_list.extend(iterable)	×
69	return lazy_list	×
70
71	@classmethod	×
72	def _resolve_lazy_item(cls, item):
73	if cls.is_lazy_item(item):	×
74	item = item()	×
75
76	return item	×
77
78	@classmethod	×
79	def is_lazy_item(cls, item):
80	return isinstance(item, Promise)	×
81
82
83	class ListWithLazyItemsRawIterator(ListWithLazyItems):	×
84	"""
85	This lazy list yields raw items (i.e. Promises are not resolved)
86	when iterated.
87	"""
88
89	def __iter__(self):	×
90	return iter(self._list)	×

makinacorpus / django-leaflet / 7450289140

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous