def vtimezone()

in src/zonal/zone.py [0:0]
59 lines of code
12 McCabe index (conditional complexity)

    def vtimezone(self, calendar, rules, minYear, maxYear):
        """
        Generate a VTIMEZONE for this Zone.

        @param calendar: the L{Calendar} object for the VCALENDAR in which the VTIMEZONE
            will be created.
        @param rules: the C{dict} containing the set of Rules currently defined.
        @param startYear: a C{int} containing the first year that should be present
            in the VTIMEZONE.
        @return: C{vtimezone} component.
        """

        # Get a VTIMEZONE component
        vtz = VTimezone(parent=calendar)

        # Add TZID property
        vtz.addProperty(Property(definitions.cICalProperty_TZID, self.name))
        vtz.addProperty(Property("X-LIC-LOCATION", self.name))

        transitions = self.expand(rules, minYear, maxYear)

        # Group rules
        lastZoneRule = None
        ruleorder = []
        rulemap = {}

        def _generateRuleData():
            # Generate VTIMEZONE component for last set of rules
            for tzrule in ruleorder:
                if tzrule:
                    # Accumulate tzrule portions with the same offset pairs
                    lastOffsetPair = (rulemap[tzrule][0][1], rulemap[tzrule][0][2],)
                    startIndex = 0
                    for index in xrange(len(rulemap[tzrule])):
                        offsetPair = (rulemap[tzrule][index][1], rulemap[tzrule][index][2],)
                        if offsetPair != lastOffsetPair:
                            tzrule.vtimezone(
                                vtz,
                                lastZoneRule,
                                rulemap[tzrule][startIndex][0],
                                rulemap[tzrule][index - 1][0],
                                rulemap[tzrule][startIndex][1],
                                rulemap[tzrule][startIndex][2],
                                index - startIndex,
                            )
                            lastOffsetPair = (rulemap[tzrule][index][1], rulemap[tzrule][index][2],)
                            startIndex = index

                    tzrule.vtimezone(
                        vtz,
                        lastZoneRule,
                        rulemap[tzrule][startIndex][0],
                        rulemap[tzrule][index][0],
                        rulemap[tzrule][startIndex][1],
                        rulemap[tzrule][startIndex][2],
                        len(rulemap[tzrule]),
                    )
                else:
                    lastZoneRule.vtimezone(
                        vtz,
                        lastZoneRule,
                        rulemap[tzrule][0][0],
                        rulemap[tzrule][-1][0],
                        rulemap[tzrule][0][1],
                        rulemap[tzrule][0][2],
                    )
            del ruleorder[:]
            rulemap.clear()

        for dt, offsetfrom, offsetto, zonerule, tzrule in transitions:

            # Check for change of rule - we ignore LMT's
            if zonerule.format != "LMT":
                if lastZoneRule and lastZoneRule != zonerule:
                    _generateRuleData()
                if tzrule not in ruleorder:
                    ruleorder.append(tzrule)
                rulemap.setdefault(tzrule, []).append((dt, offsetfrom, offsetto,))
            lastZoneRule = zonerule

        # Do left overs
        _generateRuleData()

        self._compressRDateComponents(vtz)

        vtz.finalise()
        return vtz