Python datatype.DateTime类代码示例

def get_value(element, value_type=None, try_get_text=True, get_type=False):
    """Only for "with office:value-type" elements
    """
    if value_type is None:
        value_type = element.get_attribute('office:value-type')
    if value_type == 'boolean':
        value = element.get_attribute('office:boolean-value')
        if get_type:
            return (Boolean.decode(value), value_type)
        return Boolean.decode(value)
    elif value_type in  ('float', 'percentage', 'currency'):
        value = dec(element.get_attribute('office:value'))
        # Return 3 instead of 3.0 if possible
        if int(value) == value:
            if get_type:
                return (int(value), value_type)
            return int(value)
        if get_type:
                return (value, value_type)
        return value
    elif value_type == 'date':
        value = element.get_attribute('office:date-value')
        if 'T' in value:
            if get_type:
                return (DateTime.decode(value), value_type)
            return DateTime.decode(value)
        else:
            if get_type:
                return (Date.decode(value), value_type)
            return Date.decode(value)
    elif value_type == 'string':
        value = element.get_attribute('office:string-value')
        if value is not None:
            if get_type:
                return (unicode(value), value_type)
            return unicode(value)
        if try_get_text:
            value = []
            for para in element.get_elements('text:p'):
                value.append(para.get_text(recursive=True))
            if value:
                if get_type:
                    return (u"\n".join(value), value_type)
                return u"\n".join(value)
        if get_type:
            return (None, value_type)
        return None
    elif value_type == 'time':
        value = Duration.decode(element.get_attribute('office:time-value'))
        if get_type:
            return (value, value_type)
        return value
    elif value_type is None:
        if get_type:
            return (None, None)
        return None

    raise ValueError, 'unexpected value type "%s"' % value_type

def _get_element_list(context, element_name, content=None, href=None,
        svg_title=None, svg_desc=None, dc_creator=None, dc_date=None, **kw):
    query = _make_xpath_query(element_name, **kw)
    elements = context.get_element_list(query)
    # Filter the elements with the regex (TODO use XPath)
    if content is not None:
        elements = [element for element in elements if element.match(content)]
    if href is not None:
        filtered = []
        for element in elements:
            href_attr = element.get_attribute('xlink:href')
            if search(href, href_attr) is not None:
                filtered.append(element)
        elements = filtered
    if dc_date is not None:
        # XXX Date or DateTime?
        dc_date = DateTime.encode(dc_date)
    for variable, childname in [
            (svg_title, 'svg:title'),
            (svg_desc, 'svg:desc'),
            (dc_creator, 'descendant::dc:creator'),
            (dc_date, 'descendant::dc:date')]:
        if not variable:
            continue
        filtered = []
        for element in elements:
            child = element.get_element(childname)
            if child and child.match(variable):
                filtered.append(element)
        elements = filtered
    return elements

    def get_user_defined_metadata(self):
        """Return a dict of unicode/value mapping.

        Value types can be: Decimal, date, time, boolean or unicode.
        """

        result = {}
        for meta in self.get_elements('//meta:user-defined'):
            # Read the values
            name = meta.get_attribute('meta:name')
            value_type = meta.get_attribute('meta:value-type')
            if value_type is None:
                value_type = 'string'
            value = meta.get_text()
            # Interpretation
            if value_type == 'boolean':
                result[name] = Boolean.decode(value)
            elif value_type in  ('float', 'percentage', 'currency'):
                result[name] = Decimal(value)
            elif value_type == 'date':
                if 'T' in value:
                    result[name] = DateTime.decode(value)
                else:
                    result[name] = Date.decode(value)
            elif value_type == 'string':
                result[name] = value
            elif value_type == 'time':
                result[name] = Duration.decode(value)
        return result

 def _get_meta_value(element, full=False):
     """get_value deicated to the meta data part, for one meta element.
     """
     name = element.get_attribute('meta:name')
     value_type = element.get_attribute('meta:value-type')
     if value_type is None:
         value_type = 'string'
     text = element.get_text()
     # Interpretation
     if value_type == 'boolean':
         value = Boolean.decode(text)
     elif value_type in  ('float', 'percentage', 'currency'):
         value = Decimal(text)
     elif value_type == 'date':
         if 'T' in text:
             value = DateTime.decode(text)
         else:
             value = Date.decode(text)
     elif value_type == 'string':
         value = text
     elif value_type == 'time':
         value = Duration.decode(text)
     if full:
         return (value, value_type, text)
     else:
         return value

 def set_user_defined_metadata(self, name, value):
     if type(value) is bool:
         value_type = 'boolean'
         value = u'true' if value else u'false'
     elif isinstance(value, (int, float, Decimal)):
         value_type = 'float'
         value = unicode(value)
     elif type(value) is date:
         value_type = 'date'
         value = unicode(Date.encode(value))
     elif type(value) is datetime:
         value_type = 'date'
         value = unicode(DateTime.encode(value))
     elif type(value) is str:
         value_type = 'string'
         value = unicode(value)
     elif type(value) is unicode:
         value_type = 'string'
     elif type(value) is timedelta:
         value_type = 'time'
         value = unicode(Duration.encode(value))
     else:
         raise TypeError, 'unexpected type "%s" for value' % type(value)
     # Already the same element ?
     for metadata in self.get_elements('//meta:user-defined'):
         if metadata.get_attribute('meta:name') == name:
             break
     else:
         metadata = odf_create_element('meta:user-defined')
         metadata.set_attribute('meta:name', name)
         self.get_meta_body().append(metadata)
     metadata.set_attribute('meta:value-type', value_type)
     metadata.set_text(value)

    def get_modification_date(self):
        """Get the last modified date of the document.

        Return: datetime (or None if inexistant)
        """
        element = self.get_element('//dc:date')
        if element is None:
            return None
        modification_date = element.get_text()
        return DateTime.decode(modification_date)

    def get_creation_date(self):
        """Get the creation date of the document.

        Return: datetime (or None if inexistant)
        """
        element = self.get_element('//meta:creation-date')
        if element is None:
            return None
        creation_date = element.get_text()
        return DateTime.decode(creation_date)

def odf_create_time_variable(time, fixed=False, data_style=None, text=None, time_adjust=None):
    element = odf_create_element("text:time")
    element.set_attribute("text:time-value", DateTime.encode(time))
    if fixed:
        element.set_attribute("text:fixed", "true")
    if data_style is not None:
        element.set_style_attribute("style:data-style-name", data_style)
    if text is None:
        text = time.strftime("%H:%M:%S")
    element.set_text(text)
    if time_adjust is not None:
        element.set_attribute("text:time-adjust", Duration.encode(time_adjust))
    return element

    def set_modification_date(self, date):
        """Set the last modified date of the document.

        Arguments:

            date -- datetime
        """
        element = self.get_element('//dc:date')
        if element is None:
            element = odf_create_element('dc:date')
            self.get_meta_body().append(element)
        modification_date = DateTime.encode(date)
        element.set_text(modification_date)

    def set_creation_date(self, date):
        """Set the creation date of the document.

        Arguments:

            date -- datetime
        """
        element = self.get_element('//meta:creation-date')
        if element is None:
            element = odf_create_element('meta:creation-date')
            self.get_meta_body().append(element)
        creation_date = DateTime.encode(date)
        element.set_text(creation_date)

def odf_create_time_variable(time, fixed=False, data_style=None, text=None,
        time_adjust=None):
    data = '<text:time text:time-value="%s"/>'
    element = odf_create_element(data % DateTime.encode(time))
    if fixed:
        element.set_attribute('text:fixed', 'true')
    if data_style is not None:
        element.set_attribute('style:data-style-name', data_style)
    if text is None:
        text = time.strftime('%H:%M:%S')
    element.set_text(text)
    if time_adjust is not None:
        element.set_attribute('text:time-adjust',
                               Duration.encode(time_adjust))
    return element

def odf_create_date_variable(date, fixed=False, data_style=None, text=None,
        date_adjust=None):
    element = odf_create_element('text:date')
    element.set_attribute('text:date-value', DateTime.encode(date))
    if fixed:
        element.set_attribute('text:fixed', 'true')
    if data_style is not None:
        element.set_style_attribute('style:data-style-name', data_style)
    if text is None:
        text = Date.encode(date)
    element.set_text(text)
    if date_adjust is not None:
        element.set_attribute('text:date-adjust',
                               Duration.encode(date_adjust))
    return element

    def set_dc_date(self, date=None):
        """Set the date of the change. If date is None, use current time.

        Arguments:

            date -- datetime
        """
        if date is None:
            date = datetime.now()
        dcdate = DateTime.encode(date)
        element = self.get_element('dc:date')
        if element is None:
            element = odf_create_element('dc:date')
            self.insert(element, xmlposition=LAST_CHILD)
        element.set_text(dcdate)

def get_value(element, value_type=None, try_get_text=True):
    """Only for "with office:value-type" elements
    """

    if value_type is None:
        value_type = element.get_attribute('office:value-type')

    if value_type == 'boolean':
        value = element.get_attribute('office:boolean-value')
        return Boolean.decode(value)
    elif value_type in  ('float', 'percentage', 'currency'):
        value = dec(element.get_attribute('office:value'))
        # Return 3 instead of 3.0 if possible
        if int(value) == value:
            return int(value)
        return value
    elif value_type == 'date':
        value = element.get_attribute('office:date-value')
        if 'T' in value:
            return DateTime.decode(value)
        else:
            return Date.decode(value)
    elif value_type == 'string':
        value = element.get_attribute('office:string-value')
        if value is not None:
            return unicode(value)
        # XXX: get_text or get_formatted_text ???
        if try_get_text:
            value = element.get_text(recursive=True)
            if value != '':
                return value
        return None

    elif value_type == 'time':
        value = element.get_attribute('office:time-value')
        return Duration.decode(value)
    elif value_type is None:
        return None

    raise ValueError, 'unexpected value type "%s"' % value_type

 def get_dc_date(self):
     dc_date = self.get_element('descendant::dc:date')
     if dc_date is None:
         return None
     date = dc_date.get_text()
     return DateTime.decode(date)