Show More
@@ -225,7 +225,7 b' class Exporter(Configurable):' | |||
|
225 | 225 | return self.from_notebook_node(nbformat.read(file_stream, 'json'), resources=resources, **kw) |
|
226 | 226 | |
|
227 | 227 | |
|
228 |
def register_transformer(self, transformer, enabled= |
|
|
228 | def register_transformer(self, transformer, enabled=False): | |
|
229 | 229 | """ |
|
230 | 230 | Register a transformer. |
|
231 | 231 | Transformers are classes that act upon the notebook before it is |
@@ -237,33 +237,39 b' class Exporter(Configurable):' | |||
|
237 | 237 | ---------- |
|
238 | 238 | transformer : transformer |
|
239 | 239 | """ |
|
240 | if transformer is None: | |
|
241 | raise TypeError('transformer') | |
|
242 | isclass = inspect.isclass(transformer) | |
|
243 | constructed = not isclass | |
|
240 | 244 | |
|
241 | 245 | #Handle transformer's registration based on it's type |
|
242 | if inspect.isfunction(transformer): | |
|
246 | if constructed and isinstance(transformer, types.StringTypes): | |
|
247 | #Transformer is a string, import the namespace and recursively call | |
|
248 | #this register_transformer method | |
|
249 | transformer_cls = import_item(transformer) | |
|
250 | return self.register_transformer(transformer_cls, enabled) | |
|
251 | ||
|
252 | if constructed and hasattr(transformer, '__call__'): | |
|
243 | 253 | #Transformer is a function, no need to construct it. |
|
254 | #Register and return the transformer. | |
|
255 | if enabled: | |
|
256 | transformer.enabled = True | |
|
244 | 257 | self._transformers.append(transformer) |
|
245 | 258 | return transformer |
|
246 | 259 | |
|
247 |
elif isinstance(transformer, |
|
|
248 | #Transformer is a string, import the namespace and recursively call | |
|
249 | #this register_transformer method | |
|
250 | transformer_cls = import_item(DottedObjectName(transformer)) | |
|
251 | return self.register_transformer(transformer_cls, enabled=None) | |
|
252 | ||
|
253 | elif isinstance(transformer, MetaHasTraits): | |
|
260 | elif isclass and isinstance(transformer, MetaHasTraits): | |
|
254 | 261 | #Transformer is configurable. Make sure to pass in new default for |
|
255 | 262 | #the enabled flag if one was specified. |
|
256 |
transformer |
|
|
257 | if enabled is not None: | |
|
258 | transformer_instance.enabled = True | |
|
263 | self.register_transformer(transformer(parent=self), enabled) | |
|
259 | 264 | |
|
260 |
el |
|
|
265 | elif isclass: | |
|
261 | 266 | #Transformer is not configurable, construct it |
|
262 |
transformer |
|
|
267 | self.register_transformer(transformer(), enabled) | |
|
263 | 268 | |
|
264 | #Register and return the transformer. | |
|
265 | self._transformers.append(transformer_instance) | |
|
266 | return transformer_instance | |
|
269 | else: | |
|
270 | #Transformer is an instance of something without a __call__ | |
|
271 | #attribute. | |
|
272 | raise TypeError('transformer') | |
|
267 | 273 | |
|
268 | 274 | |
|
269 | 275 | def register_filter(self, name, filter): |
@@ -278,16 +284,36 b' class Exporter(Configurable):' | |||
|
278 | 284 | name to give the filter in the Jinja engine |
|
279 | 285 | filter : filter |
|
280 | 286 | """ |
|
281 | if inspect.isfunction(filter): | |
|
287 | if filter is None: | |
|
288 | raise TypeError('filter') | |
|
289 | isclass = inspect.isclass(filter) | |
|
290 | constructed = not isclass | |
|
291 | ||
|
292 | #Handle filter's registration based on it's type | |
|
293 | if constructed and isinstance(filter, types.StringTypes): | |
|
294 | #filter is a string, import the namespace and recursively call | |
|
295 | #this register_filter method | |
|
296 | filter_cls = import_item(filter) | |
|
297 | return self.register_filter(name, filter_cls) | |
|
298 | ||
|
299 | if constructed and hasattr(filter, '__call__'): | |
|
300 | #filter is a function, no need to construct it. | |
|
282 | 301 | self.environment.filters[name] = filter |
|
283 | elif isinstance(filter, types.StringTypes): | |
|
284 | filter_cls = import_item(DottedObjectName(filter)) | |
|
285 | self.register_filter(name, filter_cls) | |
|
286 | elif isinstance(filter, MetaHasTraits): | |
|
287 | self.environment.filters[name] = filter(config=self.config) | |
|
302 | return filter | |
|
303 | ||
|
304 | elif isclass and isinstance(filter, MetaHasTraits): | |
|
305 | #filter is configurable. Make sure to pass in new default for | |
|
306 | #the enabled flag if one was specified. | |
|
307 | self.register_filter(name, filter(parent=self)) | |
|
308 | ||
|
309 | elif isclass: | |
|
310 | #filter is not configurable, construct it | |
|
311 | self.register_filter(name, filter()) | |
|
312 | ||
|
288 | 313 | else: |
|
289 | self.environment.filters[name] = filter() | |
|
290 | return self.environment.filters[name] | |
|
314 | #filter is an instance of something without a __call__ | |
|
315 | #attribute. | |
|
316 | raise TypeError('filter') | |
|
291 | 317 | |
|
292 | 318 | |
|
293 | 319 | def _init_environment(self, extra_loaders=None): |
General Comments 0
You need to be logged in to leave comments.
Login now