← Back to branch summary

~ubuntu-branches/ubuntu/lucid/mythtv/lucid

« back to all changes in this revision

Viewing changes to bindings/python/MythTV/MythBase.py

  • Committer: Bazaar Package Importer
  • Author(s): Mario Limonciello, Dave Walker, Mario Limonciello
  • Date: 2010-02-27 14:33:45 UTC
  • mfrom: (1.1.48 upstream)
  • Revision ID: james.westby@ubuntu.com-20100227143345-qye52374g4b4caf9
Tags: 0.23.0~trunk23623-0ubuntu1
https://launchpad.net/bugs/524822
https://launchpad.net/bugs/527288
[ Dave Walker ]
* debian/control:  Added quilt as a build-depends, primarily
  for karmic builds.

[ Mario Limonciello ]
* New checkout (r23623).
  - Fixes audio issues w/ ac3 audio.
* debian/patches/36_setgroups_too:
  - Set the right args for setgroups. (LP: #524822)
* debian/rules:
  - Explicitly set all shell scripts executable.  Fixes problems on < lucid
    builds.
* debian/control:
  - Correct the replaces statements. (LP: #527288)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bindings/python/MythTV/MythBase.py
41
41
            -- or --
42
42
        obj['field_name']
43
43
    """
 
44
 
 
45
    class DictIterator( object ):
 
46
        def __init__(self, mode, parent):
 
47
            # modes = 1:keys, 2:values, 3:items
 
48
            self.index = 0
 
49
            self.mode = mode
 
50
            self.data = parent
 
51
        def __iter__(self): return self
 
52
        def next(self):
 
53
            self.index += 1
 
54
            if self.index > len(self.data.field_order):
 
55
                raise StopIteration
 
56
            key = self.data.field_order[self.index-1]
 
57
            if self.mode == 1:
 
58
                return key
 
59
            elif self.mode == 2:
 
60
                return self.data[key]
 
61
            elif self.mode == 3:
 
62
                return (key, self.data[key])
 
63
 
44
64
    logmodule = 'Python DictData'
45
65
    # class emulation functions
46
66
    def __getattr__(self,name):
83
103
        return bool(item in self.data.keys())
84
104
 
85
105
    def __iter__(self):
86
 
        return self.itervalues()
 
106
        return self.DictIterator(2,self)
87
107
        
88
108
    def iterkeys(self):
89
109
        """
90
110
        obj.iterkeys() -> an iterator over the keys of obj
91
111
                                                ordered by self.field_order
92
112
        """
93
 
        self.field = 0
94
 
        self.iterdata = self.keys()
95
 
        return self
 
113
        return self.DictIterator(1,self)
96
114
        
97
115
    def itervalues(self):
98
116
        """
99
117
        obj.itervalues() -> an iterator over the values of obj
100
118
                                                ordered by self.field_order
101
119
        """
102
 
        self.field = 0
103
 
        self.iterdata = self.values()
104
 
        return self
 
120
        return self.DictIterator(2,self)
105
121
    
106
122
    def iteritems(self):
107
123
        """
108
124
        obj.iteritems() -> an iterator of over the (key,value) pairs of obj
109
125
                                                ordered by self.field_order
110
126
        """
111
 
        self.field = 0
112
 
        self.iterdata = self.items()
113
 
        return self
 
127
        return self.DictIterator(3,self)
114
128
 
115
 
    def next(self):
116
 
        res = self.iterdata[self.field]
117
 
        self.field += 1
118
 
        if self.field == len(self.iterdata):
119
 
            del self.field
120
 
            del self.iterdata
121
 
            raise StopIteration
122
 
        return res
123
 
 
124
129
    def keys(self):
125
130
        """obj.keys() -> list of self.field_order"""
126
 
        return list(self.field_order)
 
131
        return list(self.iterkeys())
127
132
        
128
133
    def has_key(self,item):
129
134
        return self.__contains__(item)
130
135
        
131
136
    def values(self):
132
137
        """obj.values() -> list of values, ordered by self.field_order"""
133
 
        return [self.data[key] for key in self.field_order]
 
138
        return list(self.itervalues())
134
139
        
135
140
    def get(self,key):
136
141
        return self.data[key]
139
144
        """
140
145
        obj.items() -> list of (key,value) pairs, ordered by self.field_order
141
146
        """
142
 
        return [(key, self.data[key]) for key in self.field_order]
 
147
        return list(self.iteritems())
143
148
        
144
149
    def pop(self,key):
145
150
        raise NotImplementedError
344
349
        self._fillNone()
345
350
        self.data.update(self.defaults)
346
351
 
 
352
    def __init__(self, data=None, db=None, raw=None):
 
353
        DBData.__init__(self, data, db, raw)
 
354
        if raw is not None:
 
355
            self.origdata = self.data.copy()
 
356
 
347
357
    def create(self,data=None):
348
358
        """
349
359
        obj.create(data=None) -> new database row
992
1002
  </UPnP>
993
1003
</Configuration>
994
1004
""" % tuple(settings)
995
 
                fp = open(os.path.expanduser('~/.mythtv/config.xml'), 'w')
 
1005
                mythdir = os.path.expanduser('~/.mythtv')
 
1006
                if not os.access(mythdir, os.F_OK):
 
1007
                    os.mkdir(mythdir,0755)
 
1008
                fp = open(mythdir+'/config.xml', 'w')
996
1009
                fp.write(config)
997
1010
                fp.close()
998
1011
                
1757
1770
        MythDBBase.__init__(self, db=db)
1758
1771
        self.log = MythLog(self.logmodule, db=self)
1759
1772
        self.path = ''
1760
 
        if path:
 
1773
        if path is not None:
1761
1774
            self.path = path
1762
 
        elif setting:
1763
 
            self.path = self.settings[socket.gethostname()][setting]
 
1775
        elif setting is not None:
 
1776
            host = socket.gethostname()
 
1777
            self.path = self.settings[host][setting]
 
1778
            if self.path is None:
 
1779
                raise MythDBError(MythError.DB_SETTING, setting, host)
 
1780
        else:
 
1781
            raise MythError('Invalid input to Grabber()')
1764
1782
        self.returncode = 0
1765
1783
        self.stderr = ''
1766
1784