840 lines
25 KiB
Python
840 lines
25 KiB
Python
#!/usr/bin/env python
|
|
# -*- Mode: python -*-
|
|
#======================================================================
|
|
# FILE: Property.py
|
|
# CREATOR: eric
|
|
#
|
|
# DESCRIPTION:
|
|
#
|
|
#
|
|
# $Id$
|
|
# $Locker$
|
|
#
|
|
# (C) COPYRIGHT 2001, Eric Busboom <eric@softwarestudio.org>
|
|
# (C) COPYRIGHT 2001, Patrick Lewis <plewis@inetarena.com>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of either:
|
|
#
|
|
# The LGPL as published by the Free Software Foundation, version
|
|
# 2.1, available at: http://www.fsf.org/copyleft/lesser.html
|
|
#
|
|
# Or:
|
|
#
|
|
# The Mozilla Public License Version 1.0. You may obtain a copy of
|
|
# the License at http://www.mozilla.org/MPL/
|
|
#======================================================================
|
|
|
|
from LibicalWrap import *
|
|
from types import *
|
|
import regsub
|
|
import base64
|
|
from string import index, upper
|
|
|
|
#def icalerror_supress(arg):
|
|
# pass
|
|
|
|
#def icalerror_restore(a,b):
|
|
# pass
|
|
|
|
def error_type():
|
|
error = icalerror_perror()
|
|
return error[:index(error,':')]
|
|
|
|
class Property:
|
|
""" Represent any iCalendar Property.
|
|
|
|
Usage:
|
|
Property(dict)
|
|
|
|
Where:
|
|
dict is a dictionary with keys of 'name', 'value_type', and 'value'.
|
|
In addition, parameter:parameter value entries may be included.
|
|
"""
|
|
|
|
class ConstructorFailedError(Exception):
|
|
"Failed to construct a property"
|
|
|
|
class UpdateFailedError(Exception):
|
|
"Failed to update the value of a property"
|
|
|
|
|
|
def __init__(self, type = None, ref = None):
|
|
|
|
|
|
assert(ref == None or isinstance(ref,StringType))
|
|
assert(type == None or isinstance(type,StringType))
|
|
|
|
self._ref = None
|
|
|
|
if ref != None:
|
|
self._ref = ref
|
|
elif type != None:
|
|
kind = icalproperty_string_to_kind(type)
|
|
self._ref = icalproperty_new(kind)
|
|
|
|
|
|
if self._ref == None or self._ref == 'NULL':
|
|
raise Property.ConstructorFailedError("Failed to construct Property")
|
|
|
|
self._deleted = 0;
|
|
|
|
|
|
# Initialize all of the required keys
|
|
|
|
|
|
def __del__(self):
|
|
|
|
self._deleted = 1;
|
|
|
|
if not self._deleted and \
|
|
self.ref() and \
|
|
icalproperty_get_parent(self.ref()) == 'NULL':
|
|
|
|
icalproperty_free(self.ref())
|
|
|
|
def name(self,v=None):
|
|
""" Return the name of the property """
|
|
str = icalproperty_as_ical_string(self._ref)
|
|
|
|
idx = index(str, '\n')
|
|
|
|
return str[:idx]
|
|
|
|
def ref(self,v=None):
|
|
""" Return the internal reference to the libical icalproperty """
|
|
if(v != None):
|
|
|
|
if not self._deleted and self._ref and \
|
|
icalproperty_get_parent(self._ref) == 'NULL':
|
|
|
|
icalproperty_free(self._ref)
|
|
|
|
self._ref = v
|
|
|
|
return self._ref
|
|
|
|
|
|
def value(self,v=None, kind = None):
|
|
""" Return the RFC2445 representation of the value """
|
|
|
|
if(v != None):
|
|
|
|
if kind != None:
|
|
# Get the default kind of value for this property
|
|
default_kind = icalvalue_kind_to_string(icalproperty_kind_to_value_kind(icalproperty_string_to_kind(self.name())))
|
|
|
|
if(kind != default_kind):
|
|
self.__setitem__('VALUE',kind)
|
|
vt = kind
|
|
elif self.__getitem__('VALUE'):
|
|
vt = self.__getitem__('VALUE')
|
|
else:
|
|
vt = 'NO' # Use the kind of the existing value
|
|
|
|
|
|
icalerror_clear_errno()
|
|
|
|
#e1=icalerror_supress("MALFORMEDDATA")
|
|
icalproperty_set_value_from_string(self._ref,v,vt)
|
|
#icalerror_restore("MALFORMEDDATA",e1)
|
|
|
|
if error_type() != "NO":
|
|
raise Property.UpdateFailedError(error_type())
|
|
|
|
s = icalproperty_get_value_as_string(self._ref)
|
|
assert(s == v)
|
|
|
|
return icalproperty_get_value_as_string(self._ref)
|
|
|
|
def parameters(self):
|
|
|
|
d_string = icallangbind_property_eval_string(self._ref,":")
|
|
dict = eval(d_string)
|
|
|
|
desc_keys = ('name', 'value', 'value_type', 'pid', 'ref', 'deleted' )
|
|
|
|
def foo(k,d=dict):
|
|
if d.has_key(k): del d[k]
|
|
|
|
map( foo, desc_keys)
|
|
|
|
return filter(lambda p, s=self: s[p] != None, dict.keys())
|
|
|
|
|
|
def as_ical_string(self):
|
|
|
|
return icalproperty_as_ical_string(self._ref)
|
|
|
|
def __getitem__(self,key):
|
|
""" Return property values by name """
|
|
key = upper(key)
|
|
|
|
str = icalproperty_get_parameter_as_string(self._ref,key)
|
|
|
|
if(str == 'NULL'): return None
|
|
|
|
return str
|
|
|
|
def __setitem__(self,key,value):
|
|
""" Set Property Values by Name """
|
|
key = upper(key)
|
|
|
|
icalproperty_set_parameter_from_string(self._ref,key,value)
|
|
|
|
return self.__getitem__(key)
|
|
|
|
def __str__(self):
|
|
|
|
str = self.as_ical_string()
|
|
return regsub.gsub('\r?\n ?','',str)
|
|
|
|
def __cmp__(self, other):
|
|
s_str = str(self)
|
|
o_str = str(other)
|
|
|
|
return cmp(s_str,o_str)
|
|
|
|
|
|
class Time(Property):
|
|
""" Represent iCalendar DATE, TIME and DATE-TIME """
|
|
def __init__(self, arg, name="DTSTART"):
|
|
"""
|
|
Create a new Time from a string or number of seconds past the
|
|
POSIX epoch
|
|
|
|
Time("19970325T123000Z") Construct from an iCalendar string
|
|
Time(8349873494) Construct from seconds past POSIX epoch
|
|
|
|
"""
|
|
e1=icalerror_supress("MALFORMEDDATA")
|
|
e2=icalerror_supress("BADARG")
|
|
|
|
if isinstance(arg, DictType):
|
|
# Dictionary -- used for creating from Component
|
|
self.tt = icaltime_from_string(arg['value'])
|
|
Property.__init__(self, ref=arg['ref'])
|
|
else:
|
|
if isinstance(arg, StringType):
|
|
# Create from an iCal string
|
|
self.tt = icaltime_from_string(arg)
|
|
elif isinstance(arg, IntType) or \
|
|
isinstance(arg, FloatType):
|
|
# Create from seconds past the POSIX epoch
|
|
self.tt = icaltime_from_timet(int(arg),0)
|
|
elif isinstance(arg, Time):
|
|
# Copy an instance
|
|
self.tt = arg.tt
|
|
else:
|
|
self.tt = icaltime_null_time()
|
|
|
|
Property.__init__(self,type=name)
|
|
|
|
icalerror_restore("MALFORMEDDATA",e1)
|
|
icalerror_restore("BADARG",e2)
|
|
|
|
if icaltime_is_null_time(self.tt):
|
|
raise Property.ConstructorFailedError("Failed to construct a Time")
|
|
|
|
try:
|
|
self._update_value()
|
|
except Property.UpdateFailedError:
|
|
raise Property.ConstructorFailedError("Failed to construct a Time")
|
|
|
|
def _update_value(self):
|
|
self.tt = icaltime_normalize(self.tt)
|
|
self.value(icaltime_as_ical_string(self.tt),"DATE-TIME")
|
|
|
|
def valid(self):
|
|
" Return true if this is a valid time "
|
|
return not icaltime_is_null_time(self.tt)
|
|
|
|
def utc_seconds(self,v=None):
|
|
""" Return or set time in seconds past POSIX epoch"""
|
|
if (v!=None):
|
|
self.tt = icaltime_from_timet(v,0)
|
|
self._update_value()
|
|
|
|
return icaltime_as_timet(self.tt)
|
|
|
|
def is_utc(self,v=None):
|
|
""" Return or set boolean indicating if time is in UTC """
|
|
if(v != None):
|
|
icaltimetype_is_utc_set(self.tt,v)
|
|
self._update_value()
|
|
return icaltimetype_is_utc_get(self.tt)
|
|
|
|
def is_date(self,v=None):
|
|
""" Return or set boolean indicating if time is actually a date """
|
|
if(v != None):
|
|
icaltimetype_is_date_set(self.tt,v)
|
|
self._update_value()
|
|
return icaltimetype_is_date_get(self.tt)
|
|
|
|
def timezone(self,v=None):
|
|
""" Return or set the timezone string for this time """
|
|
|
|
if (v != None):
|
|
assert(isinstance(v,StringType) )
|
|
self['TZID'] = v
|
|
return self['TZID']
|
|
|
|
def second(self,v=None):
|
|
""" Get or set the seconds component of this time """
|
|
if(v != None):
|
|
icaltimetype_second_set(self.tt,v)
|
|
self._update_value()
|
|
return icaltimetype_second_get(self.tt)
|
|
|
|
def minute(self,v=None):
|
|
""" Get or set the minute component of this time """
|
|
if(v != None):
|
|
icaltimetype_minute_set(self.tt,v)
|
|
self._update_value()
|
|
return icaltimetype_minute_get(self.tt)
|
|
|
|
def hour(self,v=None):
|
|
""" Get or set the hour component of this time """
|
|
if(v != None):
|
|
icaltimetype_hour_set(self.tt,v)
|
|
self._update_value()
|
|
return icaltimetype_hour_get(self.tt)
|
|
|
|
def day(self,v=None):
|
|
""" Get or set the month day component of this time """
|
|
if(v != None):
|
|
icaltimetype_day_set(self.tt,v)
|
|
self._update_value()
|
|
return icaltimetype_day_get(self.tt)
|
|
|
|
def month(self,v=None):
|
|
""" Get or set the month component of this time. January is month 1 """
|
|
if(v != None):
|
|
icaltimetype_month_set(self.tt,v)
|
|
self._update_value()
|
|
return icaltimetype_month_get(self.tt)
|
|
|
|
def year(self,v=None):
|
|
""" Get or set the year component of this time """
|
|
if(v != None):
|
|
icaltimetype_year_set(self.tt,v)
|
|
self._update_value()
|
|
|
|
return icaltimetype_year_get(self.tt)
|
|
|
|
|
|
|
|
def __add__(self,o):
|
|
|
|
other = Duration(o,"DURATION")
|
|
|
|
if not other.valid():
|
|
return Duration(0,"DURATION")
|
|
|
|
seconds = self.utc_seconds() + other.seconds()
|
|
|
|
new = Time(seconds,self.name())
|
|
new.timezone(self.timezone())
|
|
new.is_utc(self.is_utc())
|
|
|
|
return new
|
|
|
|
def __radd_(self,o):
|
|
return self.__add__(o)
|
|
|
|
|
|
def __sub__(self,o):
|
|
|
|
|
|
if isinstance(o,Time):
|
|
# Subtract a time from this time and return a duration
|
|
seconds = self.utc_seconds() - other.utc_seconds()
|
|
return Duration(seconds)
|
|
elif isinstance(o,Duration):
|
|
# Subtract a duration from this time and return a time
|
|
other = Duration(o)
|
|
if(not other.valid()):
|
|
return Time()
|
|
|
|
seconds = self.utc_seconds() - other.seconds()
|
|
return Time(seconds)
|
|
else:
|
|
raise TypeError, "subtraction with Time reqires Time or Duration"
|
|
|
|
class Duration(Property):
|
|
"""
|
|
Represent a length of time, like 3 minutes, or 6 days, 20 seconds.
|
|
|
|
|
|
"""
|
|
|
|
def __init__(self, arg, name="DURATION"):
|
|
"""
|
|
Create a new duration from an RFC2445 string or number of seconds.
|
|
Construct the duration from an iCalendar string or a number of seconds.
|
|
|
|
Duration("P3DT2H34M45S") Construct from an iCalendar string
|
|
Duration(3660) Construct from seconds
|
|
"""
|
|
|
|
self.dur = None
|
|
|
|
e=icalerror_supress("MALFORMEDDATA")
|
|
|
|
if isinstance(arg, DictType):
|
|
|
|
self.dur = icaldurationtype_from_string(arg['value'])
|
|
Property.__init__(self,ref=arg['ref'])
|
|
else:
|
|
if isinstance(arg, StringType):
|
|
self.dur = icaldurationtype_from_string(arg)
|
|
elif isinstance(arg, IntType):
|
|
self.dur = icaldurationtype_from_int(arg)
|
|
elif isinstance(arg,Duration):
|
|
self.dur = arg.dur
|
|
else:
|
|
self.dur = icaldurationtype_null_duration()
|
|
|
|
Property.__init__(self,type=name)
|
|
|
|
icalerror_restore("MALFORMEDDATA",e)
|
|
|
|
if self.dur == None or icaldurationtype_is_null_duration(self.dur):
|
|
raise Property.ConstructorFailedError("Failed to construct Duration from " +str(arg))
|
|
|
|
try:
|
|
self._update_value()
|
|
except Property.UpdateFailedError:
|
|
raise Property.ConstructorFailedError("Failed to construct Duration from " + str(arg))
|
|
|
|
def _update_value(self):
|
|
|
|
self.value(icaldurationtype_as_ical_string(self.dur),"DURATION")
|
|
|
|
def valid(self):
|
|
"Return true if this is a valid duration"
|
|
|
|
return not icaldurationtype_is_null_duration(self.dur)
|
|
|
|
def seconds(self,v=None):
|
|
"""Return or set duration in seconds"""
|
|
if(v != None):
|
|
self.dur = icaldurationtype_from_int(v);
|
|
self.dict['value'] = icaltimedurationtype_as_ical_string(self.dur)
|
|
return icaldurationtype_as_int(self.dur)
|
|
|
|
|
|
class Period(Property):
|
|
"""Represent a span of time"""
|
|
def __init__(self,arg,name='FREEBUSY'):
|
|
""" """
|
|
|
|
Property.__init__(self, type = name)
|
|
|
|
self.pt=None
|
|
|
|
#icalerror_clear_errno()
|
|
e1=icalerror_supress("MALFORMEDDATA")
|
|
e2=icalerror_supress("BADARG")
|
|
|
|
if isinstance(arg, DictType):
|
|
|
|
|
|
es=icalerror_supress("MALFORMEDDATA")
|
|
self.pt = icalperiodtype_from_string(arg['value'])
|
|
icalerror_restore("MALFORMEDDATA",es)
|
|
|
|
Property.__init__(self, ref=arg['ref'])
|
|
else:
|
|
if isinstance(arg, StringType):
|
|
|
|
self.pt = icalperiodtype_from_string(arg)
|
|
|
|
else:
|
|
self.pt = icalperiodtype_null_period()
|
|
|
|
Property.__init__(self,type=name)
|
|
|
|
icalerror_restore("MALFORMEDDATA",e1)
|
|
icalerror_restore("BADARG",e2)
|
|
|
|
|
|
if self.pt == None or icalperiodtype_is_null_period(self.pt):
|
|
raise Property.ConstructorFailedError("Failed to construct Period")
|
|
|
|
|
|
try:
|
|
self._update_value()
|
|
except Property.UpdateFailedError:
|
|
raise Property.ConstructorFailedError("Failed to construct Period")
|
|
|
|
def _end_is_duration(self):
|
|
dur = icalperiodtype_duration_get(self.pt)
|
|
if not icaldurationtype_is_null_duration(dur):
|
|
return 1
|
|
return 0
|
|
|
|
def _end_is_time(self):
|
|
end = icalperiodtype_end_get(self.pt)
|
|
if not icaltime_is_null_time(end):
|
|
return 1
|
|
return 0
|
|
|
|
def _update_value(self):
|
|
|
|
self.value(icalperiodtype_as_ical_string(self.pt),"PERIOD")
|
|
|
|
|
|
def valid(self):
|
|
"Return true if this is a valid period"
|
|
|
|
return not icalperiodtype_is_null_period(self.dur)
|
|
|
|
def start(self,v=None):
|
|
"""
|
|
Return or set start time of the period. The start time may be
|
|
expressed as an RFC2445 format string or an instance of Time.
|
|
The return value is an instance of Time
|
|
"""
|
|
|
|
if(v != None):
|
|
if isinstance(t,Time):
|
|
t = v
|
|
elif isinstance(t,StringType) or isinstance(t,IntType):
|
|
t = Time(v,"DTSTART")
|
|
else:
|
|
raise TypeError
|
|
|
|
icalperiodtype_start_set(self.pt,t.tt)
|
|
|
|
self._update_value()
|
|
|
|
|
|
return Time(icaltime_as_timet(icalperiodtype_start_get(self.pt)),
|
|
"DTSTART")
|
|
|
|
def end(self,v=None):
|
|
"""
|
|
Return or set end time of the period. The end time may be
|
|
expressed as an RFC2445 format string or an instance of Time.
|
|
The return value is an instance of Time.
|
|
|
|
If the Period has a duration set, but not an end time, this
|
|
method will caluculate the end time from the duration. """
|
|
|
|
if(v != None):
|
|
|
|
if isinstance(t,Time):
|
|
t = v
|
|
elif isinstance(t,StringType) or isinstance(t,IntType):
|
|
t = Time(v)
|
|
else:
|
|
raise TypeError
|
|
|
|
if(self._end_is_duration()):
|
|
start = icaltime_as_timet(icalperiodtype_start_get(self.pt))
|
|
dur = t.utc_seconds()-start;
|
|
icalperiodtype_duration_set(self.pt,
|
|
icaldurationtype_from_int(dur))
|
|
else:
|
|
icalperiodtype_end_set(self.pt,t.tt)
|
|
|
|
self._update_value()
|
|
|
|
if(self._end_is_time()):
|
|
rt = Time(icaltime_as_timet(icalperiodtype_end_get(self.pt)),
|
|
'DTEND')
|
|
rt.timezone(self.timezone())
|
|
return rt
|
|
elif(self._end_is_duration()):
|
|
start = icaltime_as_timet(icalperiodtype_start_get(self.pt))
|
|
dur = icaldurationtype_as_int(icalperiodtype_duration_get(self.pt))
|
|
rt = Time(start+dur,'DTEND')
|
|
rt.timezone(self.timezone())
|
|
return rt
|
|
else:
|
|
return Time({},'DTEND')
|
|
|
|
|
|
|
|
def duration(self,v=None):
|
|
"""
|
|
Return or set the duration of the period. The duration may be
|
|
expressed as an RFC2445 format string or an instance of Duration.
|
|
The return value is an instance of Duration.
|
|
|
|
If the period has an end time set, but not a duration, this
|
|
method will calculate the duration from the end time. """
|
|
|
|
if(v != None):
|
|
|
|
if isinstance(t,Duration):
|
|
d = v
|
|
elif isinstance(t,StringType) or isinstance(t,IntType):
|
|
d = Duration(v)
|
|
else:
|
|
raise TypeError
|
|
|
|
if(self._end_is_time()):
|
|
start = icaltime_as_timet(icalperiodtype_start_get(self.pt))
|
|
end = start + d.seconds()
|
|
|
|
icalperiodtype_end_set(self.pt,icaltime_from_timet(end,0))
|
|
else:
|
|
icalperiodtype_duration_set(self.pt,d.dur)
|
|
|
|
if(self._end_is_time()):
|
|
start =icaltime_as_timet(icalperiodtype_start_get(self.pt))
|
|
end = icaltime_as_timet(icalperiodtype_end_get(self.pt))
|
|
|
|
print "End is time " + str(end-start)
|
|
|
|
return Duration(end-start,"DURATION")
|
|
|
|
elif(self._end_is_duration()):
|
|
dur = icaldurationtype_as_int(
|
|
icalperiodtype_duration_get(self.pt))
|
|
|
|
return Duration(dur,"DURATION")
|
|
else:
|
|
|
|
|
|
return Duration(0,"DURATION")
|
|
|
|
|
|
def timezone(self,v=None):
|
|
""" Return or set the timezone string for this time """
|
|
if (v != None):
|
|
self['TZID'] = v
|
|
return self['TZID']
|
|
|
|
class Attendee(Property):
|
|
"""Class for Attendee properties.
|
|
|
|
Usage:
|
|
Attendee([dict])
|
|
Attendee([address])
|
|
|
|
Where:
|
|
dict is an optional dictionary with keys of
|
|
'value': CAL-ADDRESS string and any parameter: parameter_value entries.
|
|
'name' and 'value_type' entries in dict are ignored and automatically set
|
|
with the appropriate values.
|
|
address is the CAL-ADDRESS (string) of the Attendee
|
|
"""
|
|
|
|
def __init__(self, arg={}):
|
|
|
|
assert(isinstance(arg,DictType))
|
|
|
|
ref = None
|
|
|
|
if arg!={}:
|
|
ref = arg['ref']
|
|
|
|
Property.__init__(self,type='ATTENDEE',ref=ref)
|
|
|
|
def _doParam(self, parameter, v):
|
|
if v!=None:
|
|
self[parameter]=v
|
|
return self[parameter]
|
|
|
|
# Methods for accessing enumerated parameters
|
|
def cn(self, v=None): self._doParam('CN', v)
|
|
def cutype(self, v=None): self._doParam('CUTYPE', v)
|
|
def dir(self, v=None): self._doParam('DIR', v)
|
|
def delegated_from(self, v=None): self._doParam('DELEGATED-FROM', v)
|
|
def delegated_to(self, v=None): self._doParam('DELEGATED-TO', v)
|
|
def language(self, v=None): self._doParam('LANGUAGE', v)
|
|
def member(self, v=None): self._doParam('MEMBER', v)
|
|
def partstat(self, v=None): self._doParam('PARTSTAT', v)
|
|
def role(self, v=None): self._doParam('ROLE', v)
|
|
def rsvp(self, v=None): self._doParam('RSVP', v)
|
|
def sent_by(self, v=None): self._doParam('SENT-BY', v)
|
|
|
|
|
|
class Organizer(Property):
|
|
"""Class for Organizer property.
|
|
"""
|
|
|
|
def __init__(self, arg={}):
|
|
|
|
assert(isinstance(arg, DictType))
|
|
|
|
ref = None
|
|
if arg != {}:
|
|
ref = arg['ref']
|
|
Property.__init__(self, type='ORGANIZER', ref=ref)
|
|
|
|
## param_t = ( 'CN', 'DIR', 'SENT-BY', 'LANGUAGE' )
|
|
## for param in param_t:
|
|
## self[param] = None
|
|
## if value != None:
|
|
## self.value(value)
|
|
|
|
|
|
def _doParam(self, parameter, v):
|
|
if v!=None:
|
|
self[parameter]=v
|
|
return self[parameter]
|
|
|
|
def name(self):
|
|
"Return the name of the property."
|
|
return Property.name(self)
|
|
|
|
def value_type(self):
|
|
"Return the value type of the property."
|
|
return self._desc['value_type']
|
|
|
|
# Methods for accessing enumerated parameters
|
|
def cn(self, v=None): self._doParam('CN', v)
|
|
def dir(self, v=None): self._doParam('DIR', v)
|
|
def language(self, v=None): self._doParam('LANGUAGE', v)
|
|
def sent_by(self, v=None): self._doParam('SENT-BY', v)
|
|
|
|
class Recurrence_Id(Time):
|
|
"""Class for RECURRENCE-ID property.
|
|
|
|
Usage:
|
|
Reccurence_Id(dict) # A normal property dictionary
|
|
Reccurence_Id("19960401") # An iCalendar string
|
|
Reccurence_Id(8349873494) # Seconds from epoch
|
|
|
|
If the 'dict' constructor is used, 'name' and 'value_type'
|
|
entries in dict are ignored and automatically set with the appropriate
|
|
values.
|
|
"""
|
|
|
|
def __init__(self, dict={}):
|
|
Time.__init__(self, dict)
|
|
Property.name(self, 'RECURRENCE-ID')
|
|
|
|
def name(self):
|
|
return Property.name(self)
|
|
|
|
def _doParam(self, parameter, v):
|
|
if v!=None:
|
|
self[parameter]=v
|
|
return self[parameter]
|
|
|
|
# Enumerated parameters
|
|
def value_parameter(self, v=None):
|
|
"""Sets or gets the VALUE parameter value.
|
|
|
|
The value passed should be either "DATE-TIME" or "DATE". Setting this
|
|
parameter has no impact on the property's value_type. Doing something
|
|
like:
|
|
|
|
rid=Recurrence_Id("19960401") # Sets value & makes value_type="DATE"
|
|
rid.value_parameter("DATE-TIME") # Sets the parameter VALUE=DATE-TIME
|
|
|
|
Would be allowed (even though it is wrong), so pay attention.
|
|
Verifying the component will reveal the error.
|
|
"""
|
|
if v!=None and v!="DATE" and v!="DATE-TIME":
|
|
raise ValueError, "%s is an invalid VALUE parameter value" % str(v)
|
|
self._doParam("VALUE", v)
|
|
|
|
def tzid(self, v=None):
|
|
"Sets or gets the TZID parameter value."
|
|
self._doParam("TZID", v)
|
|
|
|
def range_parameter(self, v=None): # 'range' is a builtin function
|
|
"Sets or gets the RANGE parameter value."
|
|
if v!=None and v!="THISANDPRIOR" and v!= "THISANDFUTURE":
|
|
raise ValueError, "%s is an invalid RANGE parameter value" % str(v)
|
|
self._doParam("RANGE", v)
|
|
|
|
class Attach(Property):
|
|
"""A class representing an ATTACH property.
|
|
|
|
Usage:
|
|
Attach(uriString [, parameter_dict])
|
|
Attach(fileObj [, parameter_dict])
|
|
"""
|
|
|
|
def __init__(self, value=None, parameter_dict={}):
|
|
Property.__init__(self, parameter_dict)
|
|
Property.name(self, 'ATTACH')
|
|
self.value(value)
|
|
|
|
def value(self, v=None):
|
|
"Returns or sets the value of the property."
|
|
if v != None:
|
|
if isinstance(v, StringType): # Is a URI
|
|
self._desc['value']=v
|
|
Property.value_type(self, 'URI')
|
|
else:
|
|
try:
|
|
tempStr = v.read()
|
|
except:
|
|
raise TypeError,"%s must be a URL string or file-ish type"\
|
|
% str(v)
|
|
self._desc['value'] = base64.encodestring(tempStr)
|
|
Property.value_type(self, 'BINARY')
|
|
else:
|
|
return self._desc['value']
|
|
|
|
def name(self):
|
|
"Returns the name of the property."
|
|
return Property.name(self)
|
|
|
|
def value_type(self):
|
|
return Property.value_type(self)
|
|
|
|
def fmttype(self, v=None):
|
|
"Gets or sets the FMTYPE parameter."
|
|
if v!= None:
|
|
self['FMTTYPE']=v
|
|
else:
|
|
return self['FMTTYPE']
|
|
|
|
class RecurrenceSet:
|
|
"""
|
|
Represents a set of event occurrences. This
|
|
class controls a component's RRULE, EXRULE, RDATE and EXDATE
|
|
properties and can produce from them a set of occurrences.
|
|
"""
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
def include(self, **params):
|
|
"""
|
|
Include a date or rule to the set.
|
|
|
|
Use date= or pass in a
|
|
Time instance to include a date. Included dates will add an
|
|
RDATE property or will remove an EXDATE property of the same
|
|
date.
|
|
|
|
Use rule= or pass in a string to include a rule. Included
|
|
rules with either add a RRULE property or remove an EXRULE
|
|
property.
|
|
|
|
"""
|
|
pass
|
|
|
|
def exclude(self, **params):
|
|
"""
|
|
Exclude date or rule to the set.
|
|
|
|
Use date= or pass in a Time instance to exclude a
|
|
date. Excluded dates will add an EXDATE property or will remove
|
|
an RDATE property of the same date.
|
|
|
|
Use rule= or pass in a string to exclude a rule. Excluded
|
|
rules with either add an EXRULE property or remove an RRULE
|
|
property.
|
|
|
|
"""
|
|
pass
|
|
|
|
def occurrences(self, count=None):
|
|
"""
|
|
Return 'count' occurrences as a tuple of Time instances.
|
|
"""
|
|
pass
|
|
|
|
|