Changeset 193

Timestamp:

04/17/12 16:48:27 (13 months ago)

Author:

cyrusdaboo

Message:

Support generation of JSON format iCalendar data. Exact format is a work in progress.

Location:

PyCalendar/branches/json/src/pycalendar

Files:

• attribute.py (modified) (1 diff)
• calendar.py (modified) (2 diffs)
• componentbase.py (modified) (3 diffs)
• datetime.py (modified) (2 diffs)
• datetimevalue.py (modified) (1 diff)
• duration.py (modified) (1 diff)
• durationvalue.py (modified) (1 diff)
• integervalue.py (modified) (1 diff)
• multivalue.py (modified) (1 diff)
• period.py (modified) (1 diff)
• periodvalue.py (modified) (1 diff)
• plaintextvalue.py (modified) (1 diff)
• property.py (modified) (1 diff)
• recurrence.py (modified) (1 diff)
• recurrencevalue.py (modified) (1 diff)
• requeststatusvalue.py (modified) (1 diff)
• tests/test_json.py (added)
• tests/test_xml.py (modified) (1 diff)
• utcoffsetvalue.py (modified) (2 diffs)
• value.py (modified) (1 diff)
• valueutils.py (modified) (1 diff)

PyCalendar/branches/json/src/pycalendar/attribute.py

@@ -104 +104 @@
             text = XML.SubElement(param, xmldefs.makeTag(namespace, xmldefs.value_text))
             text.text = value
+
+    def writeJSON(self, jobject):
+        jobject[self.getName().lower()] = self.mValues if len(self.mValues) > 1 else self.mValues[0]
+

PyCalendar/branches/json/src/pycalendar/calendar.py

@@ -42 +42 @@
 import collections
 import xml.etree.cElementTree as XML
+import json
 
 class PyCalendar(PyCalendarComponentBase):
@@ -457 +458 @@
         super(PyCalendar, self).writeXML(root, xmldefs.iCalendar20_namespace)
         return root
+        
+    def getTextJSON(self, includeTimezones=False):
+        jobject = self.writeJSON(includeTimezones)
+        return json.dumps(jobject, indent=2)
+
+    def writeJSON(self, includeTimezones=False):
+        # Make sure all required timezones are in this object
+        if includeTimezones:
+            self.includeTimezones()
+            
+        # Root node structure
+        vcalendar = []
+        super(PyCalendar, self).writeJSON(vcalendar)
+        return vcalendar
         
     # Get expanded components

PyCalendar/branches/json/src/pycalendar/componentbase.py

@@ -309 +309 @@
         self.writeComponentsFilteredXML(comp, namespace, filter)
 
+    def writeJSON(self, jobject):
+        
+        # Component element
+        comp = {"type":self.getType().lower()}
+        jobject.append(comp)
+        
+        # Each property
+        self.writePropertiesJSON(comp)
+    
+        # Each component
+        self.writeComponentsJSON(comp)
+    
+    def writeJSONFiltered(self, jobject, filter):
+        # Component element
+        comp = {"type":self.getType()}
+        jobject.append(comp)
+        
+        # Each property
+        self.writePropertiesFilteredJSON(comp, filter)
+    
+        # Each component
+        self.writeComponentsFilteredJSON(comp, filter)
+
     def sortedComponents(self):
         
@@ -371 +394 @@
                     if subfilter is not None:
                         subcomp.writeFilteredXML(comps, namespace, subfilter)
+        
+    def writeComponentsJSON(self, jobject):
+        
+        if self.mComponents:
+            comps = []
+            jobject["components"] = comps
+            
+            # Write out the remainder 
+            for component in self.sortedComponents():
+                component.writeJSON(comps)
+
+    def writeComponentsFilteredJSON(self, jobject, filter):
+
+        if self.mComponents:
+            comps = []
+            jobject["components"] = comps
+            
+            # Shortcut for all sub-components
+            if filter.isAllSubComponents():
+                self.writeJSON(comps)
+            elif filter.hasSubComponentFilters():
+                for subcomp in self.sortedcomponents():
+                    subfilter = filter.getSubComponentFilter(subcomp.getType())
+                    if subfilter is not None:
+                        subcomp.writeFilteredJSON(comps, subfilter)
         
     def loadValue(self, value_name):
@@ -530 +578 @@
                     prop.writeFilteredXML(props, namespace, filter)
 
+    def writePropertiesJSON(self, jobject):
+
+        properties = {}
+        jobject["properties"] = properties
+        
+        # Sort properties by name
+        keys = self.sortedPropertyKeys()
+        for key in keys:
+            props = self.mProperties[key]
+            for prop in props:
+                prop.writeJSON(properties)
+
+    def writePropertiesFilteredJSON(self, jobject, filter):
+
+        properties = {}
+        jobject["properties"] = properties
+        
+        # Sort properties by name
+        keys = self.sortedPropertyKeys()
+
+        # Shortcut for all properties
+        if filter.isAllProperties():
+            for key in keys:
+                for prop in self.getProperties(key):
+                    prop.writeJSON(properties)
+        elif filter.hasPropertyFilters():
+            for key in keys:
+                for prop in self.getProperties(key):
+                    prop.writeFilteredJSON(properties, filter)
+
     def loadPrivateValue(self, value_name):
         # Read it in from properties list and then delete the property from the

PyCalendar/branches/json/src/pycalendar/datetime.py

@@ -814 +814 @@
                 return "%04d-%02d-%02dT%02d:%02d:%02d" % ( self.mYear, self.mMonth, self.mDay, self.mHours, self.mMinutes, self.mSeconds )
 
+    getJSONText = getXMLText
+    
     @classmethod
     def parseText(cls, data, fullISO=False):
@@ -966 +968 @@
         value.text = self.getXMLText()
 
+    def writeJSON(self, jobject):
+        jobject["date" if self.isDateOnly() else "date-time"] = self.getJSONText()
+
     def normalise( self ):
         # Normalise seconds

PyCalendar/branches/json/src/pycalendar/datetimevalue.py

@@ -39 +39 @@
         self.mValue.writeXML(node, namespace)
 
+    def writeJSON(self, jobject):
+        self.mValue.writeJSON(jobject)
+
     def getValue(self):
         return self.mValue

PyCalendar/branches/json/src/pycalendar/duration.py

@@ -254 +254 @@
     def writeXML(self, node, namespace):
         node.text = self.getText()
+
+    def writeJSON(self, jobject):
+        jobject["duration"] = self.getText()
+

PyCalendar/branches/json/src/pycalendar/durationvalue.py

@@ -40 +40 @@
         value.text = self.mValue.writeXML()
 
+    def writeJSON(self, jobject):
+        self.mValue.writeJSON(jobject)
+
     def getValue(self):
         return self.mValue

PyCalendar/branches/json/src/pycalendar/integervalue.py

@@ -45 +45 @@
         value.text = str(self.mValue)
 
+    def writeJSON(self, jobject):
+        jobject["integer"] = self.mValue
+
     def getValue(self):
         return self.mValue

PyCalendar/branches/json/src/pycalendar/multivalue.py

@@ -83 +83 @@
             iter.writeXML(node, namespace)
 
+    def writeJSON(self, jobject):
+        mtype = None
+        values = []
+        for iter in self.mValues:
+            result = {}
+            iter.writeJSON(result)
+            k, v = result.items()[0]
+            if mtype is None:
+                mtype = k
+            values.append(v)
+        jobject[mtype] = values
+
 PyCalendarValue.registerType(PyCalendarValue.VALUETYPE_MULTIVALUE, PyCalendarMultiValue, None)

PyCalendar/branches/json/src/pycalendar/period.py

@@ -104 +104 @@
             end.text = self.mEnd.getXMLText()
 
+    def writeJSON(self, jobject):
+        
+        period = {}
+        jobject["period"] = period
+        
+        period["start"] = self.mStart.getJSONText()
+        
+        if self.mUseDuration:
+            period["duration"] = self.mDuration.getText()
+        else:
+            period["end"] = self.mEnd.getJSONText()
+        
     def getStart( self ):
         return self.mStart

PyCalendar/branches/json/src/pycalendar/periodvalue.py

@@ -40 +40 @@
         value.text = self.mValue.writeXML()
 
+    def writeJSON(self, jobject):
+        self.mValue.writeJSON(jobject)
+
     def getValue( self ):
         return self.mValue

PyCalendar/branches/json/src/pycalendar/plaintextvalue.py

@@ -43 +43 @@
         value.text = self.mValue
 
+    def writeJSON(self, jobject):
+        jobject["text"] = self.mValue
+
     def getValue(self):
         return self.mValue

PyCalendar/branches/json/src/pycalendar/property.py

@@ -500 +500 @@
             self.mValue.writeXML(prop, namespace)
     
+    def writeJSON(self, jobject):
+        
+        prop = {}
+        if self.getName().lower() not in jobject:
+            jobject[self.getName().lower()] = prop
+        elif isinstance(jobject[self.getName().lower()], list):
+            jobject[self.getName().lower()].append(prop)
+        else:
+            jobject[self.getName().lower()] = [jobject[self.getName().lower()], prop]
+        
+        # Write all attributes
+        if len(self.mAttributes):
+            params = {}
+            prop["parameters"] = params
+            for key in sorted(self.mAttributes.keys()):
+                for attr in self.mAttributes[key]:
+                    if attr.getName() != "VALUE":
+                        attr.writeJSON(params)
+
+        # Write value
+        if self.mValue:
+            self.mValue.writeJSON(prop)
+        
+
     def _init_PyCalendarProperty(self):
         self.mName = ""

PyCalendar/branches/json/src/pycalendar/recurrence.py

@@ -673 +673 @@
                 child.text = str(item)
                 
+    def writeJSON(self, jobject):
+
+        recur = {}
+        jobject["recur"] = recur
+
+        recur["freq"] = self.cFreqToXMLMap[self.mFreq]
+
+        if self.mUseCount:
+            recur["count"] = self.mCount
+        elif self.mUseUntil:
+            recur["until"] = self.mUntil.getJSONText()
+
+        if self.mInterval > 1:
+            recur["interval"] = self.mInterval
+
+        if self.mBySeconds is not None and len(self.mBySeconds) != 0:
+            recur["bysecond"] = self.mBySeconds
+        if self.mByMinutes is not None and len(self.mByMinutes) != 0:
+            recur["byminute"] = self.mByMinutes
+        if self.mByHours is not None and len(self.mByHours) != 0:
+            recur["byhour"] = self.mByHours
+            
+        if self.mByDay is not None and len(self.mByDay) != 0:
+            bydays = []
+            for iter in self.mByDay:
+                data = ""
+                if iter[0] != 0:
+                    data = str(iter[0])
+                data += self.cWeekdayRecurMap.get(iter[1], "")
+                bydays.append(data)
+            recur["byday"] = bydays
+
+        if self.mByMonthDay is not None and len(self.mByMonthDay) != 0:
+            recur["bymonthday"] = self.mByMonthDay
+        if self.mByYearDay is not None and len(self.mByYearDay) != 0:
+            recur["byyearday"] = self.mByYearDay
+        if self.mByWeekNo is not None and len(self.mByWeekNo) != 0:
+            recur["byweekno"] = self.mByWeekNo
+        if self.mByMonth is not None and len(self.mByMonth) != 0:
+            recur["bymonth"] = self.mByMonth
+        if self.mBySetPos is not None and len(self.mBySetPos) != 0:
+            recur["bysetpos"] = self.mBySetPos
+
+        # MO is the default so we do not need it
+        if self.mWeekstart != definitions.eRecurrence_WEEKDAY_MO:
+            recur["wkst"] = self.cWeekdayRecurMap.get(self.mWeekstart, definitions.cICalValue_RECUR_WEEKDAY_MO)
+
     
     def hasBy(self):

PyCalendar/branches/json/src/pycalendar/recurrencevalue.py

@@ -39 +39 @@
         self.mValue.writeXML(node, namespace)
 
+    def writeJSON(self, jobject):
+        self.mValue.writeJSON(jobject)
+
     def getValue( self ):
         return self.mValue

PyCalendar/branches/json/src/pycalendar/requeststatusvalue.py

@@ -91 +91 @@
         if len(self.mValue) == 3 and self.mValue[2]:
             data = XML.SubElement(node, xmldefs.makeTag(namespace, xmldefs.req_status_data))
-            data.text = self.mValue[1]
+            data.text = self.mValue[2]
+
+    def writeJSON(self, jobject):
+        jobject["request-status"] = {
+            "code": self.mValue[0],
+            "description": self.mValue[1]
+        }
+        if len(self.mValue) == 3 and self.mValue[2]:
+            jobject["request-status"]["data"] = self.mValue[2]
 
     def getValue(self):

PyCalendar/branches/json/src/pycalendar/tests/test_xml.py

@@ -20 +20 @@
 import unittest
 
-class TestCalendar(unittest.TestCase):
+class TestXML(unittest.TestCase):
     
     data = (

PyCalendar/branches/json/src/pycalendar/utcoffsetvalue.py

@@ -89 +89 @@
     def writeXML(self, node, namespace):
         
-        os = StringIO.StringIO()
+        os = StringIO()
         self.generate(os)
         text = os.getvalue()
@@ -96 +96 @@
         value = self.getXMLNode(node, namespace)
         value.text = text
+
+    def writeJSON(self, jobject):
+        
+        os = StringIO()
+        self.generate(os)
+        text = os.getvalue()
+        text = text[:-2] + ":" + text[-2:]
+
+        jobject["utc-offset"] = text
 
     def getValue( self ):

PyCalendar/branches/json/src/pycalendar/value.py

@@ -89 +89 @@
         raise NotImplementedError
 
+    def writeJSON(self, jobject):
+        raise NotImplementedError
+
     def getXMLNode(self, node, namespace):
         return XML.SubElement(node, xmldefs.makeTag(namespace, self._xmlMap[self.getType()]))

PyCalendar/branches/json/src/pycalendar/valueutils.py

@@ -43 +43 @@
     def writeXML(self, node, namespace):
         raise NotImplementedError
+
+    def writeJSON(self, jobject):
+        raise NotImplementedError