Source Code for Module advene.model.core.import_

  1  """ 
  2  I define the class Import. 
  3  """ 
  4   
  5  from advene.model.exceptions import ModelError, UnreachableImportError 
  6  from advene.model.core.group import GroupMixin 
  7  from advene.model.core.element import PackageElement, IMPORT 
  8  from advene.util.autoproperty import autoproperty 
  9   
 10 -class Import(PackageElement, GroupMixin): 
 11   
 12      ADVENE_TYPE = IMPORT 
 13   
 14      # attributes that do not prevent imports to be volatile 
 15      _url = None 
 16      _uri = None 
 17      _imported = None 
 18   
 19      @classmethod 
 20 -    def instantiate(cls, owner, id, url, uri, *args): 
 21          r = super(Import, cls).instantiate(owner, id, id, url, uri, *args) 
 22          r._url = url 
 23          r._uri = uri 
 24          r._imported = owner._imports_dict.get(id) 
 25          return r 
 26   
 27      @classmethod 
 28 -    def create_new(cls, owner, id, package): 
 29          if id in owner._imports_dict: 
 30              # we can not wait for the backend to check that, 
 31              # because we will only create the import element in the backend 
 32              # when the internal structures of the packages are successfuly 
 33              # updated, so we need to be sure everything is ok 
 34              raise ModelError("Already have an import named %s" % id) 
 35          if package is owner: 
 36              raise ModelError("A package cannot import itself") 
 37          if [ p for p in owner._imports_dict.itervalues() 
 38                       if p is not None and 
 39                        (p.url == package.url or p.uri and p.uri == package.uri) 
 40          ]: 
 41              raise ModelError("Package already imported", p) 
 42   
 43          url, uri = package.url, package.uri # may access the backend 
 44          owner._imports_dict[id] = package 
 45          owner._update_backends_dict() 
 46          package._importers[owner] = id 
 47   
 48          owner._backend.create_import(owner._id, id, url, uri) 
 49          r = cls.instantiate(owner, id, url, uri) 
 50          return r 
 51   
 52 -    def delete(self): 
 53          super(Import, self).delete() 
 54          o = self._owner 
 55          del o._imports_dict[self._id] 
 56          del self._imported._importers[o] 
 57          o._update_backends_dict() 
 58   
 59      @autoproperty 
 60 -    def _get_url(self): 
 61          """ 
 62          The URL to which this import fetches the imported package. 
 63          """ 
 64          return self._url 
 65   
 66      @autoproperty 
 67 -    def _set_url(self, url): 
 68          assert url, "URL cannot be empty" 
 69          self.emit("pre-modified::url", "url", url) 
 70          self._url = url 
 71          self.__store() 
 72          self.emit("modified::url", "url", url) 
 73   
 74      @autoproperty 
 75 -    def _get_uri(self): 
 76          """ 
 77          The URI identifying the imported package. 
 78   
 79          It may be different from the physical URL from which the imported 
 80          package has actually been fetched. 
 81          """ 
 82          return self._uri 
 83   
 84      @autoproperty 
 85 -    def _set_uri(self, uri): 
 86          self.emit("pre-modified::uri", "uri", uri) 
 87          self._uri = uri 
 88          self.__store() 
 89          self.emit("modified::uri", "uri", uri) 
 90   
 91      @autoproperty 
 92 -    def _get_package(self): 
 93          if not self._imported: 
 94              raise UnreachableImportError(self._id) 
 95          else: 
 96              return self._imported 
 97   
 98 -    def __store(self): 
 99          o = self._owner 
100          o._backend.update_import(o._id, self._id, self._url, self._uri) 
101   
102 -    def __contains__(self, element): 
103          if not self._imported: 
104              raise UnreachableImportError(self._id) 
105          return element in self._imported.own 
106   
107      # group interface 
108   
109 -    def iter_medias(self): 
110          if not self._imported: 
111              raise UnreachableImportError(self._id) 
112          return self._imported.own.iter_medias() 
113   
114 -    def iter_annotations(self): 
115          if not self._imported: 
116              raise UnreachableImportError(self._id) 
117          return self._imported.own.iter_annotations() 
118   
119 -    def iter_relations(self): 
120          if not self._imported: 
121              raise UnreachableImportError(self._id) 
122          return self._imported.own.iter_relations() 
123   
124 -    def iter_views(self): 
125          if not self._imported: 
126              raise UnreachableImportError(self._id) 
127          return self._imported.own.iter_views() 
128   
129 -    def iter_resources(self): 
130          if not self._imported: 
131              raise UnreachableImportError(self._id) 
132          return self._imported.own.iter_resources() 
133   
134 -    def iter_tags(self): 
135          if not self._imported: 
136              raise UnreachableImportError(self._id) 
137          return self._imported.own.iter_tags() 
138   
139 -    def iter_lists(self): 
140          if not self._imported: 
141              raise UnreachableImportError(self._id) 
142          return self._imported.own.iter_lists() 
143   
144 -    def iter_imports(self): 
145          if not self._imported: 
146              raise UnreachableImportError(self._id) 
147          return self._imported.own.iter_imports() 
148   
149 -    def iter_queries(self): 
150          if not self._imported: 
151              raise UnreachableImportError(self._id) 
152          return self._imported.own.iter_queries() 
153   
154 -    def count_medias(self): 
155          if not self._imported: 
156              raise UnreachableImportError(self._id) 
157          return self._imported.own.count_medias() 
158   
159 -    def count_annotations(self): 
160          if not self._imported: 
161              raise UnreachableImportError(self._id) 
162          return self._imported.own.count_annotations() 
163   
164 -    def count_relations(self): 
165          if not self._imported: 
166              raise UnreachableImportError(self._id) 
167          return self._imported.own.count_relations() 
168   
169 -    def count_views(self): 
170          if not self._imported: 
171              raise UnreachableImportError(self._id) 
172          return self._imported.own.count_views() 
173   
174 -    def count_resources(self): 
175          if not self._imported: 
176              raise UnreachableImportError(self._id) 
177          return self._imported.own.count_resources() 
178   
179 -    def count_tags(self): 
180          if not self._imported: 
181              raise UnreachableImportError(self._id) 
182          return self._imported.own.count_tags() 
183   
184 -    def count_lists(self): 
185          if not self._imported: 
186              raise UnreachableImportError(self._id) 
187          return self._imported.own.count_lists() 
188   
189 -    def count_imports(self): 
190          if not self._imported: 
191              raise UnreachableImportError(self._id) 
192          return self._imported.own.count_imports() 
193   
194 -    def count_queries(self): 
195          if not self._imported: 
196              raise UnreachableImportError(self._id) 
197          return self._imported.own.count_queries() 
198   
199      # dict interface 
200   
201 -    def __getitem__ (self, i): 
202          if not self._imported: 
203              raise UnreachableImportError(self._id) 
204          return self._imported[i] 
205   
206 -    def get(self, i, default=None): 
207          if not self._imported: 
208              raise UnreachableImportError(self._id) 
209          return self._imported.get(i, default) 
210