Namespace.__getitem__() - Code Metrics - Inspection of "Added Processor class that handles model imports a..." - zayfod/pyfranca - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b15539...e299b1 )

by Kaloyan

created 2017-02-16 16:29 UTC

Namespace.getitem() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	24.8582

Importance

Changes

Metric	Value
cc	7
dl	0
loc	15
ccs	4
cts	14
cp	0.2857
crap	24.8582
rs	7.3333
c	0
b	0
f	0


from abc import ABCMeta
from collections import OrderedDict


class ASTException(Exception):

    def __init__(self, message):
        super(ASTException, self).__init__()
        self.message = message

    def __str__(self):
        return self.message


class Package(object):
    """
    AST representation of a Franca package.
    """

    def __init__(self, name, file_name=None, imports=None,
                 interfaces=None, typecollections=None):
        """
        Constructs a new Package.
        """
        self.name = name
        self.file = file_name
        self.imports = imports if imports else []
        self.interfaces = interfaces if interfaces else OrderedDict()
        self.typecollections = typecollections if typecollections else \
            OrderedDict()

        for item in self.interfaces.values():
            item.package = self
        for item in self.typecollections.values():
            item.package = self

    def __contains__(self, namespace):
        res = namespace in self.typecollections or \
              namespace in self.interfaces
        return res

    def __getitem__(self, namespace):
        if not isinstance(namespace, str):
            raise TypeError
        elif namespace in self.typecollections:
            return self.typecollections[namespace]
        elif namespace in self.interfaces:
            return self.interfaces[namespace]
        else:
            raise KeyError


class Import(object):

    def __init__(self, file_name, namespace=None):
        self.file = file_name
        self.namespace = namespace          # None for "import model"
        self.package_reference = None
        self.namespace_reference = None


class Namespace(object):

    __metaclass__ = ABCMeta

    def __init__(self, name, flags=None, members=None):
        self.package = None
        self.name = name
        self.flags = flags if flags else []         # Unused
        self.version = None
        self.typedefs = OrderedDict()
        self.enumerations = OrderedDict()
        self.structs = OrderedDict()
        self.arrays = OrderedDict()
        self.maps = OrderedDict()
        if members:
            for member in members:
                self._add_member(member)

    def __contains__(self, name):
        res = name in self.typedefs or \
              name in self.enumerations or \
              name in self.structs or \
              name in self.arrays or \
              name in self.maps
        return res

    def __getitem__(self, name):
        if not isinstance(name, str):
            raise TypeError
        elif name in self.typedefs:
            return self.typedefs[name]
        elif name in self.enumerations:
            return self.enumerations[name]
        elif name in self.structs:
            return self.structs[name]
        elif name in self.arrays:
            return self.arrays[name]
        elif name in self.maps:
            return self.maps[name]
        else:
            raise KeyError

    def _add_member(self, member):
        if isinstance(member, Version):
            if not self.version:
                self.version = member
            else:
                raise ASTException("Multiple version definitions.")
        elif isinstance(member, Type):
            if member.name in self:
                raise ASTException("Duplicate namespace member "
                                   "\"{}\".".format(member.name))
            if isinstance(member, Typedef):
                self.typedefs[member.name] = member
            elif isinstance(member, Enumeration):
                self.enumerations[member.name] = member
            elif isinstance(member, Struct):
                self.structs[member.name] = member
            elif isinstance(member, Array):
                self.arrays[member.name] = member
            elif isinstance(member, Map):
                self.maps[member.name] = member
            else:
                raise ASTException("Unexpected namespace member type.")
            member.namespace = self
        else:
            raise ValueError("Unexpected namespace member type.")


class TypeCollection(Namespace):

    def __init__(self, name, flags=None, members=None):
        super(TypeCollection, self).__init__(name, flags=flags,
                                             members=members)


class Type(object):

    __metaclass__ = ABCMeta

    def __init__(self, name=None):
        self.namespace = None
        self.name = name if name else self.__class__.__name__


class Typedef(Type):

    def __init__(self, name, base_type):
        super(Typedef, self).__init__(name)
        self.type = base_type


class PrimitiveType(Type):

    __metaclass__ = ABCMeta

    def __init__(self):
        super(PrimitiveType, self).__init__()


class Int8(PrimitiveType):

    def __init__(self):
        super(Int8, self).__init__()


class Int16(PrimitiveType):

    def __init__(self):
        super(Int16, self).__init__()


class Int32(PrimitiveType):

    def __init__(self):
        super(Int32, self).__init__()


class Int64(PrimitiveType):

    def __init__(self):
        super(Int64, self).__init__()


class UInt8(PrimitiveType):

    def __init__(self):
        super(UInt8, self).__init__()


class UInt16(PrimitiveType):

    def __init__(self):
        super(UInt16, self).__init__()


class UInt32(PrimitiveType):

    def __init__(self):
        super(UInt32, self).__init__()


class UInt64(PrimitiveType):

    def __init__(self):
        super(UInt64, self).__init__()


class Boolean(PrimitiveType):

    def __init__(self):
        super(Boolean, self).__init__()


class Float(PrimitiveType):

    def __init__(self):
        super(Float, self).__init__()


class Double(PrimitiveType):

    def __init__(self):
        super(Double, self).__init__()


class String(PrimitiveType):

    def __init__(self):
        super(String, self).__init__()


class ByteBuffer(PrimitiveType):

    def __init__(self):
        super(ByteBuffer, self).__init__()


class ComplexType(Type):

    __metaclass__ = ABCMeta

    def __init__(self):
        super(ComplexType, self).__init__()


class Enumeration(ComplexType):

    def __init__(self, name, enumerators=None, extends=None, flags=None):
        super(Enumeration, self).__init__()
        self.name = name
        self.enumerators = enumerators if enumerators else OrderedDict()
        self.extends = extends
        self.reference = None
        self.flags = flags if flags else []         # Unused


class Enumerator(object):

    def __init__(self, name, value=None):
        self.name = name
        self.value = value


class Struct(ComplexType):

    def __init__(self, name, fields=None, extends=None, flags=None):
        super(Struct, self).__init__()
        self.name = name
        self.fields = fields if fields else OrderedDict()
        self.extends = extends
        self.reference = None
        self.flags = flags if flags else []


class StructField(object):

    def __init__(self, name, field_type):
        self.name = name
        self.type = field_type


class Array(ComplexType):

    def __init__(self, name, element_type):
        super(Array, self).__init__()
        self.name = name            # None for implicit arrays.
        self.type = element_type


class Map(ComplexType):

    def __init__(self, name, key_type, value_type):
        super(Map, self).__init__()
        self.name = name
        self.key_type = key_type
        self.value_type = value_type


class Reference(Type):

    def __init__(self, name):
        super(Reference, self).__init__()
        self.name = name
        self.reference = None


class Interface(Namespace):

    def __init__(self, name, flags=None, members=None, extends=None):
        super(Interface, self).__init__(name=name, flags=flags, members=None)
        self.attributes = OrderedDict()
        self.methods = OrderedDict()
        self.broadcasts = OrderedDict()
        self.extends = extends
        self.reference = None
        if members:
            for member in members:
                self._add_member(member)

    def __contains__(self, name):
        res = super(Interface, self).__contains__(name) or \
              name in self.attributes or \
              name in self.methods or \
              name in self.broadcasts
        return res

    def __getitem__(self, name):
        if not isinstance(name, str):
            raise TypeError
        elif name in self.attributes:
            return self.attributes[name]
        elif name in self.methods:
            return self.methods[name]
        elif name in self.broadcasts:
            return self.broadcasts[name]
        else:
            return super(Interface, self).__getitem__(name)

    def _add_member(self, member):
        if isinstance(member, Type):
            if member.name in self:
                raise ASTException("Duplicate namespace member "
                                   "\"{}\".".format(member.name))
            if isinstance(member, Attribute):
                self.attributes[member.name] = member
            elif isinstance(member, Method):
                self.methods[member.name] = member
            elif isinstance(member, Broadcast):
                self.broadcasts[member.name] = member
            else:
                super(Interface, self)._add_member(member)
            member.namespace = self
        else:
            super(Interface, self)._add_member(member)


class Version(object):

    def __init__(self, major, minor):
        self.major = major
        self.minor = minor

    def __str__(self):
        return "{}.{}".format(self.major, self.minor)


class Attribute(Type):

    def __init__(self, name, attr_type, flags=None):
        super(Attribute, self).__init__(name)
        self.type = attr_type
        self.flags = flags if flags else []


class Method(Type):

    def __init__(self, name, flags=None,
                 in_args=None, out_args=None, errors=None):
        super(Method, self).__init__(name)
        self.flags = flags if flags else []
        self.in_args = in_args if in_args else OrderedDict()
        self.out_args = out_args if out_args else OrderedDict()
        # Errors can be an OrderedDict() or a Reference to an enumeration.
        self.errors = errors if errors else OrderedDict()


class Broadcast(Type):

    def __init__(self, name, flags=None, out_args=None):
        super(Broadcast, self).__init__(name)
        self.flags = flags if flags else []
        self.out_args = out_args if out_args else OrderedDict()


class Argument(object):

    def __init__(self, name, arg_type):
        self.name = name
        self.type = arg_type


1
2	1	from abc import ABCMeta
3	1	from collections import OrderedDict
4
5
6	1	class ASTException(Exception):
7
8	1	def __init__(self, message):
9	1	super(ASTException, self).__init__()
10	1	self.message = message
11
12	1	def __str__(self):
13		return self.message
14
15
16	1	class Package(object):
17		"""
18		AST representation of a Franca package.
19		"""
20
21	1	def __init__(self, name, file_name=None, imports=None,
22		interfaces=None, typecollections=None):
23		"""
24		Constructs a new Package.
25		"""
26	1	self.name = name
27	1	self.file = file_name
28	1	self.imports = imports if imports else []
29	1	self.interfaces = interfaces if interfaces else OrderedDict()
30	1	self.typecollections = typecollections if typecollections else \
31		OrderedDict()
32
33	1	for item in self.interfaces.values():
34	1	item.package = self
35	1	for item in self.typecollections.values():
36	1	item.package = self
37
38	1	def __contains__(self, namespace):
39	1	res = namespace in self.typecollections or \
40		namespace in self.interfaces
41	1	return res
42
43	1	def __getitem__(self, namespace):
44	1	if not isinstance(namespace, str):
45		raise TypeError
46	1	elif namespace in self.typecollections:
47	1	return self.typecollections[namespace]
48		elif namespace in self.interfaces:
49		return self.interfaces[namespace]
50		else:
51		raise KeyError
52
53
54	1	class Import(object):
55
56	1	def __init__(self, file_name, namespace=None):
57	1	self.file = file_name
58	1	self.namespace = namespace # None for "import model"
59	1	self.package_reference = None
60	1	self.namespace_reference = None
61
62
63	1	class Namespace(object):
64
65	1	__metaclass__ = ABCMeta
66
67	1	def __init__(self, name, flags=None, members=None):
68	1	self.package = None
69	1	self.name = name
70	1	self.flags = flags if flags else [] # Unused
71	1	self.version = None
72	1	self.typedefs = OrderedDict()
73	1	self.enumerations = OrderedDict()
74	1	self.structs = OrderedDict()
75	1	self.arrays = OrderedDict()
76	1	self.maps = OrderedDict()
77	1	if members:
78	1	for member in members:
79	1	self._add_member(member)
80
81	1	def __contains__(self, name):
82	1	res = name in self.typedefs or \
83		name in self.enumerations or \
84		name in self.structs or \
85		name in self.arrays or \
86		name in self.maps
87	1	return res
88
89	1	def __getitem__(self, name):
90	1	if not isinstance(name, str):
91		raise TypeError
92	1	elif name in self.typedefs:
93	1	return self.typedefs[name]
94		elif name in self.enumerations:
95		return self.enumerations[name]
96		elif name in self.structs:
97		return self.structs[name]
98		elif name in self.arrays:
99		return self.arrays[name]
100		elif name in self.maps:
101		return self.maps[name]
102		else:
103		raise KeyError
104
105	1	def _add_member(self, member):
106	1	if isinstance(member, Version):
107	1	if not self.version:
108	1	self.version = member
109		else:
110	1	raise ASTException("Multiple version definitions.")
111	1	elif isinstance(member, Type):
112	1	if member.name in self:
113	1	raise ASTException("Duplicate namespace member "
114		"\"{}\".".format(member.name))
115	1	if isinstance(member, Typedef):
116	1	self.typedefs[member.name] = member
117	1	elif isinstance(member, Enumeration):
118	1	self.enumerations[member.name] = member
119	1	elif isinstance(member, Struct):
120	1	self.structs[member.name] = member
121	1	elif isinstance(member, Array):
122	1	self.arrays[member.name] = member
123	1	elif isinstance(member, Map):
124	1	self.maps[member.name] = member
125		else:
126		raise ASTException("Unexpected namespace member type.")
127	1	member.namespace = self
128		else:
129		raise ValueError("Unexpected namespace member type.")
130
131
132	1	class TypeCollection(Namespace):
133
134	1	def __init__(self, name, flags=None, members=None):
135	1	super(TypeCollection, self).__init__(name, flags=flags,
136		members=members)
137
138
139	1	class Type(object):
140
141	1	__metaclass__ = ABCMeta
142
143	1	def __init__(self, name=None):
144	1	self.namespace = None
145	1	self.name = name if name else self.__class__.__name__
146
147
148	1	class Typedef(Type):
149
150	1	def __init__(self, name, base_type):
151	1	super(Typedef, self).__init__(name)
152	1	self.type = base_type
153
154
155	1	class PrimitiveType(Type):
156
157	1	__metaclass__ = ABCMeta
158
159	1	def __init__(self):
160	1	super(PrimitiveType, self).__init__()
161
162
163	1	class Int8(PrimitiveType):
164
165	1	def __init__(self):
166	1	super(Int8, self).__init__()
167
168
169	1	class Int16(PrimitiveType):
170
171	1	def __init__(self):
172	1	super(Int16, self).__init__()
173
174
175	1	class Int32(PrimitiveType):
176
177	1	def __init__(self):
178	1	super(Int32, self).__init__()
179
180
181	1	class Int64(PrimitiveType):
182
183	1	def __init__(self):
184	1	super(Int64, self).__init__()
185
186
187	1	class UInt8(PrimitiveType):
188
189	1	def __init__(self):
190	1	super(UInt8, self).__init__()
191
192
193	1	class UInt16(PrimitiveType):
194
195	1	def __init__(self):
196	1	super(UInt16, self).__init__()
197
198
199	1	class UInt32(PrimitiveType):
200
201	1	def __init__(self):
202	1	super(UInt32, self).__init__()
203
204
205	1	class UInt64(PrimitiveType):
206
207	1	def __init__(self):
208	1	super(UInt64, self).__init__()
209
210
211	1	class Boolean(PrimitiveType):
212
213	1	def __init__(self):
214	1	super(Boolean, self).__init__()
215
216
217	1	class Float(PrimitiveType):
218
219	1	def __init__(self):
220	1	super(Float, self).__init__()
221
222
223	1	class Double(PrimitiveType):
224
225	1	def __init__(self):
226	1	super(Double, self).__init__()
227
228
229	1	class String(PrimitiveType):
230
231	1	def __init__(self):
232	1	super(String, self).__init__()
233
234
235	1	class ByteBuffer(PrimitiveType):
236
237	1	def __init__(self):
238	1	super(ByteBuffer, self).__init__()
239
240
241	1	class ComplexType(Type):
242
243	1	__metaclass__ = ABCMeta
244
245	1	def __init__(self):
246	1	super(ComplexType, self).__init__()
247
248
249	1	class Enumeration(ComplexType):
250
251	1	def __init__(self, name, enumerators=None, extends=None, flags=None):
252	1	super(Enumeration, self).__init__()
253	1	self.name = name
254	1	self.enumerators = enumerators if enumerators else OrderedDict()
255	1	self.extends = extends
256	1	self.reference = None
257	1	self.flags = flags if flags else [] # Unused
258
259
260	1	class Enumerator(object):
261
262	1	def __init__(self, name, value=None):
263	1	self.name = name
264	1	self.value = value
265
266
267	1	class Struct(ComplexType):
268
269	1	def __init__(self, name, fields=None, extends=None, flags=None):
270	1	super(Struct, self).__init__()
271	1	self.name = name
272	1	self.fields = fields if fields else OrderedDict()
273	1	self.extends = extends
274	1	self.reference = None
275	1	self.flags = flags if flags else []
276
277
278	1	class StructField(object):
279
280	1	def __init__(self, name, field_type):
281	1	self.name = name
282	1	self.type = field_type
283
284
285	1	class Array(ComplexType):
286
287	1	def __init__(self, name, element_type):
288	1	super(Array, self).__init__()
289	1	self.name = name # None for implicit arrays.
290	1	self.type = element_type
291
292
293	1	class Map(ComplexType):
294
295	1	def __init__(self, name, key_type, value_type):
296	1	super(Map, self).__init__()
297	1	self.name = name
298	1	self.key_type = key_type
299	1	self.value_type = value_type
300
301
302	1	class Reference(Type):
303
304	1	def __init__(self, name):
305	1	super(Reference, self).__init__()
306	1	self.name = name
307	1	self.reference = None
308
309
310	1	class Interface(Namespace):
311
312	1	def __init__(self, name, flags=None, members=None, extends=None):
313	1	super(Interface, self).__init__(name=name, flags=flags, members=None)
314	1	self.attributes = OrderedDict()
315	1	self.methods = OrderedDict()
316	1	self.broadcasts = OrderedDict()
317	1	self.extends = extends
318	1	self.reference = None
319	1	if members:
320	1	for member in members:
321	1	self._add_member(member)
322
323	1	def __contains__(self, name):
324	1	res = super(Interface, self).__contains__(name) or \
325		name in self.attributes or \
326		name in self.methods or \
327		name in self.broadcasts
328	1	return res
329
330	1	def __getitem__(self, name):
331		if not isinstance(name, str):
332		raise TypeError
333		elif name in self.attributes:
334		return self.attributes[name]
335		elif name in self.methods:
336		return self.methods[name]
337		elif name in self.broadcasts:
338		return self.broadcasts[name]
339		else:
340		return super(Interface, self).__getitem__(name)
341
342	1	def _add_member(self, member):
343	1	if isinstance(member, Type):
344	1	if member.name in self:
345	1	raise ASTException("Duplicate namespace member "
346		"\"{}\".".format(member.name))
347	1	if isinstance(member, Attribute):
348	1	self.attributes[member.name] = member
349	1	elif isinstance(member, Method):
350	1	self.methods[member.name] = member
351	1	elif isinstance(member, Broadcast):
352	1	self.broadcasts[member.name] = member
353		else:
354	1	super(Interface, self)._add_member(member)
355	1	member.namespace = self
356		else:
357	1	super(Interface, self)._add_member(member)
358
359
360	1	class Version(object):
361
362	1	def __init__(self, major, minor):
363	1	self.major = major
364	1	self.minor = minor
365
366	1	def __str__(self):
367	1	return "{}.{}".format(self.major, self.minor)
368
369
370	1	class Attribute(Type):
371
372	1	def __init__(self, name, attr_type, flags=None):
373	1	super(Attribute, self).__init__(name)
374	1	self.type = attr_type
375	1	self.flags = flags if flags else []
376
377
378	1	class Method(Type):
379
380	1	def __init__(self, name, flags=None,
381		in_args=None, out_args=None, errors=None):
382	1	super(Method, self).__init__(name)
383	1	self.flags = flags if flags else []
384	1	self.in_args = in_args if in_args else OrderedDict()
385	1	self.out_args = out_args if out_args else OrderedDict()
386		# Errors can be an OrderedDict() or a Reference to an enumeration.
387	1	self.errors = errors if errors else OrderedDict()
388
389
390	1	class Broadcast(Type):
391
392	1	def __init__(self, name, flags=None, out_args=None):
393	1	super(Broadcast, self).__init__(name)
394	1	self.flags = flags if flags else []
395	1	self.out_args = out_args if out_args else OrderedDict()
396
397
398	1	class Argument(object):
399
400	1	def __init__(self, name, arg_type):
401	1	self.name = name
402		self.type = arg_type
403

zayfod / pyfranca

GitHub Access Token became invalid

Push — master ( b15539...e299b1 )

Namespace.__getitem__() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Namespace.getitem() B