Python formatter.SafeFormat类代码示例

 def template_to_attribute(self, other, ops):
     '''
     Takes a list [(src,dest), (src,dest)], evaluates the template in the
     context of other, then copies the result to self[dest]. This is on a
     best-efforts basis. Some assignments can make no sense.
     '''
     if not ops:
         return
     from calibre.ebooks.metadata.book.formatter import SafeFormat
     formatter = SafeFormat()
     for op in ops:
         try:
             src = op[0]
             dest = op[1]
             val = formatter.safe_format(src, other, 'PLUGBOARD TEMPLATE ERROR', other)
             if dest == 'tags':
                 self.set(dest, [f.strip() for f in val.split(',') if f.strip()])
             elif dest == 'authors':
                 self.set(dest, [f.strip() for f in val.split('&') if f.strip()])
             else:
                 self.set(dest, val)
         except:
             if DEBUG:
                 traceback.print_exc()

 def __init__(self, title, authors=(_('Unknown'),), other=None, template_cache=None):
     '''
     @param title: title or ``_('Unknown')``
     @param authors: List of strings or []
     @param other: None or a metadata object
     '''
     _data = copy.deepcopy(NULL_VALUES)
     _data.pop('language')
     object.__setattr__(self, '_data', _data)
     if other is not None:
         self.smart_update(other)
     else:
         if title:
             self.title = title
         if authors:
             # List of strings or []
             self.author = list(authors) if authors else []# Needed for backward compatibility
             self.authors = list(authors) if authors else []
     from calibre.ebooks.metadata.book.formatter import SafeFormat
     self.formatter = SafeFormat()
     self.template_cache = template_cache

 def get_value(self, orig_key, args, kwargs):
     ans = SafeFormat.get_value(self, orig_key, args, kwargs)
     return escape_formatting(ans)

class Metadata(object):

    '''
    A class representing all the metadata for a book. The various standard metadata
    fields are available as attributes of this object. You can also stick
    arbitrary attributes onto this object.

    Metadata from custom columns should be accessed via the get() method,
    passing in the lookup name for the column, for example: "#mytags".

    Use the :meth:`is_null` method to test if a field is null.

    This object also has functions to format fields into strings.

    The list of standard metadata fields grows with time is in
    :data:`STANDARD_METADATA_FIELDS`.

    Please keep the method based API of this class to a minimum. Every method
    becomes a reserved field name.
    '''

    def __init__(self, title, authors=(_('Unknown'),), other=None, template_cache=None,
                 formatter=None):
        '''
        @param title: title or ``_('Unknown')``
        @param authors: List of strings or []
        @param other: None or a metadata object
        '''
        _data = copy.deepcopy(NULL_VALUES)
        _data.pop('language')
        object.__setattr__(self, '_data', _data)
        if other is not None:
            self.smart_update(other)
        else:
            if title:
                self.title = title
            if authors:
                # List of strings or []
                self.author = list(authors) if authors else []  # Needed for backward compatibility
                self.authors = list(authors) if authors else []
        from calibre.ebooks.metadata.book.formatter import SafeFormat
        self.formatter = SafeFormat() if formatter is None else formatter
        self.template_cache = template_cache

    def is_null(self, field):
        '''
        Return True if the value of field is null in this object.
        'null' means it is unknown or evaluates to False. So a title of
        _('Unknown') is null or a language of 'und' is null.

        Be careful with numeric fields since this will return True for zero as
        well as None.

        Also returns True if the field does not exist.
        '''
        try:
            null_val = NULL_VALUES.get(field, None)
            val = getattr(self, field, None)
            return not val or val == null_val
        except:
            return True

    def __getattribute__(self, field):
        _data = object.__getattribute__(self, '_data')
        if field in SIMPLE_GET:
            return _data.get(field, None)
        if field in TOP_LEVEL_IDENTIFIERS:
            return _data.get('identifiers').get(field, None)
        if field == 'language':
            try:
                return _data.get('languages', [])[0]
            except:
                return NULL_VALUES['language']
        try:
            return object.__getattribute__(self, field)
        except AttributeError:
            pass
        if field in _data['user_metadata'].iterkeys():
            d = _data['user_metadata'][field]
            val = d['#value#']
            if d['datatype'] != 'composite':
                return val
            if val is None:
                d['#value#'] = 'RECURSIVE_COMPOSITE FIELD (Metadata) ' + field
                val = d['#value#'] = self.formatter.safe_format(
                                            d['display']['composite_template'],
                                            self,
                                            _('TEMPLATE ERROR'),
                                            self, column_name=field,
                                            template_cache=self.template_cache).strip()
            return val
        if field.startswith('#') and field.endswith('_index'):
            try:
                return self.get_extra(field[:-6])
            except:
                pass
        raise AttributeError(
                'Metadata object has no attribute named: '+ repr(field))

    def __setattr__(self, field, val, extra=None):
#.........这里部分代码省略.........