def setValue(self, value):
newValues = []
for v in value:
val = Value.createFromType(self.mType)
val.setValue(v)
newValues.append(val)
self.mValues = newValues
def setValue(self, value):
newValues = []
for v in value:
val = Value.createFromType(self.mType)
val.setValue(v)
newValues.append(val)
self.mValues = newValues
def _init_attr_value_text(self, txt, value_type):
# Value
self.mValue = Value.createFromType(value_type)
if isinstance(self.mValue, PlainTextValue) or isinstance(self.mValue, UnknownValue):
self.mValue.setValue(txt)
# Parameters
self.setupValueParameter()
def _init_attr_value_text(self, txt, value_type):
# Value
self.mValue = Value.createFromType(value_type)
if isinstance(self.mValue, PlainTextValue) or isinstance(self.mValue, UnknownValue):
self.mValue.setValue(txt)
# Parameters
self.setupValueParameter()
def parseText(cls, data):
"""
Parse the text format data and return a L{Property}
@param data: text data
@type data: C{str}
"""
try:
prop = cls()
# Look for parameter or value delimiter
prop_name, txt = stringutils.strduptokenstr(data, ";:")
if not prop_name:
raise InvalidProperty("Invalid property", data)
# Get the name
if prop.sUsesGroup:
# Check for group prefix
splits = prop_name.split(".", 1)
if len(splits) == 2:
# We have both group and name
prop.mGroup = splits[0]
prop.mName = splits[1]
else:
# We have the name
prop.mName = prop_name
else:
prop.mName = prop_name
# Get the parameters
txt = prop.parseTextParameters(txt, data)
# Tidy first
prop.mValue = None
# Get value type from property name
value_type = prop.determineValueType()
# Check for multivalued
if prop.mName.upper() in prop.sMultiValues:
prop.mValue = MultiValue(value_type)
else:
# Create the type
prop.mValue = Value.createFromType(value_type)
# Now parse the data
prop.mValue.parse(txt, prop.sVariant)
prop._postCreateValue(value_type)
return prop
except Exception:
raise InvalidProperty("Invalid property", data)
def parseText(cls, data):
"""
Parse the text format data and return a L{Property}
@param data: text data
@type data: C{str}
"""
try:
prop = cls()
# Look for parameter or value delimiter
prop_name, txt = stringutils.strduptokenstr(data, ";:")
if not prop_name:
raise InvalidProperty("Invalid property: empty name", data)
# Get the name
if prop.sUsesGroup:
# Check for group prefix
splits = prop_name.split(".", 1)
if len(splits) == 2:
# We have both group and name
prop.mGroup = splits[0]
prop.mName = splits[1]
else:
# We have the name
prop.mName = prop_name
else:
prop.mName = prop_name
# Get the parameters
txt = prop.parseTextParameters(txt, data)
# Tidy first
prop.mValue = None
# Get value type from property name
value_type = prop.determineValueType()
# Check for multivalued
if prop.mName.upper() in prop.sMultiValues:
prop.mValue = MultiValue(value_type)
else:
# Create the type
prop.mValue = Value.createFromType(value_type)
# Now parse the data
prop.mValue.parse(txt, prop.sVariant)
prop._postCreateValue(value_type)
return prop
except Exception as e:
raise InvalidProperty("Invalid property: '{}'".format(e), data)
def parse(self, data, variant):
# Tokenize on comma
if "," in data:
tokens = data.split(",")
else:
tokens = (data, )
for token in tokens:
# Create single value, and parse data
value = Value.createFromType(self.mType)
value.parse(token, variant)
self.mValues.append(value)
def parse(self, data, variant):
# Tokenize on comma
if "," in data:
tokens = data.split(",")
else:
tokens = (data,)
for token in tokens:
# Create single value, and parse data
value = Value.createFromType(self.mType)
value.parse(token, variant)
self.mValues.append(value)
def parseJSON(cls, jobject):
"""
Parse a JSON property of the form:
[name, attrs, type, value1, value2, ...]
@param jobject: a JSON array
@type jobject: C{list}
"""
try:
prop = cls()
# Get the name
prop.mName = jobject[0].encode("utf-8").upper()
# Get the parameters
if jobject[1]:
for name, value in jobject[1].items():
# Now add parameter value
name = name.upper()
attrvalue = Parameter(name=name.encode("utf-8"), value=value.encode("utf-8"))
prop.mParameters.setdefault(name, []).append(attrvalue)
# Get default value type from property name and insert a VALUE parameter if current value type is not default
value_type = cls.sValueTypeMap.get(jobject[2].upper(), Value.VALUETYPE_UNKNOWN)
default_type = cls.sDefaultValueTypeMap.get(prop.mName.upper(), Value.VALUETYPE_UNKNOWN)
if default_type != value_type:
attrvalue = Parameter(name=cls.sValue, value=jobject[2].encode("utf-8").upper())
prop.mParameters.setdefault(cls.sValue, []).append(attrvalue)
# Get value type from property name
value_type = prop.determineValueType()
# Check for multivalued
values = jobject[3:]
if prop.mName.upper() in cls.sMultiValues:
prop.mValue = MultiValue(value_type)
prop.mValue.parseJSONValue(values)
else:
# Create the type
prop.mValue = Value.createFromType(value_type)
prop.mValue.parseJSONValue(values[0])
# Special post-create for some types
prop._postCreateValue(value_type)
return prop
except Exception:
raise InvalidProperty("Invalid property", jobject)
def parseJSON(cls, jobject):
"""
Parse a JSON property of the form:
[name, attrs, type, value1, value2, ...]
@param jobject: a JSON array
@type jobject: C{list}
"""
try:
prop = cls()
# Get the name
prop.mName = jobject[0].encode("utf-8").upper()
# Get the parameters
if jobject[1]:
for name, value in jobject[1].items():
# Now add parameter value
name = name.upper()
attrvalue = Parameter(name=name.encode("utf-8"), value=value.encode("utf-8"))
prop.mParameters.setdefault(name, []).append(attrvalue)
# Get default value type from property name and insert a VALUE parameter if current value type is not default
value_type = cls.sValueTypeMap.get(jobject[2].upper(), Value.VALUETYPE_UNKNOWN)
default_type = cls.sDefaultValueTypeMap.get(prop.mName.upper(), Value.VALUETYPE_UNKNOWN)
if default_type != value_type:
attrvalue = Parameter(name=cls.sValue, value=jobject[2].encode("utf-8").upper())
prop.mParameters.setdefault(cls.sValue, []).append(attrvalue)
# Get value type from property name
value_type = prop.determineValueType()
# Check for multivalued
values = jobject[3:]
if prop.mName.upper() in cls.sMultiValues:
prop.mValue = MultiValue(value_type)
prop.mValue.parseJSONValue(values)
else:
# Create the type
prop.mValue = Value.createFromType(value_type)
prop.mValue.parseJSONValue(values[0])
# Special post-create for some types
prop._postCreateValue(value_type)
return prop
except Exception as e:
raise InvalidProperty("Invalid property: '{}'".format(e), jobject)
def createValue(self, data):
# Tidy first
self.mValue = None
# Get value type from property name
value_type = self.determineValueType()
# Check for multivalued
if self.mName.upper() in self.sMultiValues:
self.mValue = MultiValue(value_type)
else:
# Create the type
self.mValue = Value.createFromType(value_type)
# Now parse the data
try:
self.mValue.parse(data, self.sVariant)
except ValueError:
raise InvalidProperty("Invalid property value", data)
self._postCreateValue(value_type)
def createValue(self, data):
# Tidy first
self.mValue = None
# Get value type from property name
value_type = self.determineValueType()
# Check for multivalued
if self.mName.upper() in self.sMultiValues:
self.mValue = MultiValue(value_type)
else:
# Create the type
self.mValue = Value.createFromType(value_type)
# Now parse the data
try:
self.mValue.parse(data, self.sVariant)
except ValueError as e:
raise InvalidProperty("Invalid property value: '{}'".format(e), data)
self._postCreateValue(value_type)
def setValue(self, value):
# Tidy first
self.mValue = None
# Get value type from property name
value_type = self.sDefaultValueTypeMap.get(self.mName.upper(), Value.VALUETYPE_TEXT)
# Check whether custom value is set
if self.sValue in self.mParameters:
value_type = self.sValueTypeMap.get(self.getParameterValue(self.sValue), value_type)
# Check for multivalued
if self.mName.upper() in self.sMultiValues:
self.mValue = MultiValue(value_type)
else:
# Create the type
self.mValue = Value.createFromType(value_type)
self.mValue.setValue(value)
# Special post-create for some types
self._postCreateValue(value_type)
def setValue(self, value):
# Tidy first
self.mValue = None
# Get value type from property name
value_type = self.sDefaultValueTypeMap.get(self.mName.upper(), Value.VALUETYPE_TEXT)
# Check whether custom value is set
if self.sValue in self.mParameters:
value_type = self.sValueTypeMap.get(self.getParameterValue(self.sValue), value_type)
# Check for multivalued
if self.mName.upper() in self.sMultiValues:
self.mValue = MultiValue(value_type)
else:
# Create the type
self.mValue = Value.createFromType(value_type)
self.mValue.setValue(value)
# Special post-create for some types
self._postCreateValue(value_type)
# See the License for the specific language governing permissions and
# limitations under the License.
##
# iCalendar UTC Offset value
from pycalendar import utils, xmldefinitions
from pycalendar.plaintextvalue import PlainTextValue
from pycalendar.value import Value
class TextValue(PlainTextValue):
def getType(self):
return Value.VALUETYPE_TEXT
def parse(self, data, variant):
# Decoding required
self.mValue = utils.decodeTextValue(data)
# os - StringIO object
def generate(self, os):
try:
# Encoding required
utils.writeTextValue(os, self.mValue)
except:
pass
Value.registerType(Value.VALUETYPE_TEXT, TextValue, xmldefinitions.value_text)
# See the License for the specific language governing permissions and
# limitations under the License.
##
from pycalendar import xmldefinitions
from pycalendar.datetime import DateTime
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
class DateTimeValue(WrapperValue, Value):
_wrappedClass = DateTime
_wrappedType = None # Depends on actual value
def getType(self):
return (Value.VALUETYPE_DATETIME,
Value.VALUETYPE_DATE)[self.mValue.isDateOnly()]
def parse(self, data, variant):
self.mValue.parse(data, fullISO=(variant == "vcard"))
def writeXML(self, node, namespace):
self.mValue.writeXML(node, namespace)
Value.registerType(Value.VALUETYPE_DATE, DateTimeValue,
xmldefinitions.value_date)
Value.registerType(Value.VALUETYPE_DATETIME, DateTimeValue,
xmldefinitions.value_date_time)
##
# Copyright (c) 2011-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# iCalendar Binary value
from pycalendar import xmldefinitions
from pycalendar.plaintextvalue import PlainTextValue
from pycalendar.value import Value
class BinaryValue(PlainTextValue):
def getType(self):
return Value.VALUETYPE_BINARY
Value.registerType(Value.VALUETYPE_BINARY, BinaryValue,
xmldefinitions.value_binary)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
from pycalendar import xmldefinitions
from pycalendar.period import Period
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
class PeriodValue(WrapperValue, Value):
_wrappedClass = Period
_wrappedType = Value.VALUETYPE_PERIOD
Value.registerType(Value.VALUETYPE_PERIOD, PeriodValue, xmldefinitions.value_period)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# vCard N value
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
from pycalendar.vcard.n import N
class NValue(WrapperValue, Value):
_wrappedClass = N
_wrappedType = Value.VALUETYPE_N
Value.registerType(Value.VALUETYPE_N, NValue, None)
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
from pycalendar import xmldefinitions
from pycalendar.datetime import DateTime
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
class DateTimeValue(WrapperValue, Value):
_wrappedClass = DateTime
_wrappedType = None # Depends on actual value
def getType(self):
return (Value.VALUETYPE_DATETIME, Value.VALUETYPE_DATE)[self.mValue.isDateOnly()]
def parse(self, data, variant):
self.mValue.parse(data, fullISO=(variant == "vcard"))
def writeXML(self, node, namespace):
self.mValue.writeXML(node, namespace)
Value.registerType(Value.VALUETYPE_DATE, DateTimeValue, xmldefinitions.value_date)
Value.registerType(Value.VALUETYPE_DATETIME, DateTimeValue, xmldefinitions.value_date_time)
def parse(self, data, variant):
self.mValue = int(data)
# os - StringIO object
def generate(self, os):
try:
os.write(str(self.mValue))
except:
pass
def writeXML(self, node, namespace):
value = self.getXMLNode(node, namespace)
value.text = str(self.mValue)
def parseJSONValue(self, jobject):
self.mValue = int(jobject)
def writeJSONValue(self, jobject):
jobject.append(self.mValue)
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_INTEGER, IntegerValue,
xmldefinitions.value_integer)
class URIValue(PlainTextValue):
def getType(self):
return URIValue.VALUETYPE_URI
def parse(self, data, variant):
if ParserContext.BACKSLASH_IN_URI_VALUE == ParserContext.PARSER_FIX:
# Decoding required
self.mValue = utils.decodeTextValue(data)
else:
# No decoding required
self.mValue = data
# os - StringIO object
def generate(self, os):
"""
Handle a client bug where it sometimes includes a \n in the value and we need
to make sure that gets encoded rather than included literally which would break syntax.
"""
if '\n' in self.mValue:
try:
# No encoding required
os.write(self.mValue.replace("\n", "\\n"))
except:
pass
else:
super(URIValue, self).generate(os)
Value.registerType(Value.VALUETYPE_URI, URIValue, xmldefinitions.value_uri)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# vCard N value
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
from pycalendar.vcard.n import N
class NValue(WrapperValue, Value):
_wrappedClass = N
_wrappedType = Value.VALUETYPE_N
Value.registerType(Value.VALUETYPE_N, NValue, None)
os = StringIO()
self.generate(os)
text = os.getvalue()
text = text[:-2] + ":" + text[-2:]
value = self.getXMLNode(node, namespace)
value.text = text
def parseJSONValue(self, jobject):
self.parse(str(jobject), variant="vcard")
def writeJSONValue(self, jobject):
os = StringIO()
self.generate(os, fullISO=True)
text = os.getvalue()
jobject.append(text)
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_UTC_OFFSET, UTCOffsetValue, xmldefinitions.value_utc_offset)
def parse(self, data, variant):
self.mValue = float(data)
# os - StringIO object
def generate(self, os):
try:
os.write(str(self.mValue))
except:
pass
def writeXML(self, node, namespace):
value = self.getXMLNode(node, namespace)
value.text = str(self.mValue)
def parseJSONValue(self, jobject):
self.mValue = float(jobject)
def writeJSONValue(self, jobject):
jobject.append(self.mValue)
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_FLOAT, FloatValue,
xmldefinitions.value_float)
def parseJSONValue(self, jobject):
for jvalue in jobject:
value = Value.createFromType(self.mType)
value.parseJSONValue(jvalue)
self.mValues.append(value)
description = XML.SubElement(
value,
xmlutils.makeTag(namespace, xmldefinitions.req_status_description))
description.text = self.mValue[1]
if len(self.mValue) == 3 and self.mValue[2]:
data = XML.SubElement(
value,
xmlutils.makeTag(namespace, xmldefinitions.req_status_data))
data.text = self.mValue[2]
def parseJSONValue(self, jobject):
self.mValue = map(lambda x: x.encode("utf-8"), jobject)
def writeJSONValue(self, jobject):
value = [self.mValue[0], self.mValue[1]]
if len(self.mValue) == 3:
value.append(self.mValue[2])
jobject.append(value)
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_REQUEST_STATUS, RequestStatusValue, None,
xmldefinitions_top.value_text)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# iCalendar UTC Offset value
from pycalendar import xmldefinitions
from pycalendar.plaintextvalue import PlainTextValue
from pycalendar.value import Value
class CalAddressValue(PlainTextValue):
def getType(self):
return Value.VALUETYPE_CALADDRESS
Value.registerType(Value.VALUETYPE_CALADDRESS, CalAddressValue, xmldefinitions.value_cal_address)
def __init__(self, value=None):
self.mValue = value
def duplicate(self):
return OrgValue(self.mValue)
def getType(self):
return Value.VALUETYPE_ORG
def parse(self, data, variant="vcard"):
self.mValue = utils.parseTextList(data, ";")
def generate(self, os):
utils.generateTextList(os, self.mValue, ";")
def parseJSONValue(self, jobject):
self.mValue = tuple(map(lambda x: x.encode("utf-8"), jobject))
def writeJSONValue(self, jobject):
jobject.append(list(self.mValue))
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_ORG, OrgValue, None)
code = XML.SubElement(value, xmlutils.makeTag(namespace, xmldefinitions.req_status_code))
code.text = self.mValue[0]
description = XML.SubElement(value, xmlutils.makeTag(namespace, xmldefinitions.req_status_description))
description.text = self.mValue[1]
if len(self.mValue) == 3 and self.mValue[2]:
data = XML.SubElement(value, xmlutils.makeTag(namespace, xmldefinitions.req_status_data))
data.text = self.mValue[2]
def parseJSONValue(self, jobject):
self.mValue = map(lambda x: x.encode("utf-8"), jobject)
def writeJSONValue(self, jobject):
value = [self.mValue[0], self.mValue[1]]
if len(self.mValue) == 3:
value.append(self.mValue[2])
jobject.append(value)
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_REQUEST_STATUS, RequestStatusValue, None, xmldefinitions_top.value_text)
"""
def __init__(self, value=None):
self.mValue = value
def duplicate(self):
return OrgValue(self.mValue)
def getType(self):
return Value.VALUETYPE_ORG
def parse(self, data, variant="vcard"):
self.mValue = utils.parseTextList(data, ';')
def generate(self, os):
utils.generateTextList(os, self.mValue, ';')
def parseJSONValue(self, jobject):
self.mValue = tuple(map(lambda x: x.encode("utf-8"), jobject))
def writeJSONValue(self, jobject):
jobject.append(list(self.mValue))
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_ORG, OrgValue, None)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# vCard ADR value
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
from pycalendar.vcard.adr import Adr
class AdrValue(WrapperValue, Value):
_wrappedClass = Adr
_wrappedType = Value.VALUETYPE_ADR
Value.registerType(Value.VALUETYPE_ADR, AdrValue, None)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
from pycalendar.icalendar import xmldefinitions
from pycalendar.icalendar.recurrence import Recurrence
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
class RecurrenceValue(WrapperValue, Value):
_wrappedClass = Recurrence
_wrappedType = Value.VALUETYPE_RECUR
def writeXML(self, node, namespace):
self.mValue.writeXML(node, namespace)
Value.registerType(Value.VALUETYPE_RECUR, RecurrenceValue, xmldefinitions.value_recur)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# iCalendar UTC Offset value
from pycalendar import xmldefinitions
from pycalendar.plaintextvalue import PlainTextValue
from pycalendar.value import Value
class CalAddressValue(PlainTextValue):
def getType(self):
return Value.VALUETYPE_CALADDRESS
Value.registerType(Value.VALUETYPE_CALADDRESS, CalAddressValue,
xmldefinitions.value_cal_address)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# iCalendar Unknown value - one whose default type we don't know about
from pycalendar import xmldefinitions
from pycalendar.plaintextvalue import PlainTextValue
from pycalendar.value import Value
class UnknownValue(PlainTextValue):
def getType(self):
return UnknownValue.VALUETYPE_UNKNOWN
Value.registerType(Value.VALUETYPE_UNKNOWN, UnknownValue, xmldefinitions.value_unknown)
def generate(self, os):
os.write("%s;%s" % (self.mValue[0], self.mValue[1],))
def writeXML(self, node, namespace):
value = self.getXMLNode(node, namespace)
latitude = XML.SubElement(value, xmlutils.makeTag(namespace, xmldefinitions.geo_latitude))
latitude.text = self.mValue[0]
longitude = XML.SubElement(value, xmlutils.makeTag(namespace, xmldefinitions.geo_longitude))
longitude.text = self.mValue[1]
def parseJSONValue(self, jobject):
self.mValue = jobject
def writeJSONValue(self, jobject):
jobject.append(list(self.mValue))
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_GEO, GeoValue, xmldefinitions.geo, xmldefinitions_top.value_float)
def writeXML(self, node, namespace):
os = StringIO()
self.generate(os)
text = os.getvalue()
text = text[:-2] + ":" + text[-2:]
value = self.getXMLNode(node, namespace)
value.text = text
def parseJSONValue(self, jobject):
self.parse(str(jobject), variant="vcard")
def writeJSONValue(self, jobject):
os = StringIO()
self.generate(os, fullISO=True)
text = os.getvalue()
jobject.append(text)
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_UTC_OFFSET, UTCOffsetValue,
xmldefinitions.value_utc_offset)
# os - StringIO object
def generate(self, os):
try:
os.write(str(self.mValue))
except:
pass
def writeXML(self, node, namespace):
value = self.getXMLNode(node, namespace)
value.text = str(self.mValue)
def parseJSONValue(self, jobject):
self.mValue = float(jobject)
def writeJSONValue(self, jobject):
jobject.append(self.mValue)
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_FLOAT, FloatValue, xmldefinitions.value_float)
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
from pycalendar.icalendar import xmldefinitions
from pycalendar.icalendar.recurrence import Recurrence
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
class RecurrenceValue(WrapperValue, Value):
_wrappedClass = Recurrence
_wrappedType = Value.VALUETYPE_RECUR
def writeXML(self, node, namespace):
self.mValue.writeXML(node, namespace)
Value.registerType(Value.VALUETYPE_RECUR, RecurrenceValue,
xmldefinitions.value_recur)
class URIValue(PlainTextValue):
def getType(self):
return URIValue.VALUETYPE_URI
def parse(self, data, variant):
if ParserContext.BACKSLASH_IN_URI_VALUE == ParserContext.PARSER_FIX:
# Decoding required
self.mValue = utils.decodeTextValue(data)
else:
# No decoding required
self.mValue = data
# os - StringIO object
def generate(self, os):
"""
Handle a client bug where it sometimes includes a \n in the value and we need
to make sure that gets encoded rather than included literally which would break syntax.
"""
if "\n" in self.mValue:
try:
# No encoding required
os.write(self.mValue.replace("\n", "\\n"))
except:
pass
else:
super(URIValue, self).generate(os)
Value.registerType(Value.VALUETYPE_URI, URIValue, xmldefinitions.value_uri)
def parseJSONValue(self, jobject):
for jvalue in jobject:
value = Value.createFromType(self.mType)
value.parseJSONValue(jvalue)
self.mValues.append(value)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
from pycalendar import xmldefinitions
from pycalendar.duration import Duration
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
class DurationValue(WrapperValue, Value):
_wrappedClass = Duration
_wrappedType = Value.VALUETYPE_DURATION
Value.registerType(Value.VALUETYPE_DURATION, DurationValue,
xmldefinitions.value_duration)
def generate(self, os):
try:
first = True
for iter in self.mValues:
if first:
first = False
else:
os.write(",")
iter.generate(os)
except:
pass
def writeXML(self, node, namespace):
for iter in self.mValues:
iter.writeXML(node, namespace)
def parseJSONValue(self, jobject):
for jvalue in jobject:
value = Value.createFromType(self.mType)
value.parseJSONValue(jvalue)
self.mValues.append(value)
def writeJSONValue(self, jobject):
for iter in self.mValues:
iter.writeJSONValue(jobject)
Value.registerType(Value.VALUETYPE_MULTIVALUE, MultiValue, None)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
from pycalendar import xmldefinitions
from pycalendar.duration import Duration
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
class DurationValue(WrapperValue, Value):
_wrappedClass = Duration
_wrappedType = Value.VALUETYPE_DURATION
Value.registerType(Value.VALUETYPE_DURATION, DurationValue, xmldefinitions.value_duration)
return Value.VALUETYPE_INTEGER
def parse(self, data, variant):
self.mValue = int(data)
# os - StringIO object
def generate(self, os):
try:
os.write(str(self.mValue))
except:
pass
def writeXML(self, node, namespace):
value = self.getXMLNode(node, namespace)
value.text = str(self.mValue)
def parseJSONValue(self, jobject):
self.mValue = int(jobject)
def writeJSONValue(self, jobject):
jobject.append(self.mValue)
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_INTEGER, IntegerValue, xmldefinitions.value_integer)
self.mValues.append(value)
def generate(self, os):
try:
first = True
for iter in self.mValues:
if first:
first = False
else:
os.write(",")
iter.generate(os)
except:
pass
def writeXML(self, node, namespace):
for iter in self.mValues:
iter.writeXML(node, namespace)
def parseJSONValue(self, jobject):
for jvalue in jobject:
value = Value.createFromType(self.mType)
value.parseJSONValue(jvalue)
self.mValues.append(value)
def writeJSONValue(self, jobject):
for iter in self.mValues:
iter.writeJSONValue(jobject)
Value.registerType(Value.VALUETYPE_MULTIVALUE, MultiValue, None)
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# iCalendar UTC Offset value
from pycalendar import utils, xmldefinitions
from pycalendar.plaintextvalue import PlainTextValue
from pycalendar.value import Value
class TextValue(PlainTextValue):
def getType(self):
return Value.VALUETYPE_TEXT
def parse(self, data, variant):
# Decoding required
self.mValue = utils.decodeTextValue(data)
# os - StringIO object
def generate(self, os):
try:
# Encoding required
utils.writeTextValue(os, self.mValue)
except:
pass
Value.registerType(Value.VALUETYPE_TEXT, TextValue, xmldefinitions.value_text)
##
# Copyright (c) 2007-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
from pycalendar import xmldefinitions
from pycalendar.period import Period
from pycalendar.value import Value
from pycalendar.valueutils import WrapperValue
class PeriodValue(WrapperValue, Value):
_wrappedClass = Period
_wrappedType = Value.VALUETYPE_PERIOD
Value.registerType(Value.VALUETYPE_PERIOD, PeriodValue, xmldefinitions.value_period)
self.mValue[0],
self.mValue[1],
))
def writeXML(self, node, namespace):
value = self.getXMLNode(node, namespace)
latitude = XML.SubElement(
value, xmlutils.makeTag(namespace, xmldefinitions.geo_latitude))
latitude.text = self.mValue[0]
longitude = XML.SubElement(
value, xmlutils.makeTag(namespace, xmldefinitions.geo_longitude))
longitude.text = self.mValue[1]
def parseJSONValue(self, jobject):
self.mValue = jobject
def writeJSONValue(self, jobject):
jobject.append(list(self.mValue))
def getValue(self):
return self.mValue
def setValue(self, value):
self.mValue = value
Value.registerType(Value.VALUETYPE_GEO, GeoValue, xmldefinitions.geo,
xmldefinitions_top.value_float)
##
# Copyright (c) 2011-2013 Cyrus Daboo. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##
# iCalendar Binary value
from pycalendar import xmldefinitions
from pycalendar.plaintextvalue import PlainTextValue
from pycalendar.value import Value
class BinaryValue(PlainTextValue):
def getType(self):
return Value.VALUETYPE_BINARY
Value.registerType(Value.VALUETYPE_BINARY, BinaryValue, xmldefinitions.value_binary)
