Пример #1
0
def random_phonebook_csv(minlength=0, maxlength=2000, maxfields=400):
    """Generate a random phonebook in CSV format
    @param minlength: minimum number of entries
    @param maxlength: maximum number of entries
    @returns:  a list of lists of the data.  the first row is the headers
    """
    
    possfields=["First Name", "Last Name", "Middle Name",
                "Name", "Nickname", "Email Address", "Web Page", "Fax", "Home Street",
                "Home City", "Home Postal Code", "Home State",
                "Home Country/Region",  "Home Phone", "Home Fax", "Mobile Phone", "Home Web Page",
                "Business Street", "Business City", "Business Postal Code",
                "Business State", "Business Country/Region", "Business Web Page",
                "Business Phone", "Business Fax", "Pager", "Company", "Notes", "Private",
                "Category", "Categories"]

    # some fields  use different types mostly
    types={ 'Fax': phonenumber, "Home Phone": phonenumber, "Home Fax": phonenumber, "Mobile Phone": phonenumber,
            "Business Phone": phonenumber, "Business Fax": phonenumber, "Pager": phonenumber,
            "Email Address": email, "Categories": categories, "Private": boolean }

    print "Generating phonebook",
    headers=[random.choice(possfields) for i in range(random.randrange(1,maxfields))]
    numrows=random.randrange(minlength, maxlength)
    print "with",len(headers),"columns and",numrows,"rows"

    op=[ headers ]

    for i in range(numrows):
        op.append([gen_string(choices=types.get(col, words)) for col in headers])

    print "  ... generation completed"
    return DSV.exportDSV(op, quoteall=random.choice([0,1]))
 def splitandunescape(self, line):
     """Split fields and unescape double quote and right brace"""
     col=line.find(": ")
     print line[col+2:]
     e=DSV.importDSV([line[col+2:]])[0]
     i=0
     while i<len(e):
         item=e[i]
         item=item.replace("}\002",'"')
         item=item.replace("}]","}")
         e[i]=item
         i+=1
     return e
Пример #3
0
def random_phonebook_csv(minlength=0, maxlength=2000, maxfields=400):
    """Generate a random phonebook in CSV format
    @param minlength: minimum number of entries
    @param maxlength: maximum number of entries
    @returns:  a list of lists of the data.  the first row is the headers
    """

    possfields = [
        "First Name", "Last Name", "Middle Name", "Name", "Nickname",
        "Email Address", "Web Page", "Fax", "Home Street", "Home City",
        "Home Postal Code", "Home State", "Home Country/Region", "Home Phone",
        "Home Fax", "Mobile Phone", "Home Web Page", "Business Street",
        "Business City", "Business Postal Code", "Business State",
        "Business Country/Region", "Business Web Page", "Business Phone",
        "Business Fax", "Pager", "Company", "Notes", "Private", "Category",
        "Categories"
    ]

    # some fields  use different types mostly
    types = {
        'Fax': phonenumber,
        "Home Phone": phonenumber,
        "Home Fax": phonenumber,
        "Mobile Phone": phonenumber,
        "Business Phone": phonenumber,
        "Business Fax": phonenumber,
        "Pager": phonenumber,
        "Email Address": email,
        "Categories": categories,
        "Private": boolean
    }

    print "Generating phonebook",
    headers = [
        random.choice(possfields)
        for i in range(random.randrange(1, maxfields))
    ]
    numrows = random.randrange(minlength, maxlength)
    print "with", len(headers), "columns and", numrows, "rows"

    op = [headers]

    for i in range(numrows):
        op.append(
            [gen_string(choices=types.get(col, words)) for col in headers])

    print "  ... generation completed"
    return DSV.exportDSV(op, quoteall=random.choice([0, 1]))
from DSV import DSV
import matplotlib.pyplot as plt
from numpy import *

csvfile='2.csv'

data = file(csvfile).read()
data = DSV.organizeIntoLines(data, textQualifier=None)
data = DSV.importDSV(data, delimiter=';', textQualifier=None)
# skip the headers
data=data[1:]


def dat(no):
    return array([float(d[no]) for d in data])

(t, tin, tout, door) = (dat(0), dat(1), dat(2), dat(3))

plt.figure(1)
plt.subplot(211)
plt.plot(t, tout, 'b-', t, tin, 'r-', door, 'g-')

plt.subplot(212)
plt.plot(t, tin-tout, 'c-')
plt.show()

	def splitandunescape(self, line):

        """Split fields and unescape double quote and right brace"""

        col=line.find(": ")

        print line[col+2:]

        e=DSV.importDSV([line[col+2:]])[0]

        i=0

        while i<len(e):

            item=e[i]

            item=item.replace("}\002",'"')

            item=item.replace("}]","}")

            e[i]=item

            i+=1

        return e

	def samsungescape(self, s):

        """Escape double quotes and }'s in a string"""

        return s

	def defrell(self, s, acol, ncol):

        """Fixes up phonebook responses with the alias field.  The alias field
        does not have quotes around it, but can still contain commas"""

        if acol<0 or acol>=ncol: 

            return s

        e=s.split(",")

        i=0

        while i<len(e):

            if len(e[i]) and e[i][0]=='"' and e[i][-1]!='"':

                while i+1<len(e) and (len(e[i+1])==0 or e[i+1][-1]!='"'):

                    e[i] += ","+e[i+1]

                    del e[i+1]

                else:

                    if i+1<len(e):

                        e[i] += ","+e[i+1]

                        del e[i+1]

            i+=1

        if len(e)<=ncol: 

            return s

        for k in range(len(e)-ncol):

            e[acol]+=","+e[acol+1]

            del e[acol+1]

        e[acol]='"'+e[acol]+'"' 

        res=e[0]

        for item in e[1:]:  

            res+=","+item

        return res

	def csvsplit(self, line):

        """Parse a Samsung comma separated list."""

        e=line.split(",")

        i=0

        print len(e)

        result=[]

        while i<len(e):

            if len(e[i]) and e[i][0]=='"' and e[i][-1]!='"':

                while i+1<len(e) and (len(e[i+1])==0 or e[i+1][-1]!='"'):

                    e[i] = e[i]+","+e[i+1]

                    del e[i+1]

                else:

                    if i+1<len(e):

                        e[i] = e[i]+","+e[i+1]

                        del e[i+1]

            item=e[i]

            if len(item)==0:

                t=0

            elif item[0]=='"' or item[-1]=='"':

                mo=re.match('^"?(.*?)"?$',item)

                item=mo.group(1)

                item=item.replace("}\002",'"')

                item=item.replace("}]","}")

                t='string'

            elif re.match('^\d+T\d+$',item):

                t='timestamp'

            elif re.match('^[\dPT]+$',item):

                t='number'

            elif re.match('^\(\d+-\d+\)',item):

                t='range'

            elif re.match('^\d\d?/\d\d?/\d\d(\d\d)?$',item):

                t='date'

            else:

                t='other'

            if t:

                result.append({'type':t, 'value':item})

            else:

                result.append(0)

            i+=1

        return result

	def getcalendar(self, result):

        self.log("Getting calendar entries")

        self.setmode(self.MODEPHONEBOOK)

        res={}

        l=len(self._cal_entries_range)

        cal_cnt=0

        for k in self._cal_entries_range:

            r=self.get_calendar_entry(k)

            if not len(r):

                self.progress(k+1, l, "Getting blank entry: %d"%k)

                continue

            self.progress(k+1, l, "Getting "+r[self._cal_read_name])

            entry=bpcalendar.CalendarEntry()

            entry.start=self.extract_timedate(r[self._cal_start_datetime])

            if self._cal_end_datetime_value is None:

                entry.end=self.extract_timedate(r[self._cal_end_datetime])

            else:

                entry.end=entry.start

            entry.description=r[self._cal_read_name]

            try:

                alarm=self._cal_alarm_values[r[self._cal_alarm_type]]

            except:

                alarm=None

            entry.alarm=alarm

            res[entry.id]=entry

            cal_cnt += 1

        result['calendar']=res

        self.setmode(self.MODEMODEM)

        return result

	def process_calendar(self, dict):

        """ Optimize and expand calendar data suitable for phone download
        """

        r={}

        rp=[]

        today=datetime.date.today()

        last_date=today

        if __debug__:

            print 'original calendar:'

        for k,e in dict.items():

            if __debug__:

                print e.description,':',e.start

            sd=datetime.date(*e.start[:3])

            ed=datetime.date(*e.end[:3])

            if ed>last_date:

                last_date=ed

            if e.repeat is None:

                if sd>=today:

                    r.setdefault(e.start[:3], []).append(Samsung_Calendar(e))

            else:

                if ed>=today:

                    rp.append(e)

        delta_1=datetime.timedelta(1)

        for n in rp:

            current_date=today

            end_date=datetime.date(*n.end[:3])

            cnt=0

            while current_date<=end_date:

                if n.is_active(current_date.year, current_date.month,
                               current_date.day):

                    cd_l=(current_date.year, current_date.month,
                          current_date.day)

                    r.setdefault(cd_l, []).append(\
                                      Samsung_Calendar(n, cd_l))

                    cnt+=1

                    if cnt>self._cal_max_events:

                        break

                current_date+=delta_1

        res=[]

        keys=r.keys()

        keys.sort()

        for k in keys:

            r[k].sort()

            if len(r[k])>self._cal_max_events_per_day:

                res+=r[k][:self._cal_max_events_per_day]

            else:

                res+=r[k]

        if len(res)>self._cal_max_events:

            res=res[:self._cal_max_events]

        return res

	def savecalendar(self, dict, merge):

        self.log("Sending calendar entries")

        cal=self.process_calendar(dict['calendar'])

        if __debug__:

            print 'processed calendar: ', len(cal), ' items'

            for c in cal:

                print c.description,':', c.start

        self.setmode(self.MODEPHONEBOOK)

        self.log("Saving calendar entries")

        cal_cnt=0

        l=self._cal_max_events

        for c in cal:

            e=['']*self._cal_num_of_write_fields

            e[self._cal_entry]=`cal_cnt`

            e[self._cal_start_datetime]=self.encode_timedate(c.start)

            if self._cal_end_datetime_value is None:

                e[self._cal_end_datetime]=self.encode_timedate(c.end)

            else:

                e[self._cal_end_datetime]=self._cal_end_datetime_value

            e[self._cal_datetime_stamp]=self.get_time_stamp()

            e[self._cal_alarm_type]=c.alarm

            name=c.description.replace('"', '')

            if len(name)>self._cal_max_name_len:

                name=name[:self._cal_max_name_len]

            e[self._cal_write_name]='"'+name+'"'

            self.progress(cal_cnt+1, l, "Updating "+name)

            if not self.save_calendar_entry(",".join(e)):

                self.log("Failed to save item: "+name)

            else:

                cal_cnt += 1

        self.log('Deleting unused entries')

        for k in range(cal_cnt, l):

            self.progress(k, l, "Deleting entry %d" % k)

            self.save_calendar_entry(`k`)

        self.setmode(self.MODEMODEM)

        return dict

	def _getmemo(self, result):

        self.setmode(self.MODEPHONEBOOK)

        m=MemoList(self)

        m.read()

        m_dict=m.get()

        result['memo']=m_dict

        self.setmode(self.MODEMODEM)

        return m_dict

	def _savememo(self, result, merge):

        self.setmode(self.MODEPHONEBOOK)

        m=MemoList(self)

        r=result.get('memo', {})

        m.set(r)

        m.write()

        self.setmode(self.MODEMODEM)

        return r

	def _gettodo(self, result):

        self.log("Getting todo entries")

        self.setmode(self.MODEPHONEBOOK)

        td_l=TodoList(self)

        td_l.read()

        result['todo']=td_l.get()

        self.setmode(self.MODEMODEM)

        return result

	def _savetodo(self, result, merge):

        self.log("Saving todo entries")

        self.setmode(self.MODEPHONEBOOK)

        td_l=TodoList(self, result.get('todo', {}))

        td_l.validate()

        td_l.write()

        self.setmode(self.MODEMODEM)

        return result

	def _getsms(self, result):

        self.log("Getting SMS entries")

        self.setmode(self.MODEPHONEBOOK)

        sms_l=SMSList(self)

        sms_l.read()

        result['sms']=sms_l.get()

        sms_canned=CannedMsgList(self)

        sms_canned.read()

        result['canned_msg']=sms_canned.get()

        self.setmode(self.MODEMODEM)

        return result

	def _savesms(self, result, merge):

        self.log("Saving SMS Canned Messages")

        self.setmode(self.MODEPHONEBOOK)

        canned_msg=CannedMsgList(self, result.get('canned_msg', {}))

        canned_msg.write()

        self.setmode(self.MODEMODEM)

        return result

	def _getphoneinfo(self, phone_info):

        self.log('Getting Phone Info')

        self.setmode(self.MODEPHONEBOOK)

        for e in phoneinfo.PhoneInfo.standard_keys:

            f=getattr(self, 'get_'+e[0])

            setattr(phone_info, e[0], f())

        phone_info.append('Analog/Digital:', self.get_analog_digital())

        self.setmode(self.MODEMODEM)

	def _send_at_and_get(self, cmd):

        try:

            resp=self.comm.sendatcommand(cmd)

            return ': '.join(resp[0].split(': ')[1:])

        except:

            return None

	def is_mode_modem(self):

        try:

            resp=self.comm.sendatcommand('E0V1')

            return True

        except:

            return False

	def get_detect_data(self, r):

        r['manufacturer']=self._send_at_and_get('+GMI')

        r['model']=self._send_at_and_get('+GMM')

        r['firmware_version']=self._send_at_and_get('+GMR')

        r['esn']=self._send_at_and_get('+GSN')

	def _detectphone(coms, likely_ports, res, _module, _log):

        if not len(likely_ports):

            return None

        for port in likely_ports:

            if not res.has_key(port):

                res[port]={ 'mode_modem': None, 'mode_brew': None,
                            'manufacturer': None, 'model': None,
                            'firmware_version': None, 'esn': None,
                            'firmwareresponse': None }

            try:

                if res[port]['mode_modem']==False or \
                   res[port]['model']:

                    continue

                p=Phone(_log, commport.CommConnection(_log, port, timeout=1))

                if p.is_mode_modem():

                    res[port]['mode_modem']=True

                    p.get_detect_data(res[port])

                else:

                    res[port]['mode_modem']=False

            except:

                if __debug__:

                    raise

	_detectphone=staticmethod(_detectphone)
	"Talk to a Samsung phone using AT commands"

class  Profile (com_phone.Profile) :
	BP_Calendar_Version=3
	    serialsname='samsung'
	    usbids=( ( 0x04e8, 0x6601, 1),  
        )
	    deviceclasses=("modem", "serial")
	    _supportedsyncs=()
	    def __init__(self):

        com_phone.Profile.__init__(self)


class  Samsung_Calendar :
	_cal_alarm_values={
        '0': -1, '1': 0, '2': 10, '3': 30, '4': 60 }
	    def __init__(self, calendar_entry, new_date=None):

        self._start=self._end=self._alarm=self._desc=None

        self._extract_cal_info(calendar_entry, new_date)

	def _extract_cal_info(self, cal_entry, new_date):

        s=cal_entry.start

        if new_date is not None:

            s=new_date[:3]+s[3:]

        self._start=s

        self._end=cal_entry.end

        self._desc=cal_entry.description

        self._alarm='0'

        alarm=cal_entry.alarm

        _keys=self._cal_alarm_values.keys()

        _keys.sort()

        _keys.reverse()

        for k in _keys:

            if alarm>=self._cal_alarm_values[k]:

                self._alarm=k

                break

	def __lt__(self, rhs):

        return self.start<rhs.start

	def __le__(self, rhs):

        return self.start<=rhs.start

	def __eq__(self, rhs):

        return self.start==rhs.start

	def __ne__(self, rhs):

        return self.start!=rhs.start

	def __gt__(self, rhs):

        return self.start>rhs.start

	def __ge__(self, rhs):

        return self.start>=rhs.start

	def _get_start(self):

        return self._start

	start=property(fget=_get_start)
	    def _get_end(self):

        return self._end

	end=property(fget=_get_end)
	    def _get_desc(self):

        return self._desc

	description=property(fget=_get_desc)
	    def _get_alarm(self):

        return self._alarm

	alarm=property(fget=_get_alarm)

class  MemoList (object) :
	_max_num_entries=10
	    _range_entries=xrange(_max_num_entries)
	    _max_text_len=60
	    _max_subject_len=12
	    _max_num_of_fields=4
	    _text_index=3
	    _date_index=1
	    _max_write_fields=3
	    _write_entry_index=0
	    _write_date_index=1
	    _write_text_index=2
	    _continuation_char='-'
	    def __init__(self, phone):

        self._phone=phone

        self._data={}

	def get(self):

        return copy.deepcopy(self._data, {})

	def read(self):

        self._data={}

        text=''

        for i in self._range_entries:

            try:

                self._phone.progress(i, self._max_num_entries,
                                      'Reading Memo Entry: '+str(i))

                s=self._phone.get_memo_entry(i)

                if len(s)!=self._max_num_of_fields:

                    continue

                t=s[self._text_index]

                if len(t)==self._max_text_len and \
                   t[-1]==self._continuation_char:

                    text+=t[:len(t)-1]

                    continue

                text+=t

                m=memo.MemoEntry()

                m.text=text

                m.set_date_isostr(s[self._date_index])

                self._data[m.id]=m

                text=''

            except:

                if __debug__: raise

	def write(self):

        keys=self._data.keys()

        keys.sort()

        count=0

        for k in keys:

            if count>=self._max_num_entries:

                self._phone.log('Max number of memos sent')

                break

            n=self._data[k]

            text=n.text

            subj=n.subject

            l=min(self._max_subject_len, len(text))

            if subj[:l]!=text[:l]:

                text=subj+':'+text

            text.replace('"', '')

            while len(text) and count<self._max_num_entries:

                if len(text)>self._max_text_len:

                    sub_text=text[:self._max_text_len-1]+self._continuation_char

                    text=text[self._max_text_len-1:]

                else:

                    sub_text=text

                    text=''

                entry_str=['']*self._max_write_fields

                entry_str[self._write_entry_index]=`count`

                entry_str[self._write_date_index]=self._phone.get_time_stamp()

                entry_str[self._write_text_index]='"'+sub_text+'"'

                self._phone.progress(count, self._max_num_entries,
                                      'Writing Memo Entry: '+str(count))

                if self._phone.save_memo_entry(','.join(entry_str)):

                    self._phone.log('Sent memo %s to the phone'%subj)

                    count+=1

                else:

                    self._phone.log("Failed to send memo"+subj)

        for k in xrange(count, self._max_num_entries):

            self._phone.progress(k, self._max_num_entries,
                                  'Deleing Memo Entry: '+str(k))

            self._phone.save_memo_entry(`k`)

	def set(self, data):

        self._data={}

        self._data.update(data)


class  TodoList (object) :
	_td_max_read_fields=6
	    _td_max_write_fields=5
	    _td_max_entries=20
	    _td_entry=0
	    _td_priority=1
	    _td_due_datetime=2
	    _td_datetime_stamp=3
	    _td_status=4
	    _td_subject=5
	    _td_write_subject=4
	    _td_max_len_name=32
	    def __init__(self, phone, data={}):

        self._phone=phone

        self._data=data

	def get(self):

        return copy.deepcopy(self._data, {})

	def _extract_fields(self, s):

        entry=todo.TodoEntry()

        i=int(s[self._td_priority])

        if i:

            entry.priority=1

        else:

            entry.priority=10

        entry.due_date=s[self._td_due_datetime][:8]

        entry.summary=s[self._td_subject]

        return entry

	def read(self):

        self._data={}

        cnt=0

        for i in xrange(self._td_max_entries):

            s=self._phone.get_todo_entry(i)

            if not len(s):

                self._phone.progress(i+1, self._td_max_entries,
                                      'Getting blank entry: '+str(i))

                continue

            self._phone.progress(i+1, self._td_max_entries, s[self._td_subject])

            e=self._extract_fields(s)

            self._data[e.id]=e

	def _encode_fields(self, i, entry):

        e=['']*self._td_max_write_fields

        e[self._td_entry]=`i`

        if entry.priority is not None and entry.priority<5:

            e[self._td_priority]='1'

        else:

            e[self._td_priority]='0'

        s=entry.due_date

        if s is None or not len(s):

            s=self._phone.get_time_stamp()

        else:

            s+='T000000'

        e[self._td_due_datetime]=s

        e[self._td_datetime_stamp]=self._phone.get_time_stamp()

        e[self._td_write_subject]='"'+entry.summary+'"'

        return ','.join(e)

	def _write_entry(self, i, entry):

        return self._phone.save_todo_entry(self._encode_fields(i, entry))

	def validate(self):

        for k,n in self._data.items():

            name=n.summary.replace('"', '')

            if len(name)>self._td_max_len_name:

                name=name[:self._td_max_len_name]

            n.summary=name

	def write(self):

        keys=self._data.keys()

        keys.sort()

        cnt=0

        for k in keys:

            n=self._data[k]

            if cnt>self._td_max_entries:

                break

            if self._write_entry(cnt, n):

                cnt += 1

            else:

                self._phone.log('Failed to save todo entry '+str(k))

            self._phone.progress(cnt, self._td_max_entries, 'Saving entry: '+n.summary)

        for i in xrange(cnt, self._td_max_entries):

            self._phone.progress(i, self._td_max_entries, 'Deleting entry: '+str(i))

            self._phone.save_todo_entry(`i`)


class  SMS_Generic_List (object) :
	def __init__(self, phone):

        self._phone=phone

        self._data={}

	def get(self):

        return self._data.copy()

	def read(self):

        raise NotImplementedError


class  SMS_Inbox_List (SMS_Generic_List) :
	_max_entries=100
	    _valid_range=xrange(_max_entries)
	    _datetime_index=3
	    _body_index=4
	    _callback_index=5
	    _field_num=6
	    def __init__(self, phone):

        super(SMS_Inbox_List, self).__init__(phone)

	def read(self):

        for i in self._valid_range:

            self._phone.progress(i, self._max_entries,
                                 'Reading SMS Inbox Entry '+str(i))

            s=self._phone.get_sms_inbox(i)

            if len(s)==self._field_num:

                e=sms.SMSEntry()

                e.folder=e.Folder_Inbox

                e.datetime=s[self._datetime_index]

                e._from, e.subject, txt=self._extract_body(s[self._body_index])

                e.text=unicode(txt, errors='ignore')

                e.callback=s[self._callback_index]

                self._data[e.id]=e

	def _extract_body(self, s):

        try:

            _from=None

            l=s.split(' ')

            ss=l[0]

            if ss.find('@') != -1:

                _from=ss

                l=l[1:]

                ss=l[0]

            _subj=[]

            if ss[0]=='(':

                while l:

                    _subj.append(ss)

                    l=l[1:]

                    if ss[-1]==')':

                        break

                    if l:

                        ss=l[0]

            if l:

                return (_from, ' '.join(_subj), ' '.join(l))

            else:

                return (_from, '', ' '.join(_subj))

        except:

            return (None, '', s)


class  SMS_Saved_List (SMS_Generic_List) :
	_max_entries=20
	    _valid_range=xrange(_max_entries)
	    _field_num=5
	    _datetime_index=1
	    _from_index=2
	    _body_index=4
	    def __init__(self, phone):

        super(SMS_Saved_List, self).__init__(phone)

	def read(self):

        for i in self._valid_range:

            self._phone.progress(i, self._max_entries,
                                 'Reading SMS Saved Entry '+str(i))

            s=self._phone.get_sms_saved(i)

            if len(s)==self._field_num:

                e=sms.SMSEntry()

                e.folder=e.Folder_Saved

                e.datetime=s[self._datetime_index]

                e._from=s[self._from_index]

                e.subject, txt=self._extract_body(s[self._body_index])

                e.text=unicode(txt, errors='ignore')

                self._data[e.id]=e

	def _extract_body(self, s):

        try:

            l=s.split(' ')

            ss=l[0]

            _subj=[]

            if ss[0]=='(':

                while l:

                    _subj.append(ss)

                    l=l[1:]

                    if ss[-1]==')':

                        break

                    if l:

                        ss=l[0]

            if l:

                return (' '.join(_subj), ' '.join(l))

            else:

                return ('', ' '.join(_subj))

        except:

            return ('', s)


class  SMS_Sent_List (SMS_Generic_List) :
	_max_entries=100
	    _valid_range=xrange(_max_entries)
	    _field_num=5
	    _datetime_index=1
	    _to_index=2
	    _from_index=3
	    _text_index=4
	    def __init__(self, phone):

        super(SMS_Sent_List, self).__init__(phone)

	def read(self):

        for i in self._valid_range:

            self._phone.progress(i, self._max_entries,
                                 'Reading SMS Sent Entry '+str(i))

            s=self._phone.get_sms_sent(i)

            if len(s)==self._field_num:

                e=sms.SMSEntry()

                e.folder=e.Folder_Sent

                e.datetime=s[self._datetime_index]

                e._to=s[self._to_index]

                e._from=s[self._from_index]

                e.text=unicode(s[self._text_index], errors='ignore')

                self._data[e.id]=e


class  SMSList (object) :
	def __init__(self, phone):

        self._phone=phone

        self._inbox=SMS_Inbox_List(phone)

        self._saved=SMS_Saved_List(phone)

        self._sent=SMS_Sent_List(phone)

        self._data={}

	def get(self):

        return self._data.copy()

	def read(self):

        self._inbox.read()

        self._data.update(self._inbox.get())

        self._saved.read()

        self._data.update(self._saved.get())

        self._sent.read()

        self._data.update(self._sent.get())


class  CannedMsgList (SMS_Generic_List) :
	_max_entries=20
	    _valid_range=xrange(_max_entries)
	    _field_num=4
	    _text_index=3
	    _data_key='canned_msg'
	    _max_write_fields=3
	    _count_index=0
	    _timestamp_index=1
	    _write_text_index=2
	    def __init__(self, phone, data={}):

        super(CannedMsgList, self).__init__(phone)

        self._data=data

	def read(self):

        msg_list=[]

        for i in self._valid_range:

            self._phone.progress(i, self._max_entries,
                                 'Reading SMS Canned Msg '+str(i))

            s=self._phone.get_canned_msg(i)

            if len(s)==self._field_num:

                msg_list.append({'text': s[self._text_index],
                                 'type': sms.CannedMsgEntry.user_type })

        self._data=msg_list

	def get(self):

        return copy.deepcopy(self._data, _nil=[])

	def validate(self):

        pass

	def write(self):

        msg_lst=[x['text'] for x in self._data if x['type']==sms.CannedMsgEntry.user_type]

        k=None

        for k,n in enumerate(msg_lst):

            if k>=self._max_entries:

                break

            n=n.replace('"', '')

            self._phone.progress(k, self._max_entries,
                                 'Writing SMS Canned Msg '+str(k))

            s=`k`+','+self._phone.get_time_stamp()+',"'+n+'"'

            if not self._phone.save_canned_msg(s):

                self._phone.log('Failed to write SMS Canned Msg entry: '+str(k))

        if k is None:

            k=0

        else:

            k+=1

        for i in xrange(k, self._max_entries):

            self._phone.progress(i, self._max_entries,
                                 'Deleting SMS Canned Msg entry: '+str(i))

            self._phone.save_canned_msg(`i`)