| 
                    1
                 | 
                                    
                                                     | 
                
                 | 
                """Contains the class representing a triple node."""  | 
            
            
                                                                                                            
                            
            
                                    
            
            
                | 
                    2
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                                                                            
                            
            
                                    
            
            
                | 
                    3
                 | 
                                    
                             1                          | 
                
                 | 
                from .abstractnode import register, AbstractNode  | 
            
            
                                                                                                            
                            
            
                                    
            
            
                | 
                    4
                 | 
                                    
                             1                          | 
                
                 | 
                from .list import List  | 
            
            
                                                                                                            
                                                                
            
                                    
            
            
                | 
                    5
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    6
                 | 
                                    
                             1                          | 
                
                 | 
                @register  | 
            
            
                                                        
            
                                    
            
            
                | 
                    7
                 | 
                                    
                             1                          | 
                
                 | 
                class Triple(AbstractNode):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    8
                 | 
                                    
                                                     | 
                
                 | 
                    """Represents a triple.  | 
            
            
                                                        
            
                                    
            
            
                | 
                    9
                 | 
                                    
                                                     | 
                
                 | 
                    https://github.com/ProjetPP/Documentation/blob/master/data-model.md#triple  | 
            
            
                                                        
            
                                    
            
            
                | 
                    10
                 | 
                                    
                                                     | 
                
                 | 
                    """  | 
            
            
                                                        
            
                                    
            
            
                | 
                    11
                 | 
                                    
                             1                          | 
                
                 | 
                    __slots__ = ()  | 
            
            
                                                        
            
                                    
            
            
                | 
                    12
                 | 
                                    
                             1                          | 
                
                 | 
                    _type = 'triple'  | 
            
            
                                                        
            
                                    
            
            
                | 
                    13
                 | 
                                    
                             1                          | 
                
                 | 
                    _possible_attributes = ('subject', 'predicate', 'object', 'inverse_predicate') | 
            
            
                                                        
            
                                    
            
            
                | 
                    14
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    15
                 | 
                                    
                             1                          | 
                
                 | 
                    def _check_attributes(self, attributes):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    16
                 | 
                                    
                             1                          | 
                
                 | 
                        attributes['inverse_predicate'] = \  | 
            
            
                                                        
            
                                    
            
            
                | 
                    17
                 | 
                                    
                                                     | 
                
                 | 
                                attributes.get('inverse_predicate', List([])) | 
            
            
                                                        
            
                                    
            
            
                | 
                    18
                 | 
                                    
                             1                          | 
                
                 | 
                        super(Triple, self)._check_attributes(attributes)  | 
            
            
                                                        
            
                                    
            
            
                | 
                    19
                 | 
                                    
                             1                          | 
                
                 | 
                        if not all(isinstance(x, AbstractNode) for x in attributes.values()):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    20
                 | 
                                    
                             1                          | 
                
                 | 
                            raise TypeError('One of Triple\'s constructor argument ' | 
            
            
                                                        
            
                                    
            
            
                | 
                    21
                 | 
                                    
                                                     | 
                
                 | 
                                            'is not an AbstractNode instance.')  | 
            
            
                                                        
            
                                    
            
            
                | 
                    22
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    23
                 | 
                                    
                             1                          | 
                
                 | 
                    def as_dict(self):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    24
                 | 
                                    
                                                     | 
                
                 | 
                        """Do not put inverse-predicate in the output dict if it  | 
            
            
                                                        
            
                                    
            
            
                | 
                    25
                 | 
                                    
                                                     | 
                
                 | 
                        is an empty list."""  | 
            
            
                                                        
            
                                    
            
            
                | 
                    26
                 | 
                                    
                             1                          | 
                
                 | 
                        d = super(Triple, self).as_dict()  | 
            
            
                                                        
            
                                    
            
            
                | 
                    27
                 | 
                                    
                             1                          | 
                
                 | 
                        if d['inverse-predicate']['type'] == 'list' and \  | 
            
            
                                                        
            
                                    
            
            
                | 
                    28
                 | 
                                    
                                                     | 
                
                 | 
                                d['inverse-predicate']['list'] == []:  | 
            
            
                                                        
            
                                    
            
            
                | 
                    29
                 | 
                                    
                             1                          | 
                
                 | 
                            del d['inverse-predicate']  | 
            
            
                                                        
            
                                    
            
            
                | 
                    30
                 | 
                                    
                             1                          | 
                
                 | 
                        return d  | 
            
            
                                                        
            
                                    
            
            
                | 
                    31
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    32
                 | 
                                    
                             1                          | 
                
                 | 
                    @property  | 
            
            
                                                        
            
                                    
            
            
                | 
                    33
                 | 
                                    
                                                     | 
                
                 | 
                    def predicate_set(self):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    34
                 | 
                                    
                                                     | 
                
                 | 
                        """Return a frozenset of predicates, extracting it from the list  | 
            
            
                                                        
            
                                    
            
            
                | 
                    35
                 | 
                                    
                                                     | 
                
                 | 
                        if it is a List node."""  | 
            
            
                                                        
            
                                    
            
            
                | 
                    36
                 | 
                                    
                             1                          | 
                
                 | 
                        if isinstance(self.predicate, List):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    37
                 | 
                                    
                             1                          | 
                
                 | 
                            return frozenset(self.predicate.list)  | 
            
            
                                                        
            
                                    
            
            
                | 
                    38
                 | 
                                    
                                                     | 
                
                 | 
                        else:  | 
            
            
                                                        
            
                                    
            
            
                | 
                    39
                 | 
                                    
                             1                          | 
                
                 | 
                            return frozenset({self.predicate}) | 
            
            
                                                        
            
                                    
            
            
                | 
                    40
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    41
                 | 
                                    
                             1                          | 
                
                 | 
                    @property  | 
            
            
                                                        
            
                                    
            
            
                | 
                    42
                 | 
                                    
                                                     | 
                
                 | 
                    def inverse_predicate_set(self):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    43
                 | 
                                    
                                                     | 
                
                 | 
                        """Return a frozenset of inverse predicates, extracting it from the list  | 
            
            
                                                        
            
                                    
            
            
                | 
                    44
                 | 
                                    
                                                     | 
                
                 | 
                        if it is a List node."""  | 
            
            
                                                        
            
                                    
            
            
                | 
                    45
                 | 
                                    
                                                     | 
                
                 | 
                        if isinstance(self.inverse_predicate, List):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    46
                 | 
                                    
                                                     | 
                
                 | 
                            return frozenset(self.inverse_predicate.list)  | 
            
            
                                                        
            
                                    
            
            
                | 
                    47
                 | 
                                    
                                                     | 
                
                 | 
                        else:  | 
            
            
                                                        
            
                                    
            
            
                | 
                    48
                 | 
                                    
                                                     | 
                
                 | 
                            return frozenset({self.inverse_predicate}) | 
            
            
                                                        
            
                                    
            
            
                | 
                    49
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    50
                 | 
                                    
                             1                          | 
                
                 | 
                    def inverse(self):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    51
                 | 
                                    
                             1                          | 
                
                 | 
                        return self.__class__(self.object, self.inverse_predicate,  | 
            
            
                                                        
            
                                    
            
            
                | 
                    52
                 | 
                                    
                                                     | 
                
                 | 
                                self.subject, self.predicate)  | 
            
            
                                                        
            
                                    
            
            
                | 
                    53
                 | 
                                    
                                                     | 
                
                 | 
                 |