12022076003

Committed 26 Nov 2024 01:33AM UTC coverage: 83.896% (+0.2%) from 83.721%

Build # 12022076003

Build Type

Pull #3129

github

Committed by

web-flow

Commit Message

patch/emcomposition/field_memories (#3128)

* • emcomposition.py
  fix bug in field.memories property

• test_emcomposition.py
  test_order_fields_in_memory: add tests for field.type and memory alignment

Pull Request Pull Request #3129: Devel

Run Details

9476 of 12518 branches covered (75.7%)

Branch coverage included in aggregate %.

539 of 567 new or added lines in 19 files covered. (95.06%)

10 existing lines in 3 files now uncovered.

32847 of 37929 relevant lines covered (86.6%)

0.87 hits per line

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

89.89

/psyneulink/core/globals/registry.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.
#
#
# ***********************************************  Registry ************************************************************

import inspect
import re

from collections import defaultdict, namedtuple

from psyneulink.core.globals.keywords import \
    CONTROL_PROJECTION, DDM_MECHANISM, GATING_SIGNAL, INPUT_PORT, MAPPING_PROJECTION, OUTPUT_PORT, \
    FUNCTION_COMPONENT_CATEGORY, COMPONENT_PREFERENCE_SET, MECHANISM_COMPONENT_CATEGORY, \
    PARAMETER_PORT, PREFERENCE_SET, PROJECTION_COMPONENT_CATEGORY, \
    PORT_COMPONENT_CATEGORY

__all__ = [
    'RegistryError',
    'clear_registry',
    'process_registry_object_instances'
]

# IMPLEMENTATION NOTE:
# - Implement Registry as class, and each Registry as subclass
# - Implement RegistryPreferenceSet as PreferenceSet subclass, and assign prefs attribute to each Registry object

DEFAULT_REGISTRY_VERBOSITY = False
RegistryVerbosePrefs = {
    PREFERENCE_SET: DEFAULT_REGISTRY_VERBOSITY,
    COMPONENT_PREFERENCE_SET: DEFAULT_REGISTRY_VERBOSITY,
    MECHANISM_COMPONENT_CATEGORY: DEFAULT_REGISTRY_VERBOSITY,
    PORT_COMPONENT_CATEGORY: DEFAULT_REGISTRY_VERBOSITY,
    INPUT_PORT: DEFAULT_REGISTRY_VERBOSITY,
    PARAMETER_PORT: DEFAULT_REGISTRY_VERBOSITY,
    OUTPUT_PORT: DEFAULT_REGISTRY_VERBOSITY,
    GATING_SIGNAL: DEFAULT_REGISTRY_VERBOSITY,
    DDM_MECHANISM: DEFAULT_REGISTRY_VERBOSITY,
    PROJECTION_COMPONENT_CATEGORY: DEFAULT_REGISTRY_VERBOSITY,
    CONTROL_PROJECTION: DEFAULT_REGISTRY_VERBOSITY,
    MAPPING_PROJECTION: DEFAULT_REGISTRY_VERBOSITY,
    FUNCTION_COMPONENT_CATEGORY: DEFAULT_REGISTRY_VERBOSITY,
}

RegistryEntry = namedtuple('RegistryTuple', 'subclass, instanceDict, instanceCount, renamed_instance_counts, default')

numeric_suffix_pat = re.compile(r'(.*)-\d+$')

def name_without_suffix(name):
    """Return name with any numeric suffix removed"""
    match = numeric_suffix_pat.match(name)
    if match:
        name_stripped_of_suffix = match.groups()[0]
        return name_stripped_of_suffix
    else:
        return name


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

    def __str__(self):
        return repr(self.error_value)


_register_auto_name_prefix = ""

def _get_auto_name_prefix():
    return _register_auto_name_prefix

def register_category(entry,
                      base_class,
                      name=None,
                      registry=None,
                      ):
    """Create a category within the specified registry.

    Arguments
    ---------

    base_class : Class
        PsyNeuLink Base class of Category to be added to Registry.

    name : str
        PsyNeuLink Base class of Category for which Registry is to be created.

    Registry : Dict
        Registry to which Category should be added.

    context : Context or str

    COMMENT:
    - entry (object or class)
    - base_class (parent class for entry)
    - registry (dict)


    # DOCUMENTATION:
             - Naming procedure / conventions
             - Default procedure /conventions

             TBI:
             - sub group option:  allows instances to be sub-grouped by the attribute passed in sub_group_attr arg

             If sub_group_attr, then:
                 - instead of implementing instance dict directly, implement subgroup dict
                 - when an entry is made, check for owner in sub-dict
                 - if no owner, create entry for owner, instance dict for that owner, and log instance in instance dict
                 - if owner is found, but no instances, create instance dict for that owner
                 - if owner and instance dict exist, make entry

                 - implement instance dict within subgroup



    # IMPLEMENTATION NOTE:
        ADD DEFAULT MANAGEMENT (USEFUL AT LEAST FOR PROCESS... OTHERS ARE CONTEXT-SPECIFIC)
        # # MechanismRegistry ------------------------------------------------------------------------
        # #
        # # Dictionary of registered Mechanism subclasses; each entry has:
        # #     - key: Mechanism component type name (componentType)
        # #     - value: MechanismEntry tuple (Mechanism, instanceCount, default)
        # #              Notes:
        # #              * instanceCount is incremented each time a new default instance is created
        # #              * only one default is allowed;  if a Mechanism registers itself as default,
        # #                  that displaces whatever was the default previously;  initially it is DDM
        #
        # # MechanismRegistry = {DefaultReceiver.name:(DefaultReceiverMechanism, 1)}
        #
    COMMENT
    """

    # IMPLEMENTATION NOTE:  Move to Port when that is implemented as ABC
    from psyneulink.core.components.shellclasses import Port
    if inspect.isclass(entry) and issubclass(entry, Port):
        try:
            entry.portAttributes
        except AttributeError:
            raise RegistryError("PROGRAM ERROR: {} must implement a stateSpecificParams attribute".
                                format(entry.__name__))
        try:
            entry.connectsWith
        except AttributeError:
            raise RegistryError("PROGRAM ERROR: {} must implement a connectsWith attribute".format(entry.__name__))
        try:
            entry.connectsWithAttribute
        except AttributeError:
            raise RegistryError("PROGRAM ERROR: {} must implement a connectsWithAttribute attribute".
                                format(entry.__name__))
        try:
            entry.projectionSocket
        except AttributeError:
            raise RegistryError("PROGRAM ERROR: {} must implement a projectionSocket attribute".format(entry.__name__))
        try:
            entry.modulators
        except AttributeError:
            raise RegistryError("PROGRAM ERROR: {} must implement a modulators attribute".format(entry.__name__))

    if not isinstance(registry, dict):
        raise RegistryError("Registry ({0}) for {1} must be a dict".format(registry,base_class.__name__))

    # if sub_group_attr:
    #     if not isinstance(sub_group_attr, str):
    #         raise RegistryError("sub_group_attr arg ({0}) must be a str that is the name of an attribute of {1} ".
    #                             format(sub_group_attr,entry.__class__.__name__))
    #     try:
    #         sub_group = getattr(entry,sub_group_attr)
    #     except AttributeError:
    #         raise RegistryError("sub_group_attr arg ({0}) must be an attribute of {1} ".
    #                             format(sub_group_attr,entry.__class__.__name__))

    # If entry is an instance (presumably of a component type of the base class):
    if isinstance(entry, base_class):

        try:
            component_type_name = entry.componentName
        except AttributeError:
            try:
                component_type_name = entry.componentType
            except AttributeError:
                component_type_name = entry.__class__.__name__

        # Component type is registered (i.e., there is an entry for component_type_name)
        if component_type_name in registry:
            register_instance(entry=entry,
                              name=name,
                              base_class=base_class,
                              registry=registry,
                              sub_dict=component_type_name)

        # If component type is not already registered in registry, then:
        else:
            # Set instance's name to first instance:
            # If name was not provided, assign component_type_name-1 as default;
            if name is None:
                try:
                    entry.name = _register_auto_name_prefix + component_type_name + "-0"
                except TypeError:
                    entry.name = _register_auto_name_prefix + entry.__class__.__name__

            else:
                entry.name = name

            # Create instance dict:
            instanceDict = {entry.name: entry}
            renamed_instance_counts = defaultdict(int)

            # Register component type with instance count of 1:
            registry[component_type_name] = RegistryEntry(type(entry), instanceDict, 1, renamed_instance_counts, False)


    # If entry is a reference to the component type (rather than an instance of it)
    elif issubclass(entry, base_class):
        component_type_name = entry.__name__
        # If it is already there, ignore
        if component_type_name in registry:
            pass
        # If it is not there:
        # - create entry for component type in registry
        # - instantiate empty instanceDict
        # - set instance count = 0
        else:
            registry[component_type_name] = RegistryEntry(entry, {}, 0, defaultdict(int), False)

    else:
        raise RegistryError("Requested entry {0} not of type {1}".format(entry, base_class))


def register_instance(entry, name, base_class, registry, sub_dict):

    renamed_instance_counts = registry[sub_dict].renamed_instance_counts
    renamed = False
    # If entry (instance) name is None, set entry's name to sub_dict-n where n is the next available numeric suffix
    # (starting at 0) based on the number of unnamed/renamed sub_dict objects that have already been assigned names
    if name is None:
        entry.name = '{0}{1}-{2}'.format(_register_auto_name_prefix, sub_dict, renamed_instance_counts[sub_dict])
        renamed = True
    else:
        entry.name = name

    assert not entry.name.startswith("__pnl_") or entry.name.startswith(_register_auto_name_prefix), \
        "Using reserved name: {}".format(entry.name)

    while entry.name in registry[sub_dict].instanceDict:
        # if the decided name (provided or determined) is already assigned to an object, get the non-suffixed name,
        # and append the proper new suffix according to the number of objects that have been assigned that name
        # NOTE: the while is to handle a scenario in which a user specifies a name that uses our convention but
        #   does not follow our pattern. In this case, we will produce a unique name, but the "count" will be off
        #   e.g. user gives a mechanism the name TransferMechanism-5, then the fifth unnamed TransferMechanism
        #   will be named TransferMechanism-6
        # TODO: an ambiguation problem - is the name "MappingProjection x to y-1"
        # the second projection from x to y, or the first projection from x to y-1?
        match = numeric_suffix_pat.match(entry.name)

        if match is None:
            renamed_instance_counts[entry.name] += 1
            entry.name += '-{0}'.format(renamed_instance_counts[entry.name])
        else:
            name_stripped_of_suffix = match.groups()[0]

            if name_stripped_of_suffix in renamed_instance_counts:
                # try to detect unsuffixed version first as base name
                renamed_instance_counts[name_stripped_of_suffix] += 1
                entry.name = numeric_suffix_pat.sub(
                    r'\1-{0}'.format(
                        renamed_instance_counts[name_stripped_of_suffix]
                    ),
                    entry.name
                )
            else:
                # the second time a -\d suffixed name (not renamed though) appears
                renamed_instance_counts[entry.name] += 1
                entry.name += '-{0}'.format(renamed_instance_counts[entry.name])

    # Add instance to instanceDict:
    registry[sub_dict].instanceDict.update({entry.name: entry})

    # Update instanceCount in registry:
    registry[sub_dict] = registry[sub_dict]._replace(instanceCount=registry[sub_dict].instanceCount + 1)

    # increment the base (non-suffixed) name count
    if renamed:
        match = numeric_suffix_pat.match(entry.name)
        if match is None:
            renamed_instance_counts[entry.name] += 1
        else:
            renamed_instance_counts[match.groups()[0]] += 1

def rename_instance_in_registry(registry, category, new_name, old_name=None, component=None):
    """Rename instance in category registry

    Instance to be renamed can be specified by a reference to the component or its name.
    COMMENT:
    DEPRECATED (SEE IMPLEMENTATION NOTE BELOW)
    If the name of the instance was a default name, and it was the last in the sequence,
        decrement renamed_instance_counts and if it was the only one, remove that name from the renamed_instance list
    COMMENT
    """

    registry_entry = registry[category]

    if not (old_name or component):
        raise RegistryError("Must specify a name or component to remove an entry of {}".
                            format(registry.__class__.__name__))
    if (old_name and component) and old_name != component.old_name:
        raise RegistryError("Conflicting  name ({}) and component ({}) specified for entry to remove from {}".
                            format(old_name, component.old_name, registry.__class__.__name__))
    if component and not old_name:
        for n, c in registry_entry.instanceDict.items():
            if component == c:
                old_name = n

    try:
        clear_registry(registry_entry.instanceDict[old_name]._portRegistry)
    except (AttributeError):
        pass

    entry = registry_entry.instanceDict[old_name]
    # Delete entry for instance
    del registry_entry.instanceDict[old_name]
    # Add entry for instance under new name
    registry_entry.instanceDict[new_name] = entry

    # Decrement count for instances in entry
    instance_count = registry_entry.instanceCount - 1

    # IMPLEMENTATION NOTE:
    #    Don't decrement renamed_instance_counts as:
    #        - doing so would require checking that the item being removed is the last in the sequence
    #          (to avoid fouling subsequent indexing);
    #        - it might be confusing for a subsequently added item to have the same name as one previously removed.
    # # If instance's name was a duplicate with appended index, decrement the count for that item (and remove if it is 0)
    # for base_name, count in registry_entry.renamed_instance_counts.items():
    #     if base_name in name:
    #         registry_entry.renamed_instance_counts[base_name] -= 1
    #         if registry_entry.renamed_instance_counts[base_name] == 0:
    #             del registry_entry.renamed_instance_counts[base_name]
    #         break
    # Reassign entry with new values
    registry[category] = RegistryEntry(registry_entry.subclass,
                                       registry_entry.instanceDict,
                                       instance_count,
                                       registry_entry.renamed_instance_counts,
                                       registry_entry.default)
    return new_name

def remove_instance_from_registry(registry, category, name=None, component=None):
    """Remove instance from registry category entry

    Instance to be removed can be specified by a reference to the component or its name.
    Instance count for the category is decremented
    If the name of the instance was a default name, and it was the last in the sequence,
        decrement renamed_instance_counts and if it was the only one, remove that name from the renamed_instance list
    """

    registry_entry = registry[category]

    if not (name or component):
        raise RegistryError("Must specify a name or component to remove an entry of {}".
                            format(registry.__class__.__name__))
    if (name and component) and name != component.name:
        raise RegistryError("Conflicting  name ({}) and component ({}) specified for entry to remove from {}".
                            format(name, component.name, registry.__class__.__name__))
    if component and not name:
        for n, c in registry_entry.instanceDict.items():
            if component == c:
                name = n

    try:
        clear_registry(registry_entry.instanceDict[name]._portRegistry)
    except (AttributeError):
        pass

    # Delete instance
    del registry_entry.instanceDict[name]

    # Decrement count for instances in entry
    instance_count = registry_entry.instanceCount - 1

    # IMPLEMENTATION NOTE:
    #    Don't decrement renamed_instance_counts as:
    #        - doing so would require checking that the item being removed is the last in the sequence
    #          (to avoid fouling subsequent indexing);
    #        - it might be confusing for a subsequently added item to have the same name as one previously removed.
    # # If instance's name was a duplicate with appended index, decrement the count for that item (and remove if it is 0)
    # for base_name, count in registry_entry.renamed_instance_counts.items():
    #     if base_name in name:
    #         registry_entry.renamed_instance_counts[base_name] -= 1
    #         if registry_entry.renamed_instance_counts[base_name] == 0:
    #             del registry_entry.renamed_instance_counts[base_name]
    #         break
    # Reassign entry with new values
    registry[category] = RegistryEntry(registry_entry.subclass,
                                       registry_entry.instanceDict,
                                       instance_count,
                                       registry_entry.renamed_instance_counts,
                                       registry_entry.default)

def clear_registry(registry=None):
    """Clear specified registry of all entries, but leave any categories created within it intact.

    .. note::
       This method should be used with caution.  It is used primarily in unit tests, to insure consistency of naming
       within a given test.  Calling it outside of testing may allow new Components of the same type to be created with
       exactly the same PsyNeuLink name as exsiting ones within the same Python namespace.

    """
    from psyneulink import primary_registries

    if registry is None:
        registries = primary_registries
    else:
        registries = [registry]

    for registry in registries:
        for category in registry:
            instance_dict = registry[category].instanceDict.copy()
            for name in instance_dict:
                remove_instance_from_registry(registry, category, name)
            registry[category].renamed_instance_counts.clear()

def process_registry_object_instances(registry, func):
    for category in registry:
        for (name, obj) in registry[category].instanceDict.items():
            func(name, obj)

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	# ********************************************* Registry **********************************************************
10
11	import inspect	1✔
12	import re	1✔
13
14	from collections import defaultdict, namedtuple	1✔
15
16	from psyneulink.core.globals.keywords import \	1✔
17	CONTROL_PROJECTION, DDM_MECHANISM, GATING_SIGNAL, INPUT_PORT, MAPPING_PROJECTION, OUTPUT_PORT, \
18	FUNCTION_COMPONENT_CATEGORY, COMPONENT_PREFERENCE_SET, MECHANISM_COMPONENT_CATEGORY, \
19	PARAMETER_PORT, PREFERENCE_SET, PROJECTION_COMPONENT_CATEGORY, \
20	PORT_COMPONENT_CATEGORY
21
22	__all__ = [	1✔
23	'RegistryError',
24	'clear_registry',
25	'process_registry_object_instances'
26	]
27
28	# IMPLEMENTATION NOTE:
29	# - Implement Registry as class, and each Registry as subclass
30	# - Implement RegistryPreferenceSet as PreferenceSet subclass, and assign prefs attribute to each Registry object
31
32	DEFAULT_REGISTRY_VERBOSITY = False	1✔
33	RegistryVerbosePrefs = {	1✔
34	PREFERENCE_SET: DEFAULT_REGISTRY_VERBOSITY,
35	COMPONENT_PREFERENCE_SET: DEFAULT_REGISTRY_VERBOSITY,
36	MECHANISM_COMPONENT_CATEGORY: DEFAULT_REGISTRY_VERBOSITY,
37	PORT_COMPONENT_CATEGORY: DEFAULT_REGISTRY_VERBOSITY,
38	INPUT_PORT: DEFAULT_REGISTRY_VERBOSITY,
39	PARAMETER_PORT: DEFAULT_REGISTRY_VERBOSITY,
40	OUTPUT_PORT: DEFAULT_REGISTRY_VERBOSITY,
41	GATING_SIGNAL: DEFAULT_REGISTRY_VERBOSITY,
42	DDM_MECHANISM: DEFAULT_REGISTRY_VERBOSITY,
43	PROJECTION_COMPONENT_CATEGORY: DEFAULT_REGISTRY_VERBOSITY,
44	CONTROL_PROJECTION: DEFAULT_REGISTRY_VERBOSITY,
45	MAPPING_PROJECTION: DEFAULT_REGISTRY_VERBOSITY,
46	FUNCTION_COMPONENT_CATEGORY: DEFAULT_REGISTRY_VERBOSITY,
47	}
48
49	RegistryEntry = namedtuple('RegistryTuple', 'subclass, instanceDict, instanceCount, renamed_instance_counts, default')	1✔
50
51	numeric_suffix_pat = re.compile(r'(.*)-\d+$')	1✔
52
53	def name_without_suffix(name):	1✔
54	"""Return name with any numeric suffix removed"""
UNCOV 55	match = numeric_suffix_pat.match(name)	×
UNCOV 56	if match:	×
UNCOV 57	name_stripped_of_suffix = match.groups()[0]	×
UNCOV 58	return name_stripped_of_suffix	×
59	else:
UNCOV 60	return name	×
61
62
63	class RegistryError(Exception):	1✔
64	def __init__(self, error_value):	1✔
65	self.error_value = error_value	×
66
67	def __str__(self):	1✔
68	return repr(self.error_value)	×
69
70
71	_register_auto_name_prefix = ""	1✔
72
73	def _get_auto_name_prefix():	1✔
74	return _register_auto_name_prefix	1✔
75
76	def register_category(entry,	1✔
77	base_class,
78	name=None,
79	registry=None,
80	):
81	"""Create a category within the specified registry.
82
83	Arguments
84	---------
85
86	base_class : Class
87	PsyNeuLink Base class of Category to be added to Registry.
88
89	name : str
90	PsyNeuLink Base class of Category for which Registry is to be created.
91
92	Registry : Dict
93	Registry to which Category should be added.
94
95	context : Context or str
96
97	COMMENT:
98	- entry (object or class)
99	- base_class (parent class for entry)
100	- registry (dict)
101
102
103	# DOCUMENTATION:
104	- Naming procedure / conventions
105	- Default procedure /conventions
106
107	TBI:
108	- sub group option: allows instances to be sub-grouped by the attribute passed in sub_group_attr arg
109
110	If sub_group_attr, then:
111	- instead of implementing instance dict directly, implement subgroup dict
112	- when an entry is made, check for owner in sub-dict
113	- if no owner, create entry for owner, instance dict for that owner, and log instance in instance dict
114	- if owner is found, but no instances, create instance dict for that owner
115	- if owner and instance dict exist, make entry
116
117	- implement instance dict within subgroup
118
119
120
121	# IMPLEMENTATION NOTE:
122	ADD DEFAULT MANAGEMENT (USEFUL AT LEAST FOR PROCESS... OTHERS ARE CONTEXT-SPECIFIC)
123	# # MechanismRegistry ------------------------------------------------------------------------
124	# #
125	# # Dictionary of registered Mechanism subclasses; each entry has:
126	# # - key: Mechanism component type name (componentType)
127	# # - value: MechanismEntry tuple (Mechanism, instanceCount, default)
128	# # Notes:
129	# # * instanceCount is incremented each time a new default instance is created
130	# # * only one default is allowed; if a Mechanism registers itself as default,
131	# # that displaces whatever was the default previously; initially it is DDM
132	#
133	# # MechanismRegistry = {DefaultReceiver.name:(DefaultReceiverMechanism, 1)}
134	#
135	COMMENT
136	"""
137
138	# IMPLEMENTATION NOTE: Move to Port when that is implemented as ABC
139	from psyneulink.core.components.shellclasses import Port	1✔
140	if inspect.isclass(entry) and issubclass(entry, Port):	1✔
141	try:	1✔
142	entry.portAttributes	1✔
143	except AttributeError:	×
144	raise RegistryError("PROGRAM ERROR: {} must implement a stateSpecificParams attribute".
145	format(entry.__name__))
146	try:	1✔
147	entry.connectsWith	1✔
148	except AttributeError:	×
149	raise RegistryError("PROGRAM ERROR: {} must implement a connectsWith attribute".format(entry.__name__))
150	try:	1✔
151	entry.connectsWithAttribute	1✔
152	except AttributeError:	×
153	raise RegistryError("PROGRAM ERROR: {} must implement a connectsWithAttribute attribute".
154	format(entry.__name__))
155	try:	1✔
156	entry.projectionSocket	1✔
157	except AttributeError:	×
158	raise RegistryError("PROGRAM ERROR: {} must implement a projectionSocket attribute".format(entry.__name__))
159	try:	1✔
160	entry.modulators	1✔
161	except AttributeError:	×
162	raise RegistryError("PROGRAM ERROR: {} must implement a modulators attribute".format(entry.__name__))
163
164	if not isinstance(registry, dict):	1✔
165	raise RegistryError("Registry ({0}) for {1} must be a dict".format(registry,base_class.__name__))
166
167	# if sub_group_attr:
168	# if not isinstance(sub_group_attr, str):
169	# raise RegistryError("sub_group_attr arg ({0}) must be a str that is the name of an attribute of {1} ".
170	# format(sub_group_attr,entry.__class__.__name__))
171	# try:
172	# sub_group = getattr(entry,sub_group_attr)
173	# except AttributeError:
174	# raise RegistryError("sub_group_attr arg ({0}) must be an attribute of {1} ".
175	# format(sub_group_attr,entry.__class__.__name__))
176
177	# If entry is an instance (presumably of a component type of the base class):
178	if isinstance(entry, base_class):	1✔
179
180	try:	1✔
181	component_type_name = entry.componentName	1✔
182	except AttributeError:	1✔
183	try:	1✔
184	component_type_name = entry.componentType	1✔
185	except AttributeError:	1✔
186	component_type_name = entry.__class__.__name__	1✔
187
188	# Component type is registered (i.e., there is an entry for component_type_name)
189	if component_type_name in registry:	1✔
190	register_instance(entry=entry,	1✔
191	name=name,
192	base_class=base_class,
193	registry=registry,
194	sub_dict=component_type_name)
195
196	# If component type is not already registered in registry, then:
197	else:
198	# Set instance's name to first instance:
199	# If name was not provided, assign component_type_name-1 as default;
200	if name is None:	1✔
201	try:	1✔
202	entry.name = _register_auto_name_prefix + component_type_name + "-0"	1✔
203	except TypeError:	1✔
204	entry.name = _register_auto_name_prefix + entry.__class__.__name__	1✔
205
206	else:
207	entry.name = name	1✔
208
209	# Create instance dict:
210	instanceDict = {entry.name: entry}	1✔
211	renamed_instance_counts = defaultdict(int)	1✔
212
213	# Register component type with instance count of 1:
214	registry[component_type_name] = RegistryEntry(type(entry), instanceDict, 1, renamed_instance_counts, False)	1✔
215
216
217	# If entry is a reference to the component type (rather than an instance of it)
218	elif issubclass(entry, base_class):	1✔
219	component_type_name = entry.__name__	1✔
220	# If it is already there, ignore
221	if component_type_name in registry:	1!
222	pass	×
223	# If it is not there:
224	# - create entry for component type in registry
225	# - instantiate empty instanceDict
226	# - set instance count = 0
227	else:
228	registry[component_type_name] = RegistryEntry(entry, {}, 0, defaultdict(int), False)	1✔
229
230	else:
231	raise RegistryError("Requested entry {0} not of type {1}".format(entry, base_class))
232
233
234	def register_instance(entry, name, base_class, registry, sub_dict):	1✔
235
236	renamed_instance_counts = registry[sub_dict].renamed_instance_counts	1✔
237	renamed = False	1✔
238	# If entry (instance) name is None, set entry's name to sub_dict-n where n is the next available numeric suffix
239	# (starting at 0) based on the number of unnamed/renamed sub_dict objects that have already been assigned names
240	if name is None:	1✔
241	entry.name = '{0}{1}-{2}'.format(_register_auto_name_prefix, sub_dict, renamed_instance_counts[sub_dict])	1✔
242	renamed = True	1✔
243	else:
244	entry.name = name	1✔
245
246	assert not entry.name.startswith("__pnl_") or entry.name.startswith(_register_auto_name_prefix), \	1✔
247	"Using reserved name: {}".format(entry.name)
248
249	while entry.name in registry[sub_dict].instanceDict:	1✔
250	# if the decided name (provided or determined) is already assigned to an object, get the non-suffixed name,
251	# and append the proper new suffix according to the number of objects that have been assigned that name
252	# NOTE: the while is to handle a scenario in which a user specifies a name that uses our convention but
253	# does not follow our pattern. In this case, we will produce a unique name, but the "count" will be off
254	# e.g. user gives a mechanism the name TransferMechanism-5, then the fifth unnamed TransferMechanism
255	# will be named TransferMechanism-6
256	# TODO: an ambiguation problem - is the name "MappingProjection x to y-1"
257	# the second projection from x to y, or the first projection from x to y-1?
258	match = numeric_suffix_pat.match(entry.name)	1✔
259
260	if match is None:	1✔
261	renamed_instance_counts[entry.name] += 1	1✔
262	entry.name += '-{0}'.format(renamed_instance_counts[entry.name])	1✔
263	else:
264	name_stripped_of_suffix = match.groups()[0]	1✔
265
266	if name_stripped_of_suffix in renamed_instance_counts:	1✔
267	# try to detect unsuffixed version first as base name
268	renamed_instance_counts[name_stripped_of_suffix] += 1	1✔
269	entry.name = numeric_suffix_pat.sub(	1✔
270	r'\1-{0}'.format(
271	renamed_instance_counts[name_stripped_of_suffix]
272	),
273	entry.name
274	)
275	else:
276	# the second time a -\d suffixed name (not renamed though) appears
277	renamed_instance_counts[entry.name] += 1	1✔
278	entry.name += '-{0}'.format(renamed_instance_counts[entry.name])	1✔
279
280	# Add instance to instanceDict:
281	registry[sub_dict].instanceDict.update({entry.name: entry})	1✔
282
283	# Update instanceCount in registry:
284	registry[sub_dict] = registry[sub_dict]._replace(instanceCount=registry[sub_dict].instanceCount + 1)	1✔
285
286	# increment the base (non-suffixed) name count
287	if renamed:	1✔
288	match = numeric_suffix_pat.match(entry.name)	1✔
289	if match is None:	1!
290	renamed_instance_counts[entry.name] += 1	×
291	else:
292	renamed_instance_counts[match.groups()[0]] += 1	1✔
293
294	def rename_instance_in_registry(registry, category, new_name, old_name=None, component=None):	1✔
295	"""Rename instance in category registry
296
297	Instance to be renamed can be specified by a reference to the component or its name.
298	COMMENT:
299	DEPRECATED (SEE IMPLEMENTATION NOTE BELOW)
300	If the name of the instance was a default name, and it was the last in the sequence,
301	decrement renamed_instance_counts and if it was the only one, remove that name from the renamed_instance list
302	COMMENT
303	"""
304
305	registry_entry = registry[category]	1✔
306
307	if not (old_name or component):	1✔
308	raise RegistryError("Must specify a name or component to remove an entry of {}".
309	format(registry.__class__.__name__))
310	if (old_name and component) and old_name != component.old_name:	1✔
311	raise RegistryError("Conflicting name ({}) and component ({}) specified for entry to remove from {}".
312	format(old_name, component.old_name, registry.__class__.__name__))
313	if component and not old_name:	1!
314	for n, c in registry_entry.instanceDict.items():	1✔
315	if component == c:	1✔
316	old_name = n	1✔
317
318	try:	1✔
319	clear_registry(registry_entry.instanceDict[old_name]._portRegistry)	1✔
320	except (AttributeError):	1✔
321	pass	1✔
322
323	entry = registry_entry.instanceDict[old_name]	1✔
324	# Delete entry for instance
325	del registry_entry.instanceDict[old_name]	1✔
326	# Add entry for instance under new name
327	registry_entry.instanceDict[new_name] = entry	1✔
328
329	# Decrement count for instances in entry
330	instance_count = registry_entry.instanceCount - 1	1✔
331
332	# IMPLEMENTATION NOTE:
333	# Don't decrement renamed_instance_counts as:
334	# - doing so would require checking that the item being removed is the last in the sequence
335	# (to avoid fouling subsequent indexing);
336	# - it might be confusing for a subsequently added item to have the same name as one previously removed.
337	# # If instance's name was a duplicate with appended index, decrement the count for that item (and remove if it is 0)
338	# for base_name, count in registry_entry.renamed_instance_counts.items():
339	# if base_name in name:
340	# registry_entry.renamed_instance_counts[base_name] -= 1
341	# if registry_entry.renamed_instance_counts[base_name] == 0:
342	# del registry_entry.renamed_instance_counts[base_name]
343	# break
344	# Reassign entry with new values
345	registry[category] = RegistryEntry(registry_entry.subclass,	1✔
346	registry_entry.instanceDict,
347	instance_count,
348	registry_entry.renamed_instance_counts,
349	registry_entry.default)
350	return new_name	1✔
351
352	def remove_instance_from_registry(registry, category, name=None, component=None):	1✔
353	"""Remove instance from registry category entry
354
355	Instance to be removed can be specified by a reference to the component or its name.
356	Instance count for the category is decremented
357	If the name of the instance was a default name, and it was the last in the sequence,
358	decrement renamed_instance_counts and if it was the only one, remove that name from the renamed_instance list
359	"""
360
361	registry_entry = registry[category]	1✔
362
363	if not (name or component):	1✔
364	raise RegistryError("Must specify a name or component to remove an entry of {}".
365	format(registry.__class__.__name__))
366	if (name and component) and name != component.name:	1✔
367	raise RegistryError("Conflicting name ({}) and component ({}) specified for entry to remove from {}".
368	format(name, component.name, registry.__class__.__name__))
369	if component and not name:	1✔
370	for n, c in registry_entry.instanceDict.items():	1✔
371	if component == c:	1✔
372	name = n	1✔
373
374	try:	1✔
375	clear_registry(registry_entry.instanceDict[name]._portRegistry)	1✔
376	except (AttributeError):	1✔
377	pass	1✔
378
379	# Delete instance
380	del registry_entry.instanceDict[name]	1✔
381
382	# Decrement count for instances in entry
383	instance_count = registry_entry.instanceCount - 1	1✔
384
385	# IMPLEMENTATION NOTE:
386	# Don't decrement renamed_instance_counts as:
387	# - doing so would require checking that the item being removed is the last in the sequence
388	# (to avoid fouling subsequent indexing);
389	# - it might be confusing for a subsequently added item to have the same name as one previously removed.
390	# # If instance's name was a duplicate with appended index, decrement the count for that item (and remove if it is 0)
391	# for base_name, count in registry_entry.renamed_instance_counts.items():
392	# if base_name in name:
393	# registry_entry.renamed_instance_counts[base_name] -= 1
394	# if registry_entry.renamed_instance_counts[base_name] == 0:
395	# del registry_entry.renamed_instance_counts[base_name]
396	# break
397	# Reassign entry with new values
398	registry[category] = RegistryEntry(registry_entry.subclass,	1✔
399	registry_entry.instanceDict,
400	instance_count,
401	registry_entry.renamed_instance_counts,
402	registry_entry.default)
403
404	def clear_registry(registry=None):	1✔
405	"""Clear specified registry of all entries, but leave any categories created within it intact.
406
407	.. note::
408	This method should be used with caution. It is used primarily in unit tests, to insure consistency of naming
409	within a given test. Calling it outside of testing may allow new Components of the same type to be created with
410	exactly the same PsyNeuLink name as exsiting ones within the same Python namespace.
411
412	"""
413	from psyneulink import primary_registries	1✔
414
415	if registry is None:	1✔
416	registries = primary_registries	1✔
417	else:
418	registries = [registry]	1✔
419
420	for registry in registries:	1✔
421	for category in registry:	1✔
422	instance_dict = registry[category].instanceDict.copy()	1✔
423	for name in instance_dict:	1✔
424	remove_instance_from_registry(registry, category, name)	1✔
425	registry[category].renamed_instance_counts.clear()	1✔
426
427	def process_registry_object_instances(registry, func):	1✔
428	for category in registry:	1✔
429	for (name, obj) in registry[category].instanceDict.items():	1✔
430	func(name, obj)	1✔

PrincetonUniversity / PsyNeuLink / 12022076003

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