| 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 |  |  |  |