Esempio n. 1
0
    def __init__(self, identifier, info, status_id, titles, year, files=None,
            plot=None, tagline=None):
        self._attr_from_init(locals())
        #print self.__class__.__bases__
        try:
            self.info = (self.info if isinstance(self.info, Info) 
                    else Info(**self.info))
        except TypeError, e:
            print e
            print len(self.info.keys()), identifier
            d, a = func_default_dict(Info.__init__)
            print [ x for x in self.info.keys() if x not in a.args ]
            print [ x for x in a.args[1:] if not d.has_key(x) and not
                    self.info.has_key(x) ]



            print identifier, self.info.keys()
        self.files = [ x if isinstance(x, File) else File(**x) for x in
                self.files ]

        self.titles = [ x if isinstance(x, Title) else Title(**x) for x in
                self.titles ]

    @property
    def default_title(self):
        if not self._default_title:
            for title in self.titles:
                if title.default:
                    self._default_title=title.title
                    break
        return self._default_title
Esempio n. 2
0
 def _attr_from_init(self,local=None):
     """
     The Couch Potato API has several different result structures.
     This allows rapid prototypid of objects based off the keys of
     the dictionary structures.
     Some of these are appropriate for later serialization via YAML
     in config files.
     Typical usage
     class foo(CouchPotatoDict):
         bar=1
         baz=2
         quf=0
         mung=None
         def __init__(self, bar, baz, quf=None, mung=None):
             self._attr_from_init(locals())
             if not isinstance(Mung, self.mung):
                 self.mung=Mung(**self.mung)
     """
     if not local:
         local = {}
     defaults, argspec = func_default_dict(self.__init__)
     for arg in argspec.args[1:]:
         if local.has_key(arg) and local[arg] != defaults.get(arg,None):
             if local[arg] != getattr(self, arg, None):
                 setattr(self, arg, local[arg])
Esempio n. 3
0
 def _make_query(cls, local):
     default_dict, argspec = func_default_dict(cls.make_query)
     query = tuple(
             (cls._unicode_fiddle(arg), cls._unicode_fiddle(local[arg])) 
             for arg in argspec.args[1:]
             if (local.has_key(arg) and 
                 local[arg] != default_dict.get(arg, None)))
     return query