8711265480

Committed 16 Apr 2024 07:16PM UTC coverage: 84.899% (-0.002%) from 84.901%

Build # 8711265480

Build Type

push

github

Committed by

davidt0x

Commit Message

Fix check for grad in torch.

Needs to be a check for torch functional API instead.

Run Details

13498 of 16636 branches covered (81.14%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

492 existing lines in 7 files now uncovered.

31558 of 36434 relevant lines covered (86.62%)

0.87 hits per line

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

83.72

/psyneulink/core/globals/sampleiterator.py

#
# Princeton University licenses this file to You under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.  You may obtain a copy of the License at:
#     http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and limitations under the License.
#
#
# *******************************************   SAMPLER CLASSES ********************************************************
"""

* `SampleSpec`
* `SampleIterator`

"""

from collections.abc import Iterator
from decimal import Decimal, getcontext
from inspect import isclass
from numbers import Number

import numpy as np
from beartype import beartype

from psyneulink._typing import Optional, Union, Callable

__all__ = ['SampleSpec', 'SampleIterator']


# Number of decimal places used to set precision of decimal module
SAMPLE_SPEC_PRECISION = 16


def _validate_function(source, function):
    """Ensure function specification is appropriate for SampleIterator"""
    source_name = source.__class__.__name__
    try:
        result = function()
    except:
        raise SampleIteratorError("Specification of function for {} ({}) could not be called as a function".
                                  format(source_name, function.__class__.__name__))
    if result is None:
        raise SampleIteratorError("Function specified for {} ({}) does not return a result)".
                                  format(source_name, repr(function)))
    if not isinstance(result, Number):
        raise SampleIteratorError("Function specified for {} ({}) does not return a number)".
                                  format(source_name, repr(function)))


class SampleIteratorError(Exception):
    def __init__(self, error_value):
        self.error_value = error_value


class SampleSpec:
    """
    SampleSpec(      \
    start=None,      \
    stop=None,       \
    step=None,       \
    num=None,        \
    function=None    \
    precision=None   \
    custom_spec=None \
    )

    Specify the information needed to create a SampleIterator that will either (1) generate discrete values in a range;
    (2) call a function can generate continous values within the range; (3) pass a custom spec to SampleIterator

    (1) Generate values in a range by explicitly specifying a finite regular sequence of values, using an appropriate
        combination of the **start**, **stop**, **step** and/or **num**arguments.

        * if **start**, **stop**, and **step** are specified, the behavior is similar to `Numpy's arange
          <https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.arange.html>`_. Calling
          `next <SampleIterator.__next__>`first returns **start**. Each subsequent call to next returns
          **start** :math:`+` **step** :math:`*` current_step.
          Iteration stops when the current value exceeds the **stop** value.  If any of the specified arguments are
          floats, precision determines the number of decimal places used for rounding to ensure num is a int.

        * if **start**, **stop**, and **num** are specified, the behavior is similar to `Numpy's linspace
          <https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linspace.html>`_. Calling
          `next <SampleIterator.__next__>` first returns **start**. Each subsequent call to next returns
          **start** :math:`+` step :math:`*` current_step, where step is set to :math:`\\frac{stop-start)}{num - 1}`.
          Iteration stops when **num** is reached, or the current value exceeds the **stop** value.

        * if **start**, **stop*, **step**, and **num** are all specified, then **step** and **num** must be compatible.

    (2) Specify a function, that is called repeatedly to generate a sequence of values.

        * if **num** is specified, the **function** is called once on each iteration until **num** iterations are
          complete.

        * if **num** is not specified, the **function** is called once on each iteration, and iteration may continue
          indefinitely.

    (3) Specify a custom_spec, that is passed to SampleIterator unmodified.

        * this is useful if the receiver of the SampleIterator uses a custom format or external functions to generate
          samples;  the format must, of course, be one expected by the receiver.

    .. note::
        * Some OptimizationFunctions may require that their SampleIterators have a "num" attribute.
        * The Python decimal module is used to implement **precision** for rounding.


    Arguments
    ---------

    start : int or float
        first sample in the sequence.

    stop : int or float
        maximum value of last sample in the sequence.

    step : int or float
        space between samples in sequence.

    num :  int
        number of samples.

    function : function or function class
        function to be called on each iteration. Must return one sample each time it is called.

    precision : int default 16
        number of decimal places used for rounding in floating point operations.

    custom_spec : anything

    Attributes
    ----------

    start : float
        first sample in the sequence.

    stop : float
        maximum value of last sample in the sequence.

    step : float
        space between samples in sequence.

    num :  int
        number of samples.

    function : function
        Function to be called on each iteration. Must return one sample.

    custom_spec : anything
        specification in a format recognized by receiver of SampleIterator.

    """

    @beartype
    def __init__(self,
                 start: Optional[Union[int, float]] = None,
                 stop: Optional[Union[int, float]] = None,
                 step: Optional[Union[int, float]] = None,
                 num: Optional[int] = None,
                 function: Optional[Callable] = None,
                 precision: Optional[int] = None,
                 custom_spec=None
                 ):

        self.custom_spec = custom_spec

        if self.custom_spec:
            # Assumes receiver of SampleIterator will get this and know what to do with it,
            #   therefore no other attributes are needed and, to avoid confusion, they should not be available;
            #   so just assign and return.
            return

        self._precision = precision or SAMPLE_SPEC_PRECISION
        # Save global precision for later restoration
        _global_precision = getcontext().prec
        # Set SampleSpec precision
        getcontext().prec = self._precision

        if function is None:
            if start is None or stop is None:
                raise SampleIteratorError("If 'function' is not specified, then 'start' and 'stop' must be "
                                                "specified.")
            if num is None and step is not None:
                num = int(Decimal(1.0) + Decimal(stop - start) / Decimal(step))
                # num = 1.0 + (stop - start) / step
            elif step is None and num is not None:
                step = (Decimal(stop) - Decimal(start)) / (num - 1)
            elif num is None and step is None:
                raise SampleIteratorError("Must specify one of {}, {} or {}."
                                                .format(repr('step'), repr('num'), repr('function')))
            else:
                if not np.isclose(num, 1.0 + (stop - start) / step):
                    raise SampleIteratorError("The {} ({}) and {} ({}) values specified are not comaptible."
                                                    .format(repr('step'), step, repr('num'), num))

        elif callable(function):
            _validate_function(self, function)

            if start is not None:
                raise SampleIteratorError("Only one of {} ({}) and {} ({}) may be specified."
                                                .format(repr('start'), start, repr('function'), function))
            if step is not None:
                raise SampleIteratorError("Only one of {} ({}) and {} ({}) may be specified."
                                                .format(repr('step'), step, repr('function'), function))
        else:
            raise SampleIteratorError("{} is not a valid function for {}."
                                            .format(function, self.__name__))

        # FIX: ELIMINATE WHEN UPGRADING TO PYTHON 3.5.2 OR 3.6, (AND USING ONE OF THE TYPE VERSIONS COMMENTED OUT ABOVE)
        # Validate entries of specification
        #
        self.start = start
        self.stop = stop
        self.step = step
        self.num = num
        self.function = function

        # Restore global precision
        getcontext().prec = _global_precision

    def __str__(self):
        return self.__repr__()

    def __repr__(self):
        params_list = ['start', 'stop', 'step', 'num', 'function', 'custom_spec']
        params_str = ", ".join([f"{k}={repr(getattr(self, k))}" for k in params_list if getattr(self, k) is not None])
        return f"SampleSpec({params_str})"


allowable_specs = (tuple, list, np.array, range, np.arange, callable, SampleSpec)
def is_sample_spec(spec):
    if spec is None or type(spec) in allowable_specs:
        return True
    return False


class SampleIterator(Iterator):
    """
    SampleIterator(               \
    specification                 \
    )

    Create an iterator that returns the next sample from a sequence on each call to `next <SampleIterator.__next__>`.
    (e.g., when next(<SampleIterator>) is called)

    The pattern of the sequence depends on the **specification**, which may be a list, nparray, range,
    function, or a SampleSpec. Most of the patterns depend on the "current_step," which is incremented on each
    iteration, and set to zero when the iterator is reset.

    +--------------------------------+-------------------------------------------+------------------------------------+
    | **Specification**              |  **what happens on each iteration**       | **StopIteration condition**        |
    +--------------------------------+-------------------------------------------+------------------------------------+
    | list, nparray                  | look up the item with index current_step  | list/array                         |
    +--------------------------------+-------------------------------------------+------------------------------------+
    | range, np.arange               | start + step*current_step                 | range stop value is reached        |
    +--------------------------------+-------------------------------------------+------------------------------------+
    | callable                       | call callable                             | iteration does not stop            |
    +--------------------------------+-------------------------------------------+------------------------------------+
    | SampleSpec(start, stop, step)  | start + step*current_step                 | current_step = num or value > stop |
    +--------------------------------+-------------------------------------------+------------------------------------+
    | SampleSpec(start, stop, num)   | start + step*current_step                 | current_step = num or value > stop |
    +--------------------------------+-------------------------------------------+------------------------------------+
    | SampleSpec(function, num)      | call function                             | current_step = num                 |
    +--------------------------------+-------------------------------------------+------------------------------------+
    | SampleSpec(function)           | call function                             | iteration does not stop            |
    +--------------------------------+-------------------------------------------+------------------------------------+

    .. note::
        We recommend reserving the list/nparray option for cases in which the samples do not have a pattern that can be
        represented by a SampleSpec, or the number of samples is small. The list/nparray option requires all of the
        samples to be stored and looked up, while the SampleSpec options generate samples as needed.

    """

    def __init__(self,
                 specification):
        """

        Arguments
        ---------

        specification : list, array, range, callable or SampleSpec
            specifies what to use for `generate_current_value <SampleIterator.generate_current_value>`.

        Attributes
        ----------

        start : scalar or None
            first sample in the sequence, or None

        stop : scalar or None
            last sample in the sequence, or None

        step : scalar
            space between samples in the sequence, or None

        num : int or None
            number of values returned before the iterator stops. If None, the iterator may be called indefinitely.

        current_step : int
            number of current iteration

        specification :  list, np.array, range, np.arange, callable, SampleSpec
            original argument provided in constructor;
            useful for passing application-specific forms of specification directly to receiver of SampleIterator.

        Returns
        -------

        List(self) : list
        """

        # FIX: DEAL WITH head?? OR SIMPLY USE CURRENT_STEP?
        # FIX Are nparrays allowed? Below assumes one list dimension. How to handle nested arrays/lists?
        self.specification = specification

        if isinstance(specification, (tuple, range)):
            specification = list(specification)

        elif callable(specification):
            if isclass(specification):
                specification = specification()
            _validate_function(self, specification)

            specification = SampleSpec(function=specification)

        elif isinstance(specification, np.ndarray):
            specification = specification.tolist()

        if isinstance(specification, list):
            self.start = specification[0]
            self.stop = None
            self.step = None
            self.num = len(specification)
            self.generator = specification                       # the list

            def generate_current_value():                        # index into the list
                # KDM 12/11/19: for currently unknown and unreplicable
                # reasons, the checks in __next__ will fail to ensure
                # that self.current_step is less than the length of
                # self.generator, and an IndexError will be thrown
                # occurs in tests/log/test_log.py::TestFiltering
                # and tests/models/test_greedy_agent.py due to
                # GridSearch use
                try:
                    return self.generator[self.current_step]
                except IndexError:
                    raise StopIteration

        elif isinstance(specification, SampleSpec):

            if specification.custom_spec:
                # Assumes receiver of SampleIterator will get this and know what to do with it,
                #   therefore no other attributes are needed and, to avoid confusion, they should not be available;
                #   so just return.
                return

            if specification.function is None:
                self.start = specification.start
                self.stop = specification.stop
                # self.step = Fraction(specification.step)
                self.step = specification.step
                self.num = specification.num
                self.generator = None                    # ??

                def generate_current_value():   # return next value in range
                    # Save global precision for later restoration
                    _global_precision = getcontext().prec
                    # Set SampleSpec precision
                    getcontext().prec = specification._precision
                    return_value = float(Decimal(self.start) + Decimal(self.step) * Decimal(self.current_step))
                    # Restore global precision
                    getcontext().prec = _global_precision
                    return return_value

            elif callable(specification.function):
                self.start = 0
                self.stop = None
                self.step = 1
                self.current_step = 0
                self.num = specification.num
                self.head = self.start
                self.generator = specification.function

                def generate_current_value():  # call function
                    return self.generator()

            else:
                assert False, 'PROGRAM ERROR: {} item of {} passed to specification arg of {} ' \
                              'is not an iterator or a function_type'.\
                              format(repr('function'), SampleSpec.__name__, self.__class__.__name__)

        else:
            assert False, 'PROGRAM ERROR: {} argument of {} must be one of the following: {}'.\
                          format(repr('specification'), self.__class__.__name__,
                                 (', ').join([i.__name__ for i in allowable_specs]))

        self.current_step = 0
        self.head = self.start
        self.generate_current_value = generate_current_value

    def __next__(self):
        """

        :return:
        Sample value for the current iteration.
        """
        if self.num is None:
            current_value = self.generate_current_value()
            if hasattr(self, 'stop'):
                if self.stop is not None:
                    if current_value <= self.stop:
                        return current_value
                    else:
                        raise StopIteration
            return current_value
        if self.current_step < self.num:
            current_value = self.generate_current_value()
            self.current_step += 1
            if hasattr(self, 'stop'):
                if self.stop is not None:
                    if current_value <= self.stop:
                        return current_value
                    else:
                        raise StopIteration
            return current_value

        else:
            raise StopIteration

    def __iter__(self):
        self.current_step = 0
        return self

    def __call__(self):
        return list(self)

    def reset(self, head=None):
        """Reset iterator to a specified item
        If called with None, resets to first item (if `generator <SampleIterators.generator>` is a list or
        deterministic function.
        """

        self.current_step = 0
        self.head = head or self.start

    def __repr__(self):
        return '{}({})'.format(self.__class__.__name__, self.specification)

1	#
2	# Princeton University licenses this file to You under the Apache License, Version 2.0 (the "License");
3	# you may not use this file except in compliance with the License. You may obtain a copy of the License at:
4	# http://www.apache.org/licenses/LICENSE-2.0
5	# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
6	# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
7	# See the License for the specific language governing permissions and limitations under the License.
8	#
9	#
10	# ***************************************** SAMPLER CLASSES ******************************************************
11	"""	1✔
12
13	* `SampleSpec`
14	* `SampleIterator`
15
16	"""
17
18	from collections.abc import Iterator	1✔
19	from decimal import Decimal, getcontext	1✔
20	from inspect import isclass	1✔
21	from numbers import Number	1✔
22
23	import numpy as np	1✔
24	from beartype import beartype	1✔
25
26	from psyneulink._typing import Optional, Union, Callable	1✔
27
28	__all__ = ['SampleSpec', 'SampleIterator']	1✔
29
30
31	# Number of decimal places used to set precision of decimal module
32	SAMPLE_SPEC_PRECISION = 16	1✔
33
34
35	def _validate_function(source, function):	1✔
36	"""Ensure function specification is appropriate for SampleIterator"""
37	source_name = source.__class__.__name__	1✔
38	try:	1✔
39	result = function()	1✔
40	except:	×
41	raise SampleIteratorError("Specification of function for {} ({}) could not be called as a function".
42	format(source_name, function.__class__.__name__))
43	if result is None:	1✔
44	raise SampleIteratorError("Function specified for {} ({}) does not return a result)".
45	format(source_name, repr(function)))
46	if not isinstance(result, Number):	1✔
47	raise SampleIteratorError("Function specified for {} ({}) does not return a number)".
48	format(source_name, repr(function)))
49
50
51	class SampleIteratorError(Exception):	1✔
52	def __init__(self, error_value):	1✔
53	self.error_value = error_value	1✔
54
55
56	class SampleSpec:	1✔
57	"""
58	SampleSpec( \
59	start=None, \
60	stop=None, \
61	step=None, \
62	num=None, \
63	function=None \
64	precision=None \
65	custom_spec=None \
66	)
67
68	Specify the information needed to create a SampleIterator that will either (1) generate discrete values in a range;
69	(2) call a function can generate continous values within the range; (3) pass a custom spec to SampleIterator
70
71	(1) Generate values in a range by explicitly specifying a finite regular sequence of values, using an appropriate
72	combination of the start, stop, step and/or numarguments.
73
74	* if start, stop, and step are specified, the behavior is similar to `Numpy's arange
75	<https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.arange.html>`_. Calling
76	`next <SampleIterator.__next__>`first returns start. Each subsequent call to next returns
77	start :math:`+` step :math:`*` current_step.
78	Iteration stops when the current value exceeds the stop value. If any of the specified arguments are
79	floats, precision determines the number of decimal places used for rounding to ensure num is a int.
80
81	* if start, stop, and num are specified, the behavior is similar to `Numpy's linspace
82	<https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.linspace.html>`_. Calling
83	`next <SampleIterator.__next__>` first returns start. Each subsequent call to next returns
84	start :math:`+` step :math:`*` current_step, where step is set to :math:`\\frac{stop-start)}{num - 1}`.
85	Iteration stops when num is reached, or the current value exceeds the stop value.
86
87	* if start, *stop, step, and num are all specified, then step and num must be compatible.
88
89	(2) Specify a function, that is called repeatedly to generate a sequence of values.
90
91	* if num is specified, the function is called once on each iteration until num iterations are
92	complete.
93
94	* if num is not specified, the function is called once on each iteration, and iteration may continue
95	indefinitely.
96
97	(3) Specify a custom_spec, that is passed to SampleIterator unmodified.
98
99	* this is useful if the receiver of the SampleIterator uses a custom format or external functions to generate
100	samples; the format must, of course, be one expected by the receiver.
101
102	.. note::
103	* Some OptimizationFunctions may require that their SampleIterators have a "num" attribute.
104	* The Python decimal module is used to implement precision for rounding.
105
106
107	Arguments
108	---------
109
110	start : int or float
111	first sample in the sequence.
112
113	stop : int or float
114	maximum value of last sample in the sequence.
115
116	step : int or float
117	space between samples in sequence.
118
119	num : int
120	number of samples.
121
122	function : function or function class
123	function to be called on each iteration. Must return one sample each time it is called.
124
125	precision : int default 16
126	number of decimal places used for rounding in floating point operations.
127
128	custom_spec : anything
129
130	Attributes
131	----------
132
133	start : float
134	first sample in the sequence.
135
136	stop : float
137	maximum value of last sample in the sequence.
138
139	step : float
140	space between samples in sequence.
141
142	num : int
143	number of samples.
144
145	function : function
146	Function to be called on each iteration. Must return one sample.
147
148	custom_spec : anything
149	specification in a format recognized by receiver of SampleIterator.
150
151	"""
152
153	@beartype	1✔
154	def __init__(self,	1✔
155	start: Optional[Union[int, float]] = None,
156	stop: Optional[Union[int, float]] = None,
157	step: Optional[Union[int, float]] = None,
158	num: Optional[int] = None,
159	function: Optional[Callable] = None,
160	precision: Optional[int] = None,
161	custom_spec=None
162	):
163
164	self.custom_spec = custom_spec	1✔
165
166	if self.custom_spec:	1!
167	# Assumes receiver of SampleIterator will get this and know what to do with it,
168	# therefore no other attributes are needed and, to avoid confusion, they should not be available;
169	# so just assign and return.
170	return	×
171
172	self._precision = precision or SAMPLE_SPEC_PRECISION	1✔
173	# Save global precision for later restoration
174	_global_precision = getcontext().prec	1✔
175	# Set SampleSpec precision
176	getcontext().prec = self._precision	1✔
177
178	if function is None:	1✔
179	if start is None or stop is None:	1✔
180	raise SampleIteratorError("If 'function' is not specified, then 'start' and 'stop' must be "
181	"specified.")
182	if num is None and step is not None:	1✔
183	num = int(Decimal(1.0) + Decimal(stop - start) / Decimal(step))	1✔
184	# num = 1.0 + (stop - start) / step
185	elif step is None and num is not None:	1✔
186	step = (Decimal(stop) - Decimal(start)) / (num - 1)	1✔
187	elif num is None and step is None:	1✔
188	raise SampleIteratorError("Must specify one of {}, {} or {}."
189	.format(repr('step'), repr('num'), repr('function')))
190	else:
191	if not np.isclose(num, 1.0 + (stop - start) / step):	×
192	raise SampleIteratorError("The {} ({}) and {} ({}) values specified are not comaptible."
193	.format(repr('step'), step, repr('num'), num))
194
195	elif callable(function):	1✔
196	_validate_function(self, function)	1✔
197
198	if start is not None:	1✔
199	raise SampleIteratorError("Only one of {} ({}) and {} ({}) may be specified."
200	.format(repr('start'), start, repr('function'), function))
201	if step is not None:	1✔
202	raise SampleIteratorError("Only one of {} ({}) and {} ({}) may be specified."
203	.format(repr('step'), step, repr('function'), function))
204	else:
205	raise SampleIteratorError("{} is not a valid function for {}."
206	.format(function, self.__name__))
207
208	# FIX: ELIMINATE WHEN UPGRADING TO PYTHON 3.5.2 OR 3.6, (AND USING ONE OF THE TYPE VERSIONS COMMENTED OUT ABOVE)
209	# Validate entries of specification
210	#
211	self.start = start	1✔
212	self.stop = stop	1✔
213	self.step = step	1✔
214	self.num = num	1✔
215	self.function = function	1✔
216
217	# Restore global precision
218	getcontext().prec = _global_precision	1✔
219
220	def __str__(self):	1✔
UNCOV 221	return self.__repr__()	×
222
223	def __repr__(self):
224	params_list = ['start', 'stop', 'step', 'num', 'function', 'custom_spec']
225	params_str = ", ".join([f"{k}={repr(getattr(self, k))}" for k in params_list if getattr(self, k) is not None])
226	return f"SampleSpec({params_str})"
227
228
229	allowable_specs = (tuple, list, np.array, range, np.arange, callable, SampleSpec)	1✔
230	def is_sample_spec(spec):	1✔
231	if spec is None or type(spec) in allowable_specs:	1!
232	return True	1✔
233	return False	×
234
235
236	class SampleIterator(Iterator):	1✔
237	"""
238	SampleIterator( \
239	specification \
240	)
241
242	Create an iterator that returns the next sample from a sequence on each call to `next <SampleIterator.__next__>`.
243	(e.g., when next(<SampleIterator>) is called)
244
245	The pattern of the sequence depends on the specification, which may be a list, nparray, range,
246	function, or a SampleSpec. Most of the patterns depend on the "current_step," which is incremented on each
247	iteration, and set to zero when the iterator is reset.
248
249	+--------------------------------+-------------------------------------------+------------------------------------+
250	\| Specification \| what happens on each iteration \| StopIteration condition \|
251	+--------------------------------+-------------------------------------------+------------------------------------+
252	\| list, nparray \| look up the item with index current_step \| list/array \|
253	+--------------------------------+-------------------------------------------+------------------------------------+
254	\| range, np.arange \| start + step*current_step \| range stop value is reached \|
255	+--------------------------------+-------------------------------------------+------------------------------------+
256	\| callable \| call callable \| iteration does not stop \|
257	+--------------------------------+-------------------------------------------+------------------------------------+
258	\| SampleSpec(start, stop, step) \| start + step*current_step \| current_step = num or value > stop \|
259	+--------------------------------+-------------------------------------------+------------------------------------+
260	\| SampleSpec(start, stop, num) \| start + step*current_step \| current_step = num or value > stop \|
261	+--------------------------------+-------------------------------------------+------------------------------------+
262	\| SampleSpec(function, num) \| call function \| current_step = num \|
263	+--------------------------------+-------------------------------------------+------------------------------------+
264	\| SampleSpec(function) \| call function \| iteration does not stop \|
265	+--------------------------------+-------------------------------------------+------------------------------------+
266
267	.. note::
268	We recommend reserving the list/nparray option for cases in which the samples do not have a pattern that can be
269	represented by a SampleSpec, or the number of samples is small. The list/nparray option requires all of the
270	samples to be stored and looked up, while the SampleSpec options generate samples as needed.
271
272	"""
273
274	def __init__(self,	1✔
275	specification):
276	"""
277
278	Arguments
279	---------
280
281	specification : list, array, range, callable or SampleSpec
282	specifies what to use for `generate_current_value <SampleIterator.generate_current_value>`.
283
284	Attributes
285	----------
286
287	start : scalar or None
288	first sample in the sequence, or None
289
290	stop : scalar or None
291	last sample in the sequence, or None
292
293	step : scalar
294	space between samples in the sequence, or None
295
296	num : int or None
297	number of values returned before the iterator stops. If None, the iterator may be called indefinitely.
298
299	current_step : int
300	number of current iteration
301
302	specification : list, np.array, range, np.arange, callable, SampleSpec
303	original argument provided in constructor;
304	useful for passing application-specific forms of specification directly to receiver of SampleIterator.
305
306	Returns
307	-------
308
309	List(self) : list
310	"""
311
312	# FIX: DEAL WITH head?? OR SIMPLY USE CURRENT_STEP?
313	# FIX Are nparrays allowed? Below assumes one list dimension. How to handle nested arrays/lists?
314	self.specification = specification	1✔
315
316	if isinstance(specification, (tuple, range)):	1✔
317	specification = list(specification)	1✔
318
319	elif callable(specification):	1!
320	if isclass(specification):	×
321	specification = specification()	×
322	_validate_function(self, specification)	×
323
324	specification = SampleSpec(function=specification)	×
325
326	elif isinstance(specification, np.ndarray):	1✔
327	specification = specification.tolist()	1✔
328
329	if isinstance(specification, list):	1✔
330	self.start = specification[0]	1✔
331	self.stop = None	1✔
332	self.step = None	1✔
333	self.num = len(specification)	1✔
334	self.generator = specification # the list	1✔
335
336	def generate_current_value(): # index into the list	1✔
337	# KDM 12/11/19: for currently unknown and unreplicable
338	# reasons, the checks in __next__ will fail to ensure
339	# that self.current_step is less than the length of
340	# self.generator, and an IndexError will be thrown
341	# occurs in tests/log/test_log.py::TestFiltering
342	# and tests/models/test_greedy_agent.py due to
343	# GridSearch use
344	try:	1✔
345	return self.generator[self.current_step]	1✔
346	except IndexError:	×
347	raise StopIteration	×
348
349	elif isinstance(specification, SampleSpec):	1✔
350
351	if specification.custom_spec:	1!
352	# Assumes receiver of SampleIterator will get this and know what to do with it,
353	# therefore no other attributes are needed and, to avoid confusion, they should not be available;
354	# so just return.
355	return	×
356
357	if specification.function is None:	1✔
358	self.start = specification.start	1✔
359	self.stop = specification.stop	1✔
360	# self.step = Fraction(specification.step)
361	self.step = specification.step	1✔
362	self.num = specification.num	1✔
363	self.generator = None # ??	1✔
364
365	def generate_current_value(): # return next value in range	1✔
366	# Save global precision for later restoration
367	_global_precision = getcontext().prec	1✔
368	# Set SampleSpec precision
369	getcontext().prec = specification._precision	1✔
370	return_value = float(Decimal(self.start) + Decimal(self.step) * Decimal(self.current_step))	1✔
371	# Restore global precision
372	getcontext().prec = _global_precision	1✔
373	return return_value	1✔
374
375	elif callable(specification.function):	1✔
376	self.start = 0	1✔
377	self.stop = None	1✔
378	self.step = 1	1✔
379	self.current_step = 0	1✔
380	self.num = specification.num	1✔
381	self.head = self.start	1✔
382	self.generator = specification.function	1✔
383
384	def generate_current_value(): # call function	1✔
385	return self.generator()	1✔
386
387	else:
388	assert False, 'PROGRAM ERROR: {} item of {} passed to specification arg of {} ' \
389	'is not an iterator or a function_type'.\
390	format(repr('function'), SampleSpec.__name__, self.__class__.__name__)
391
392	else:
393	assert False, 'PROGRAM ERROR: {} argument of {} must be one of the following: {}'.\
394	format(repr('specification'), self.__class__.__name__,
395	(', ').join([i.__name__ for i in allowable_specs]))
396
397	self.current_step = 0	1✔
398	self.head = self.start	1✔
399	self.generate_current_value = generate_current_value	1✔
400
401	def __next__(self):	1✔
402	"""
403
404	:return:
405	Sample value for the current iteration.
406	"""
407	if self.num is None:	1✔
408	current_value = self.generate_current_value()	1✔
409	if hasattr(self, 'stop'):	1!
410	if self.stop is not None:	1!
411	if current_value <= self.stop:	×
412	return current_value	×
413	else:
414	raise StopIteration	×
415	return current_value	1✔
416	if self.current_step < self.num:	1✔
417	current_value = self.generate_current_value()	1✔
418	self.current_step += 1	1✔
419	if hasattr(self, 'stop'):	1!
420	if self.stop is not None:	1✔
421	if current_value <= self.stop:	1!
422	return current_value	1✔
423	else:
424	raise StopIteration	×
425	return current_value	1✔
426
427	else:
428	raise StopIteration	1✔
429
430	def __iter__(self):	1✔
431	self.current_step = 0	1✔
432	return self	1✔
433
434	def __call__(self):	1✔
435	return list(self)	1✔
436
437	def reset(self, head=None):	1✔
438	"""Reset iterator to a specified item
439	If called with None, resets to first item (if `generator <SampleIterators.generator>` is a list or
440	deterministic function.
441	"""
442
443	self.current_step = 0	1✔
444	self.head = head or self.start	1✔
445
446	def __repr__(self):
447	return '{}({})'.format(self.__class__.__name__, self.specification)

PrincetonUniversity / PsyNeuLink / 8711265480

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