8856691984

Committed 02 Feb 2024 10:56PM UTC coverage: 84.919% (+0.06%) from 84.858%

Build # 8856691984

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2897 from PrincetonUniversity/devel

Devel

Run Details

13477 of 16607 branches covered (81.15%)

Branch coverage included in aggregate %.

52 of 55 new or added lines in 14 files covered. (94.55%)

28 existing lines in 6 files now uncovered.

31547 of 36413 relevant lines covered (86.64%)

0.87 hits per line

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

80.31

/psyneulink/core/scheduling/scheduler.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.


# ********************************************* Scheduler **************************************************************
import copy
import logging
import typing
from typing import Hashable

import graph_scheduler
import pint

import psyneulink as pnl
from psyneulink import _unit_registry
from psyneulink.core.globals.context import Context, handle_external_context
from psyneulink.core.globals.mdf import MDFSerializable
from psyneulink.core.globals.utilities import parse_valid_identifier
from psyneulink.core.scheduling.condition import _create_as_pnl_condition, graph_structure_conditions_available, gsc_unavailable_message

__all__ = [
    'Scheduler', 'SchedulingMode'
]


logger = logging.getLogger(__name__)
SchedulingMode = graph_scheduler.scheduler.SchedulingMode


class Scheduler(graph_scheduler.Scheduler, MDFSerializable):
    def __init__(
        self,
        composition=None,
        graph=None,
        conditions=None,
        termination_conds=None,
        default_execution_id=None,
        mode: SchedulingMode = SchedulingMode.STANDARD,
        default_absolute_time_unit: typing.Union[str, pint.Quantity] = 1 * _unit_registry.ms,
        **kwargs
    ):
        """
        :param composition: (Composition) - the Composition this scheduler is scheduling for
        """

        if composition is not None:
            # dependency dict
            graph = composition.graph_processing.prune_feedback_edges()[0]
            if default_execution_id is None:
                default_execution_id = composition.default_execution_id
            self.composition = composition

        # TODO: consider integrating something like this into graph-scheduler?
        self._user_specified_conds = graph_scheduler.ConditionSet()
        if conditions is not None:
            self._user_specified_conds.add_condition_set(copy.copy(conditions))
        self._user_specified_termination_conds = copy.copy(termination_conds) if termination_conds is not None else {}

        super().__init__(
            graph=graph,
            conditions=conditions,
            termination_conds=termination_conds,
            default_execution_id=default_execution_id,
            mode=mode,
            default_absolute_time_unit=default_absolute_time_unit,
            **kwargs,
        )

        def replace_term_conds(term_conds):
            return {
                ts: _create_as_pnl_condition(cond) for ts, cond in term_conds.items()
            }

        self.default_termination_conds = replace_term_conds(self.default_termination_conds)
        self.termination_conds = replace_term_conds(self.termination_conds)

    def _validate_conditions(self):
        unspecified_nodes = []

        # pre-graph-structure-condition compatibility
        try:
            conditions_basic = self.conditions.conditions_basic
        except AttributeError:
            conditions_basic = self.conditions.conditions

        for node in self.nodes:
            if node not in conditions_basic:
                dependencies = list(self.dependency_dict[node])
                if len(dependencies) == 0:
                    cond = graph_scheduler.Always()
                elif len(dependencies) == 1:
                    cond = graph_scheduler.EveryNCalls(dependencies[0], 1)
                else:
                    cond = graph_scheduler.All(*[graph_scheduler.EveryNCalls(x, 1) for x in dependencies])

                # TODO: replace this call in graph-scheduler if adding _user_specified_conds
                self._add_condition(node, cond)
                unspecified_nodes.append(node)

        super()._validate_conditions()

    def add_condition(self, owner, condition):
        self._user_specified_conds.add_condition(owner, condition)
        self._add_condition(owner, condition)

    def _add_condition(self, owner, condition):
        condition = _create_as_pnl_condition(condition)
        super().add_condition(owner, condition)

        if graph_structure_conditions_available:
            if isinstance(condition, pnl.GraphStructureCondition):
                self.composition._analyze_graph()

    def add_condition_set(self, conditions):
        self._user_specified_conds.add_condition_set(conditions)
        self._add_condition_set(conditions)

    def _add_condition_set(self, conditions):
        conditions = {
            node: _create_as_pnl_condition(conditions[node])
            for node in conditions
        }
        super().add_condition_set(conditions)

    def remove_condition(self, owner_or_condition):
        try:
            res = super().remove_condition(owner_or_condition)
        except AttributeError as e:
            if "has no attribute 'remove_condition'" in str(e):
                raise graph_scheduler.SchedulerError(
                    f'remove_condition unavailable in your installed graph-scheduler v{graph_scheduler.__version__}'
                )
            else:
                raise
        else:
            if isinstance(res, pnl.GraphStructureCondition):
                self.composition._analyze_graph()

        return res

    @graph_scheduler.Scheduler.termination_conds.setter
    def termination_conds(self, termination_conds):
        if termination_conds is not None:
            self._user_specified_termination_conds.update(termination_conds)

        graph_scheduler.Scheduler.termination_conds.fset(self, termination_conds)

    @handle_external_context(fallback_default=True)
    def run(
        self,
        termination_conds=None,
        context=None,
        base_context=Context(execution_id=None),
        skip_trial_time_increment=False,
    ):
        yield from super().run(
            termination_conds=termination_conds,
            context=context,
            execution_id=context.execution_id,
            base_execution_id=base_context.execution_id,
            skip_environment_state_update_time_increment=skip_trial_time_increment,
        )

    def as_mdf_model(self):
        import modeci_mdf.mdf as mdf

        return mdf.ConditionSet(
            node_specific={
                parse_valid_identifier(n.name): self.conditions[n].as_mdf_model() for n in self.nodes if n in self.conditions
            },
            termination={
                str.lower(k.name): v.as_mdf_model() for k, v in self.termination_conds.items()
            },
        )

    @handle_external_context()
    def get_clock(self, context):
        return super().get_clock(context.execution_id)

    def add_graph_edge(self, sender: Hashable, receiver: Hashable) -> 'pnl.AddEdgeTo':
        if not graph_structure_conditions_available:
            raise graph_scheduler.SchedulerError(gsc_unavailable_message)

        cond = pnl.AddEdgeTo(receiver)
        self.add_condition(sender, cond)
        return cond

    def remove_graph_edge(self, sender: Hashable, receiver: Hashable) -> 'pnl.RemoveEdgeFrom':
        if not graph_structure_conditions_available:
            raise graph_scheduler.SchedulerError(gsc_unavailable_message)

        cond = pnl.RemoveEdgeFrom(sender)
        self.add_condition(receiver, cond)
        return cond


_doc_subs = {
    None: [
        (
            '(When creating a Scheduler explicitly, the set of nodes)',
            'A Scheduler can be created explicitly using its constructor.  However, more commonly it is created automatically for a `Composition <Composition>` when it is created.\\1',
        ),

        (
            r'(\n\* a \*graph specification dictionary\* in the \*\*graph\*\* argument)',
            "\n* a `Composition` in the **composition** argument - if a Composition is specified, the Scheduler is created using the nodes and edges in the Composition's `graph <Composition.graph_processing>`, with any `feedback Projections <Composition_Feedback>` pruned as needed to produce an acyclic graph. If there is a cycle comprised of all non-feedback projections, this cycle is reduced to a single `consideration set <consideration_set>`\n\\1",
        ),

        ('origin nodes', '`ORIGIN` nodes',),

        (
            r'Examples\n--------.*\n\.\. _Scheduler_Class_Reference',
            """
Examples
--------

Please see `Condition` for a list of all supported Conditions and their behavior.

* Basic phasing in a linear process::

    >>> import psyneulink as pnl

    >>> A = pnl.TransferMechanism(name='A')
    >>> B = pnl.TransferMechanism(name='B')
    >>> C = pnl.TransferMechanism(name='C')

    >>> comp = pnl.Composition()

    >>> pway = comp.add_linear_processing_pathway([A, B, C])
    >>> pway.pathway
    [(TransferMechanism A), (MappingProjection MappingProjection from A[RESULT] to B[InputPort-0]), (TransferMechanism B), (MappingProjection MappingProjection from B[RESULT] to C[InputPort-0]), (TransferMechanism C)]

    >>> # implicit condition of Always for A
    >>> comp.scheduler.add_condition(B, pnl.EveryNCalls(A, 2))
    >>> comp.scheduler.add_condition(C, pnl.EveryNCalls(B, 3))

    >>> # implicit AllHaveRun Termination condition
    >>> execution_sequence = list(comp.scheduler.run())
    >>> execution_sequence
    [{(TransferMechanism A)}, {(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism A)}, {(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism A)}, {(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism C)}]

* Alternate basic phasing in a linear process::

    >>> comp = pnl.Composition()
    >>> pway = comp.add_linear_processing_pathway([A, B])
    >>> pway.pathway
    [(TransferMechanism A), (MappingProjection MappingProjection from A[RESULT] to B[InputPort-0]), (TransferMechanism B)]

    >>> comp.scheduler.add_condition(
    ...     A,
    ...     pnl.Any(
    ...         pnl.AtPass(0),
    ...         pnl.EveryNCalls(B, 2)
    ...     )
    ... )

    >>> comp.scheduler.add_condition(
    ...     B,
    ...     pnl.Any(
    ...         pnl.EveryNCalls(A, 1),
    ...         pnl.EveryNCalls(B, 1)
    ...     )
    ... )
    >>> termination_conds = {
    ...     pnl.TimeScale.TRIAL: pnl.AfterNCalls(B, 4, time_scale=pnl.TimeScale.TRIAL)
    ... }
    >>> execution_sequence = list(comp.scheduler.run(termination_conds=termination_conds))
    >>> execution_sequence # doctest: +SKIP
    [{(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism B)}, {(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism B)}]

* Basic phasing in two processes::

    >>> comp = pnl.Composition()
    >>> pway = comp.add_linear_processing_pathway([A, C])
    >>> pway.pathway
    [(TransferMechanism A), (MappingProjection MappingProjection from A[RESULT] to C[InputPort-0]), (TransferMechanism C)]

    >>> pway = comp.add_linear_processing_pathway([B, C])
    >>> pway.pathway
    [(TransferMechanism B), (MappingProjection MappingProjection from B[RESULT] to C[InputPort-0]), (TransferMechanism C)]

    >>> comp.scheduler.add_condition(A, pnl.EveryNPasses(1))
    >>> comp.scheduler.add_condition(B, pnl.EveryNCalls(A, 2))
    >>> comp.scheduler.add_condition(
    ...     C,
    ...     pnl.Any(
    ...         pnl.AfterNCalls(A, 3),
    ...         pnl.AfterNCalls(B, 3)
    ...     )
    ... )
    >>> termination_conds = {
    ...     pnl.TimeScale.TRIAL: pnl.AfterNCalls(C, 4, time_scale=pnl.TimeScale.TRIAL)
    ... }
    >>> execution_sequence = list(comp.scheduler.run(termination_conds=termination_conds))
    >>> execution_sequence  # doctest: +SKIP
    [{(TransferMechanism A)}, {(TransferMechanism A), (TransferMechanism B)}, {(TransferMechanism A)}, {(TransferMechanism C)}, {(TransferMechanism A), (TransferMechanism B)}, {(TransferMechanism C)}, {(TransferMechanism A)}, {(TransferMechanism C)}, {(TransferMechanism A), (TransferMechanism B)}, {(TransferMechanism C)}]

.. _Scheduler_Class_Reference
"""
        ),

        (
            r'linear graph with two nodes.*In standard mode',
            """linear composition with two nodes::

    >>> import psyneulink as pnl

    >>> A = pnl.TransferMechanism()
    >>> B = pnl.TransferMechanism()

    >>> comp = pnl.Composition()
    >>> pway = comp.add_linear_processing_pathway([A, B])

    >>> comp.scheduler.add_condition(A, pnl.TimeInterval(start=10))
    >>> comp.scheduler.add_condition(B, pnl.TimeInterval(start=10))

In standard mode"""
        ),

        (
            r'(earlier or later \(e\.g\., when the Condition\nfor a particular node or set of nodes is met\)\.)',
            '\\1 When the Scheduler terminates a `TRIAL <TimeScale.TRIAL>`, the `Composition <Composition>` begins processing the next input specified in the call to its `run <Composition.run>` method. Thus, a `TRIAL <TimeScale.TRIAL>` is defined as the scope of processing associated with a given input to the Composition.'
        ),

        (
            '(is when all of its constituent environment state updates have terminated.)',
            """\\1 These defaults may be overriden when running a Composition, by passing a dictionary mapping `TimeScales <TimeScale>` to `Conditions <Condition>` in the **termination_processing** argument of a call to `Composition.run` (to terminate the execution of processing)::

    Composition.run(
        ...,
        termination_processing={TimeScale.TRIAL: WhenFinished(ddm)}
        )
"""
        ),

        (
            r'(however, using the `indices in the original consideration queue<.*?\.Scheduler\.consideration_queue_indices>`\.)',
            '\\1 `Composition`\\ s will execute nodes in this order, however independent usages of the scheduler may not. The user should be aware of this and set up defaults and inputs to nodes accordingly.'
        ),
    ],
    'Scheduler': [
        (
            r'(Arguments\n    ---------\n)',
            """\\1
    composition : Composition
        specifies the `Components <Component>` to be ordered for execution, and any dependencies among them,
        based on the `Composition <Composition>`\\'s `graph <Composition.graph_processing>`.
"""
        )
    ]
}

1	# Princeton University licenses this file to You under the Apache License, Version 2.0 (the "License");
2	# you may not use this file except in compliance with the License. You may obtain a copy of the License at:
3	# http://www.apache.org/licenses/LICENSE-2.0
4	# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
5	# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6	# See the License for the specific language governing permissions and limitations under the License.
7
8
9	# ******************************************* Scheduler ************************************************************
10	import copy	1✔
11	import logging	1✔
12	import typing	1✔
13	from typing import Hashable	1✔
14
15	import graph_scheduler	1✔
16	import pint	1✔
17
18	import psyneulink as pnl	1✔
19	from psyneulink import _unit_registry	1✔
20	from psyneulink.core.globals.context import Context, handle_external_context	1✔
21	from psyneulink.core.globals.mdf import MDFSerializable	1✔
22	from psyneulink.core.globals.utilities import parse_valid_identifier	1✔
23	from psyneulink.core.scheduling.condition import _create_as_pnl_condition, graph_structure_conditions_available, gsc_unavailable_message	1✔
24
25	__all__ = [	1✔
26	'Scheduler', 'SchedulingMode'
27	]
28
29
30	logger = logging.getLogger(__name__)	1✔
31	SchedulingMode = graph_scheduler.scheduler.SchedulingMode	1✔
32
33
34	class Scheduler(graph_scheduler.Scheduler, MDFSerializable):	1✔
35	def __init__(	1✔
36	self,
37	composition=None,
38	graph=None,
39	conditions=None,
40	termination_conds=None,
41	default_execution_id=None,
42	mode: SchedulingMode = SchedulingMode.STANDARD,
43	default_absolute_time_unit: typing.Union[str, pint.Quantity] = 1 * _unit_registry.ms,
44	**kwargs
45	):
46	"""
47	:param composition: (Composition) - the Composition this scheduler is scheduling for
48	"""
49
50	if composition is not None:	1!
51	# dependency dict
52	graph = composition.graph_processing.prune_feedback_edges()[0]	1✔
53	if default_execution_id is None:	1✔
54	default_execution_id = composition.default_execution_id	1✔
55	self.composition = composition	1✔
56
57	# TODO: consider integrating something like this into graph-scheduler?
58	self._user_specified_conds = graph_scheduler.ConditionSet()	1✔
59	if conditions is not None:	1✔
60	self._user_specified_conds.add_condition_set(copy.copy(conditions))	1✔
61	self._user_specified_termination_conds = copy.copy(termination_conds) if termination_conds is not None else {}	1✔
62
63	super().__init__(	1✔
64	graph=graph,
65	conditions=conditions,
66	termination_conds=termination_conds,
67	default_execution_id=default_execution_id,
68	mode=mode,
69	default_absolute_time_unit=default_absolute_time_unit,
70	**kwargs,
71	)
72
73	def replace_term_conds(term_conds):	1✔
74	return {	1✔
75	ts: _create_as_pnl_condition(cond) for ts, cond in term_conds.items()
76	}
77
78	self.default_termination_conds = replace_term_conds(self.default_termination_conds)	1✔
79	self.termination_conds = replace_term_conds(self.termination_conds)	1✔
80
81	def _validate_conditions(self):	1✔
82	unspecified_nodes = []	1✔
83
84	# pre-graph-structure-condition compatibility
85	try:	1✔
86	conditions_basic = self.conditions.conditions_basic	1✔
87	except AttributeError:	1✔
88	conditions_basic = self.conditions.conditions	1✔
89
90	for node in self.nodes:	1✔
91	if node not in conditions_basic:	1✔
92	dependencies = list(self.dependency_dict[node])	1✔
93	if len(dependencies) == 0:	1✔
94	cond = graph_scheduler.Always()	1✔
95	elif len(dependencies) == 1:	1✔
96	cond = graph_scheduler.EveryNCalls(dependencies[0], 1)	1✔
97	else:
98	cond = graph_scheduler.All(*[graph_scheduler.EveryNCalls(x, 1) for x in dependencies])	1✔
99
100	# TODO: replace this call in graph-scheduler if adding _user_specified_conds
101	self._add_condition(node, cond)	1✔
102	unspecified_nodes.append(node)	1✔
103
104	super()._validate_conditions()	1✔
105
106	def add_condition(self, owner, condition):	1✔
107	self._user_specified_conds.add_condition(owner, condition)	1✔
108	self._add_condition(owner, condition)	1✔
109
110	def _add_condition(self, owner, condition):	1✔
111	condition = _create_as_pnl_condition(condition)	1✔
112	super().add_condition(owner, condition)	1✔
113
114	if graph_structure_conditions_available:	1!
UNCOV 115	if isinstance(condition, pnl.GraphStructureCondition):	×
UNCOV 116	self.composition._analyze_graph()	×
117
118	def add_condition_set(self, conditions):	1✔
119	self._user_specified_conds.add_condition_set(conditions)	1✔
120	self._add_condition_set(conditions)	1✔
121
122	def _add_condition_set(self, conditions):	1✔
123	conditions = {	1✔
124	node: _create_as_pnl_condition(conditions[node])
125	for node in conditions
126	}
127	super().add_condition_set(conditions)	1✔
128
129	def remove_condition(self, owner_or_condition):	1✔
130	try:	×
131	res = super().remove_condition(owner_or_condition)	×
132	except AttributeError as e:	×
133	if "has no attribute 'remove_condition'" in str(e):	×
134	raise graph_scheduler.SchedulerError(
135	f'remove_condition unavailable in your installed graph-scheduler v{graph_scheduler.__version__}'
136	)
137	else:
138	raise	×
139	else:
140	if isinstance(res, pnl.GraphStructureCondition):	×
141	self.composition._analyze_graph()	×
142
143	return res	×
144
145	@graph_scheduler.Scheduler.termination_conds.setter	1✔
146	def termination_conds(self, termination_conds):	1✔
147	if termination_conds is not None:	1!
148	self._user_specified_termination_conds.update(termination_conds)	1✔
149
150	graph_scheduler.Scheduler.termination_conds.fset(self, termination_conds)	1✔
151
152	@handle_external_context(fallback_default=True)	1✔
153	def run(	1✔
154	self,
155	termination_conds=None,
156	context=None,
157	base_context=Context(execution_id=None),
158	skip_trial_time_increment=False,
159	):
160	yield from super().run(	1✔
161	termination_conds=termination_conds,
162	context=context,
163	execution_id=context.execution_id,
164	base_execution_id=base_context.execution_id,
165	skip_environment_state_update_time_increment=skip_trial_time_increment,
166	)
167
168	def as_mdf_model(self):	1✔
169	import modeci_mdf.mdf as mdf	1✔
170
171	return mdf.ConditionSet(	1✔
172	node_specific={
173	parse_valid_identifier(n.name): self.conditions[n].as_mdf_model() for n in self.nodes if n in self.conditions
174	},
175	termination={
176	str.lower(k.name): v.as_mdf_model() for k, v in self.termination_conds.items()
177	},
178	)
179
180	@handle_external_context()	1✔
181	def get_clock(self, context):	1✔
182	return super().get_clock(context.execution_id)	1✔
183
184	def add_graph_edge(self, sender: Hashable, receiver: Hashable) -> 'pnl.AddEdgeTo':	1✔
UNCOV 185	if not graph_structure_conditions_available:	×
186	raise graph_scheduler.SchedulerError(gsc_unavailable_message)
187
UNCOV 188	cond = pnl.AddEdgeTo(receiver)	×
UNCOV 189	self.add_condition(sender, cond)	×
UNCOV 190	return cond	×
191
192	def remove_graph_edge(self, sender: Hashable, receiver: Hashable) -> 'pnl.RemoveEdgeFrom':	1✔
UNCOV 193	if not graph_structure_conditions_available:	×
194	raise graph_scheduler.SchedulerError(gsc_unavailable_message)
195
UNCOV 196	cond = pnl.RemoveEdgeFrom(sender)	×
UNCOV 197	self.add_condition(receiver, cond)	×
UNCOV 198	return cond	×
199
200
201	_doc_subs = {	1✔
202	None: [
203	(
204	'(When creating a Scheduler explicitly, the set of nodes)',
205	'A Scheduler can be created explicitly using its constructor. However, more commonly it is created automatically for a `Composition <Composition>` when it is created.\\1',
206	),
207
208	(
209	r'(\n\* a \graph specification dictionary\ in the \\graph\\ argument)',
210	"\n* a `Composition` in the composition argument - if a Composition is specified, the Scheduler is created using the nodes and edges in the Composition's `graph <Composition.graph_processing>`, with any `feedback Projections <Composition_Feedback>` pruned as needed to produce an acyclic graph. If there is a cycle comprised of all non-feedback projections, this cycle is reduced to a single `consideration set <consideration_set>`\n\\1",
211	),
212
213	('origin nodes', '`ORIGIN` nodes',),
214
215	(
216	r'Examples\n--------.*\n\.\. _Scheduler_Class_Reference',
217	"""
218	Examples
219	--------
220
221	Please see `Condition` for a list of all supported Conditions and their behavior.
222
223	* Basic phasing in a linear process::
224
225	>>> import psyneulink as pnl
226
227	>>> A = pnl.TransferMechanism(name='A')
228	>>> B = pnl.TransferMechanism(name='B')
229	>>> C = pnl.TransferMechanism(name='C')
230
231	>>> comp = pnl.Composition()
232
233	>>> pway = comp.add_linear_processing_pathway([A, B, C])
234	>>> pway.pathway
235	[(TransferMechanism A), (MappingProjection MappingProjection from A[RESULT] to B[InputPort-0]), (TransferMechanism B), (MappingProjection MappingProjection from B[RESULT] to C[InputPort-0]), (TransferMechanism C)]
236
237	>>> # implicit condition of Always for A
238	>>> comp.scheduler.add_condition(B, pnl.EveryNCalls(A, 2))
239	>>> comp.scheduler.add_condition(C, pnl.EveryNCalls(B, 3))
240
241	>>> # implicit AllHaveRun Termination condition
242	>>> execution_sequence = list(comp.scheduler.run())
243	>>> execution_sequence
244	[{(TransferMechanism A)}, {(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism A)}, {(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism A)}, {(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism C)}]
245
246	* Alternate basic phasing in a linear process::
247
248	>>> comp = pnl.Composition()
249	>>> pway = comp.add_linear_processing_pathway([A, B])
250	>>> pway.pathway
251	[(TransferMechanism A), (MappingProjection MappingProjection from A[RESULT] to B[InputPort-0]), (TransferMechanism B)]
252
253	>>> comp.scheduler.add_condition(
254	... A,
255	... pnl.Any(
256	... pnl.AtPass(0),
257	... pnl.EveryNCalls(B, 2)
258	... )
259	... )
260
261	>>> comp.scheduler.add_condition(
262	... B,
263	... pnl.Any(
264	... pnl.EveryNCalls(A, 1),
265	... pnl.EveryNCalls(B, 1)
266	... )
267	... )
268	>>> termination_conds = {
269	... pnl.TimeScale.TRIAL: pnl.AfterNCalls(B, 4, time_scale=pnl.TimeScale.TRIAL)
270	... }
271	>>> execution_sequence = list(comp.scheduler.run(termination_conds=termination_conds))
272	>>> execution_sequence # doctest: +SKIP
273	[{(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism B)}, {(TransferMechanism A)}, {(TransferMechanism B)}, {(TransferMechanism B)}]
274
275	* Basic phasing in two processes::
276
277	>>> comp = pnl.Composition()
278	>>> pway = comp.add_linear_processing_pathway([A, C])
279	>>> pway.pathway
280	[(TransferMechanism A), (MappingProjection MappingProjection from A[RESULT] to C[InputPort-0]), (TransferMechanism C)]
281
282	>>> pway = comp.add_linear_processing_pathway([B, C])
283	>>> pway.pathway
284	[(TransferMechanism B), (MappingProjection MappingProjection from B[RESULT] to C[InputPort-0]), (TransferMechanism C)]
285
286	>>> comp.scheduler.add_condition(A, pnl.EveryNPasses(1))
287	>>> comp.scheduler.add_condition(B, pnl.EveryNCalls(A, 2))
288	>>> comp.scheduler.add_condition(
289	... C,
290	... pnl.Any(
291	... pnl.AfterNCalls(A, 3),
292	... pnl.AfterNCalls(B, 3)
293	... )
294	... )
295	>>> termination_conds = {
296	... pnl.TimeScale.TRIAL: pnl.AfterNCalls(C, 4, time_scale=pnl.TimeScale.TRIAL)
297	... }
298	>>> execution_sequence = list(comp.scheduler.run(termination_conds=termination_conds))
299	>>> execution_sequence # doctest: +SKIP
300	[{(TransferMechanism A)}, {(TransferMechanism A), (TransferMechanism B)}, {(TransferMechanism A)}, {(TransferMechanism C)}, {(TransferMechanism A), (TransferMechanism B)}, {(TransferMechanism C)}, {(TransferMechanism A)}, {(TransferMechanism C)}, {(TransferMechanism A), (TransferMechanism B)}, {(TransferMechanism C)}]
301
302	.. _Scheduler_Class_Reference
303	"""
304	),
305
306	(
307	r'linear graph with two nodes.*In standard mode',
308	"""linear composition with two nodes::
309
310	>>> import psyneulink as pnl
311
312	>>> A = pnl.TransferMechanism()
313	>>> B = pnl.TransferMechanism()
314
315	>>> comp = pnl.Composition()
316	>>> pway = comp.add_linear_processing_pathway([A, B])
317
318	>>> comp.scheduler.add_condition(A, pnl.TimeInterval(start=10))
319	>>> comp.scheduler.add_condition(B, pnl.TimeInterval(start=10))
320
321	In standard mode"""
322	),
323
324	(
325	r'(earlier or later \(e\.g\., when the Condition\nfor a particular node or set of nodes is met\)\.)',
326	'\\1 When the Scheduler terminates a `TRIAL <TimeScale.TRIAL>`, the `Composition <Composition>` begins processing the next input specified in the call to its `run <Composition.run>` method. Thus, a `TRIAL <TimeScale.TRIAL>` is defined as the scope of processing associated with a given input to the Composition.'
327	),
328
329	(
330	'(is when all of its constituent environment state updates have terminated.)',
331	"""\\1 These defaults may be overriden when running a Composition, by passing a dictionary mapping `TimeScales <TimeScale>` to `Conditions <Condition>` in the termination_processing argument of a call to `Composition.run` (to terminate the execution of processing)::
332
333	Composition.run(
334	...,
335	termination_processing={TimeScale.TRIAL: WhenFinished(ddm)}
336	)
337	"""
338	),
339
340	(
341	r'(however, using the `indices in the original consideration queue<.*?\.Scheduler\.consideration_queue_indices>`\.)',
342	'\\1 `Composition`\\ s will execute nodes in this order, however independent usages of the scheduler may not. The user should be aware of this and set up defaults and inputs to nodes accordingly.'
343	),
344	],
345	'Scheduler': [
346	(
347	r'(Arguments\n ---------\n)',
348	"""\\1
349	composition : Composition
350	specifies the `Components <Component>` to be ordered for execution, and any dependencies among them,
351	based on the `Composition <Composition>`\\'s `graph <Composition.graph_processing>`.
352	"""
353	)
354	]
355	}

PrincetonUniversity / PsyNeuLink / 8856691984

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