11491589168

Committed 24 Oct 2024 02:36AM UTC coverage: 83.719% (+0.04%) from 83.676%

Build # 11491589168

Build Type

Pull #3079

github

Committed by

web-flow

Commit Message

Merge 9c2a66d34 into c838f803a

Pull Request Pull Request #3079: Fix/one hot max indicator

Run Details

9292 of 12326 branches covered (75.39%)

Branch coverage included in aggregate %.

77 of 79 new or added lines in 7 files covered. (97.47%)

17 existing lines in 3 files now uncovered.

32231 of 37272 relevant lines covered (86.48%)

0.86 hits per line

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

93.33

/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+$')


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

PrincetonUniversity / PsyNeuLink / 11491589168

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