def getAttr(self, attrName):
attrs = {<EOL>'<STR_LIT:name>': '<STR_LIT>',<EOL>'<STR_LIT:type>': '<STR_LIT>',<EOL>'<STR_LIT>': True,<EOL>'<STR_LIT>': [<NUM_LIT:0.0>, <NUM_LIT:0.0>],<EOL>'<STR_LIT:size>': [<NUM_LIT:0.0>, <NUM_LIT:0.0>],<EOL>'<STR_LIT>': [<NUM_LIT:1.0>, <NUM_LIT:1.0>],<EOL>'<STR_LIT>': [<NUM_LIT:0.5>, <NUM_LIT:0.5>],<EOL>'<STR_LIT>': {'<STR_LIT>': <NUM_LIT:0>, '<STR_LIT>': <NUM_LIT:0>},<EOL>}<EOL>return attrs.get(attrName)<EOL>
Return the attributes of the node. The list below shows the most used basic attributes used during while writing
test code. The implementation class should return the corresponding value as soon as it retrieves its value. If
the value cannot be determined, the default value is obtained from super class invocation and returned.  See the
example below for more detailed information. More attributes can be added in order to enhance the selection
and displaying in ``Inspector``.

The most used basic attributes are listed as follows:

- ``name``: name of the node, use the unique and meaningful name for each node is recommended
- ``type``: type of the name of the node, it can be either any string, e.g. "android.widget.Button" or just
  simple as "Button"
- ``visible``: True or False whether the node is rendered on screen. In case the return value is False, all
  children nodes are ignored in Poco selector
- ``pos``: position of the node in screen, return value should be 2-list coordinates (x, y) representing
  the percentage of the screen. e.g. if the node lies in the center of the screen, the attribute will be
  ``[0.5f, 0.5f]``. If the returned value for position is negative, it means the node lies out of the screen
- ``size``: size of the node bounding box, similar to ``pos``, value is also a 2-list of the percentage of
  the screen size, e.g. the screen size is always ``[1.0f, 1.0f]``,
  if the node lies in left half side of the screen, its size will be ``[0.5f, 1.0f]``, the returned value of
  size should be always positive value
- ``scale``: scale factor applied to the node itself, leave it ``[1.0f, 1.0f]`` by default
- ``anchorPoint``: 2-list coordinates (x, y) of the anchor expressed in the percentage related to the bounding
  box of the node, leave it ``[0.5f, 0.5f]`` by default.
- ``zOrders``: rendering order of this node, its value is a dictionary such as ``{"global": 0, "local": 0}``,
  global zOrder value is compared with all nodes in the hierarchy, local zOrder value is compared with its
  parent and siblings. The most top nodes have the largest values.

Examples:
    The following sample code demonstrates some ideas about the implementation of this method::

        def getAttr(self, attrName):
            # basic attributes
            if attrName == 'name':
                return self.node.get_name() or '<no name>'

            elif attrName == 'pos':
                return self.node.get_position()

            # ...

            # extra engine-specific attributes
            elif attrName == 'rotation':
                return self.node.get_rotation()

            # call the super method by default
            else:
                return super().getAttr(attrName)

Args:
    attrName (:obj:`str`): attribute name

Returns:
    JsonSerializable attribute value or None if no such attribute.