1

"""

     2

    Format LogLines into some other representation

     3

"""

     4

     5

import re, xml.sax.saxutils

     6

     7

from log_line import LogTypes

     8

from log_formatter_pil import PILImageFormatter

     9

from log_formatter_rss import RSSFormatter

    10

    11

class LogFormatter (object) :

    12

    """

    13

        Provides a method to format series of LogLines into various output formats, with varying themes.

    14

    """

    15

    16

    # machine-readable name

    17

    name = None

    18

    19

    # human-readable name

    20

    title = None

    21

    22

    ## parameters

    23

    # use a fixed-width font for HTML output

    24

    html_fixedwidth = True

    25

    26

    def __init__ (self, tz, timestamp_fmt, img_ttf_path, img_font_size) :

    27

        """

    28

            Initialize to format timestamps with the given timezone and timestamp.

    29

    30

            Use the given TTF font to render image text with the given size, if given, otherwise, a default one.

    31

        """

    32

    33

        self.tz = tz

    34

        self.timestamp_fmt = timestamp_fmt

    35

        self.img_ttf_path = img_ttf_path

    36

        self.img_font_size = img_font_size

    37

    38

    def _format_line_text (self, line, template_dict, full_timestamp=False) :

    39

        """

    40

            Format the given line as text, using the given { type: string template } dict

    41

        """

    42

    43

        # look up the template

    44

        template = template_dict[line.type]

    45

    46

        # convert timestamp into display timezone

    47

        dtz = line.timestamp.astimezone(self.tz)

    48

    49

        # full timestamps?

    50

        if full_timestamp :

    51

            # XXX: ugly hack

    52

            timestamp_fmt = '%Y-%m-%d ' + self.timestamp_fmt

    53

    54

        else :

    55

            timestamp_fmt = self.timestamp_fmt

    56

    57

        # breakdown source

    58

        source_nickname, source_username, source_hostname, source_chanflag = line.source

    59

        target_nickname = line.target

    60

    61

        # format with dict

    62

        return template % dict(

    63

            channel_name    = line.channel.name,

    64

            datetime        = dtz.strftime('%a %b %d %H:%M:%S %Y'),

    65

            timestamp       = dtz.strftime(timestamp_fmt),

    66

            source_nickname = source_nickname,

    67

            source_username = source_username,

    68

            source_hostname = source_hostname,

    69

            source_chanflag = source_chanflag,

    70

            target_nickname = target_nickname,

    71

            message         = line.data,

    72

        )

    73

    74

    def format_txt (self, lines, full_timestamps=False) :

    75

        """

    76

            Format given lines as plaintext.

    77

    78

            If full_timestamps is given, the output will contain full timestamps with both date and time.

    79

    80

            No trailing newlines.

    81

        """

    82

    83

        abstract

    84

    85

    def format_html (self, lines, full_timestamps=False) :

    86

        """

    87

            Format as HTML.

    88

    89

            See format_txt for information about arguments

    90

        """

    91

    92

        abstract

    93

    94

    def format_png (self, lines, full_timestamps=False) :

    95

        """

    96

            Format as a PNG image, returning the binary PNG data

    97

        """

    98

    99

        abstract

   100

   101

    def format_rss (self, lines, full_timestamps=False) :

   102

        """

   103

            Format as an XML RSS document

   104

        """

   105

   106

        abstract

   107

   108

class BaseHTMLFormatter (LogFormatter) :

   109

    """

   110

        Implements some HTML-formatting utils

   111

    """

   112

   113

    # parameters

   114

    html_fixedwidth = True

   115

   116

    # regexp to match URLs

   117

    URL_REGEXP = re.compile(r"http://\S+")

   118

   119

    def _process_links (self, line) :

   120

        """

   121

            Processed the rendered line, adding in <a href>'s for things that look like URLs, returning the new line.

   122

   123

            The line should already be escaped

   124

        """

   125

   126

        def _encode_url (match) :

   127

            # encode URL

   128

            url_html = match.group(0)

   129

            url_link = xml.sax.saxutils.unescape(url_html)

   130

   131

            return '<a href="%(url_link)s">%(url_html)s</a>' % dict(url_link=url_link, url_html=url_html)

   132

   133

        return self.URL_REGEXP.sub(_encode_url, line)

   134

   135

    def format_html (self, lines, **kwargs) :

   136

        """

   137

            Just uses format_txt, but processes links, etc

   138

        """

   139

   140

        # format using IrssiTextFormatter

   141

        for line, txt in self.format_txt(lines, **kwargs) :

   142

            # escape HTML

   143

            html = xml.sax.saxutils.escape(txt)

   144

   145

            # process links

   146

            html = self._process_links(html)

   147

   148

            # yield

   149

            yield line, html

   150

   151

   152

class IrssiTextFormatter (RSSFormatter, PILImageFormatter, LogFormatter) :

   153

    """

   154

        Implements format_txt for irssi-style output

   155

    """

   156

   157

    # format definitions by type

   158

    __FMT = {

   159

        LogTypes.RAW        : "%(timestamp)s %(data)s",

   160

        LogTypes.LOG_OPEN   : "--- Log opened %(datetime)s",

   161

        LogTypes.LOG_CLOSE  : "--- Log closed %(datetime)s",

   162

   163

        LogTypes.MSG        : "%(timestamp)s <%(source_chanflag)s%(source_nickname)s> %(message)s",

   164

        LogTypes.NOTICE     : "%(timestamp)s -%(source_nickname)s- %(message)s",

   165

        LogTypes.ACTION     : "%(timestamp)s  * %(source_nickname)s %(message)s",

   166

   167

        LogTypes.JOIN       : "%(timestamp)s -!- %(source_nickname)s [%(source_username)s@%(source_hostname)s] has joined %(channel_name)s",

   168

        LogTypes.PART       : "%(timestamp)s -!- %(source_nickname)s [%(source_username)s@%(source_hostname)s] has left %(channel_name)s [%(message)s]",

   169

        LogTypes.KICK       : "%(timestamp)s -!- %(target_nickname)s was kicked from %(channel_name)s by %(source_nickname)s [%(message)s]",

   170

        LogTypes.MODE       : "%(timestamp)s -!- mode/%(channel_name)s [%(message)s] by %(source_nickname)s",

   171

   172

        LogTypes.NICK       : "%(timestamp)s -!- %(source_nickname)s is now known as %(target_nickname)s",

   173

        LogTypes.QUIT       : "%(timestamp)s -!- %(source_nickname)s [%(source_username)s@%(source_hostname)s] has quit [%(message)s]",

   174

   175

        LogTypes.TOPIC      : "%(timestamp)s -!- %(source_nickname)s changed the topic of %(channel_name)s to: %(message)s",

   176

   177

        LogTypes.SELF_NOTICE: "%(timestamp)s -%(source_nickname)s- %(message)s",

   178

        LogTypes.SELF_NICK  : "%(timestamp)s -!- %(source_nickname)s is now known as %(target_nickname)s",

   179

    }

   180

   181

    def format_txt (self, lines, full_timestamps=False) :

   182

        # ...handle each line

   183

        for line in lines :

   184

            # using __TYPES

   185

            yield line, self._format_line_text(line, self.__FMT, full_timestamps)

   186

   187

class IrssiFormatter (BaseHTMLFormatter, IrssiTextFormatter) :

   188

    """

   189

        Implements plain black-and-white irssi-style formatting

   190

    """

   191

   192

    # name

   193

    name = 'irssi'

   194

    title = "Irssi (plain)"

   195

   196

class DebugFormatter (BaseHTMLFormatter) :

   197

    """

   198

        Implements a raw debug-style formatting of LogLines

   199

    """

   200

   201

    # name

   202

    name = 'debug'

   203

    title = "Raw debugging format"

   204

   205

    def format_txt (self, lines, full_timestamps=False) :

   206

        # iterate

   207

        for line in lines :

   208

            # just dump

   209

            yield line, repr(line)

   210

   211

def by_name (name) :

   212

    """

   213

        Lookup and return a class LogFormatter by name

   214

    """

   215

   216

    return FORMATTERS[name]

   217