fpdb/pyfpdb/HandHistoryConverter.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

#Copyright 2008-2010 Carl Gherardi
#This program is free software: you can redistribute it and/or modify
#it under the terms of the GNU Affero General Public License as published by
#the Free Software Foundation, version 3 of the License.
#
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#
#You should have received a copy of the GNU Affero General Public License
#along with this program. If not, see <http://www.gnu.org/licenses/>.
#In the "official" distribution you can find the license in agpl-3.0.txt.

import L10n
_ = L10n.get_translation()

import re
import sys
import traceback
from optparse import OptionParser
import os
import os.path
import xml.dom.minidom
import codecs
from decimal import Decimal
import operator
from xml.dom.minidom import Node

import time
import datetime
from pytz import timezone
import pytz

import logging
# logging has been set up in fpdb.py or HUD_main.py, use their settings:
log = logging.getLogger("parser")


import Hand
from Exceptions import FpdbParseError
import Configuration

import pygtk
import gtk

class HandHistoryConverter():

    READ_CHUNK_SIZE = 10000 # bytes to read at a time from file in tail mode

    # filetype can be "text" or "xml"
    # so far always "text"
    # subclass HHC_xml for xml parsing
    filetype = "text"

    # codepage indicates the encoding of the text file.
    # cp1252 is a safe default
    # "utf_8" is more likely if there are funny characters
    codepage = "cp1252"

    re_tzOffset = re.compile('^\w+[+-]\d{4}$')

    # maybe archive params should be one archive param, then call method in specific converter.   if archive:  convert_archive()
    def __init__( self, config, in_path = '-', out_path = '-', follow=False, index=0
                , autostart=True, starsArchive=False, ftpArchive=False, sitename="PokerStars" ):
        """\
in_path   (default '-' = sys.stdin)
out_path  (default '-' = sys.stdout)
follow :  whether to tail -f the input"""

        self.config = config
        self.import_parameters = self.config.get_import_parameters()
        self.sitename = sitename
        #log = Configuration.get_logger("logging.conf", "parser", log_dir=self.config.dir_log)
        log.info("HandHistory init - %s site, %s subclass, in_path '%s'; out_path '%s'" 
                 % (self.sitename, self.__class__, in_path, out_path) ) # should use self.filter, not self.sitename

        self.index     = index
        self.starsArchive = starsArchive
        self.ftpArchive = ftpArchive

        self.in_path = in_path
        self.out_path = out_path

        self.processedHands = []
        self.numHands = 0
        self.numErrors = 0

        # Tourney object used to store TourneyInfo when called to deal with a Summary file
        self.tourney = None

        if in_path == '-':
            self.in_fh = sys.stdin
        self.out_fh = get_out_fh(out_path, self.import_parameters)

        self.follow = follow
        self.compiledPlayers   = set()
        self.maxseats  = 10

        self.status = True

        self.parsedObjectType = "HH"      #default behaviour : parsing HH files, can be "Summary" if the parsing encounters a Summary File

        if autostart:
            self.start()

    def __str__(self):
        return """
HandHistoryConverter: '%(sitename)s'  
    filetype    '%(filetype)s'
    in_path     '%(in_path)s'
    out_path    '%(out_path)s'
    follow      '%(follow)s'
    """ %  locals()

    def start(self):
        """Process a hand at a time from the input specified by in_path.
If in follow mode, wait for more data to turn up.
Otherwise, finish at EOF.

"""
        while gtk.events_pending():
            gtk.main_iteration(False)

        starttime = time.time()
        if not self.sanityCheck():
            log.warning(_("Failed sanity check"))
            return

        try:
            self.numHands = 0
            self.numErrors = 0
            if self.follow:
                #TODO: See how summary files can be handled on the fly (here they should be rejected as before)
                log.info(_("Tailing '%s'") % self.in_path)
                for handText in self.tailHands():
                    try:
                        self.processHand(handText)
                        self.numHands += 1
                    except FpdbParseError, e:
                        self.numErrors += 1
                        log.warning(_("HHC.start(follow): processHand failed: Exception msg: '%s'") % e)
                        log.debug(handText)
            else:
                handsList = self.allHandsAsList()
                log.debug( _("handsList is ") + str(handsList) )
                log.info("Parsing %d hands" % len(handsList))
                # Determine if we're dealing with a HH file or a Summary file
                # quick fix : empty files make the handsList[0] fail ==> If empty file, go on with HH parsing
                if len(handsList) == 0 or self.isSummary(handsList[0]) == False:
                    self.parsedObjectType = "HH"
                    for handText in handsList:
                        try:
                            self.processedHands.append(self.processHand(handText))
                        except FpdbParseError, e:
                            self.numErrors += 1
                            log.warning(_("HHC.start(): processHand failed: Exception msg: '%s'") % e)
                            log.debug(handText)
                    self.numHands = len(handsList)
                    endtime = time.time()
                    log.info(_("Read %d hands (%d failed) in %.3f seconds") % (self.numHands, self.numErrors, endtime - starttime))
                else:
                        self.parsedObjectType = "Summary"
                        summaryParsingStatus = self.readSummaryInfo(handsList)
                        endtime = time.time()
                        if summaryParsingStatus :
                            log.info(_("Summary file '%s' correctly parsed  (took %.3f seconds)") % (self.in_path, endtime - starttime))
                        else :
                            log.warning(_("Error converting summary file '%s' (took %.3f seconds)") % (self.in_path, endtime - starttime))

        except IOError, ioe:
            log.exception(_("Error converting '%s'") % self.in_path)
        finally:
            if self.out_fh != sys.stdout:
                self.out_fh.close()


    def tailHands(self):
        """Generator of handTexts from a tailed file:
Tail the in_path file and yield handTexts separated by re_SplitHands.
This requires a regex that greedily groups and matches the 'splitter' between hands,
which it expects to find at self.re_TailSplitHands -- see for e.g. Everleaf.py.

"""
        if self.in_path == '-':
            raise StopIteration
        interval = 1.0 # seconds to sleep between reads for new data
        fd = codecs.open(self.in_path,'r', self.codepage)
        data = ''
        while 1:
            where = fd.tell()
            newdata = fd.read(self.READ_CHUNK_SIZE)
            if not newdata:
                fd_results = os.fstat(fd.fileno())
                try:
                    st_results = os.stat(self.in_path)
                except OSError:
                    st_results = fd_results
                if st_results[1] == fd_results[1]:
                    time.sleep(interval)
                    fd.seek(where)
                else:
                    log.debug(_("%s changed inode numbers from %d to %d") % (self.in_path, fd_results[1], st_results[1]))
                    fd = codecs.open(self.in_path, 'r', self.codepage)
                    fd.seek(where)
            else:
                # yield hands
                data = data + newdata
                result = self.re_TailSplitHands.split(data)
                result = iter(result)
                data = ''
                # --x       data (- is bit of splitter, x is paragraph)     yield,...,keep
                # [,--,x]    result of re.split (with group around splitter)
                # ,x        our output: yield nothing, keep x
                #
                # --x--x    [,--,x,--,x]  x,x
                # -x--x     [-x,--,x]     x,x
                # x-        [x-]          ,x-
                # x--       [x,--,]       x,--
                # x--x      [x,--,x]      x,x
                # x--x--    [x,--,x,--,]  x,x,--

                # The length is always odd.
                # 'odd' indices are always splitters.
                # 'even' indices are always paragraphs or ''
                # We want to discard all the ''
                # We want to discard splitters unless the final item is '' (because the splitter could grow with new data)
                # We want to yield all paragraphs followed by a splitter, i.e. all even indices except the last.
                for para in result:
                    try:
                        result.next()
                        splitter = True
                    except StopIteration:
                        splitter = False
                    if splitter: # para is followed by a splitter
                        if para: yield para # para not ''
                    else:
                        data = para # keep final partial paragraph


    def allHandsAsList(self):
        """Return a list of handtexts in the file at self.in_path"""
        #TODO : any need for this to be generator? e.g. stars support can email one huge file of all hands in a year. Better to read bit by bit than all at once.
        self.readFile()
        self.obs = self.obs.strip()
        self.obs = self.obs.replace('\r\n', '\n')
        # maybe archive params should be one archive param, then call method in specific converter?
        # if self.archive:
        #     self.obs = self.convert_archive(self.obs)
        if self.starsArchive == True:
            log.debug(_("Converting starsArchive format to readable"))
            m = re.compile('^Hand #\d+', re.MULTILINE)
            self.obs = m.sub('', self.obs)

        if self.ftpArchive == True:
            log.debug(_("Converting ftpArchive format to readable"))
            # Remove  ******************** # 1 *************************
            m = re.compile('\*{20}\s#\s\d+\s\*{25}\s+', re.MULTILINE)
            self.obs = m.sub('', self.obs)

        if self.obs is None or self.obs == "":
            log.error(_("Read no hands."))
            return []
        handlist = re.split(self.re_SplitHands,  self.obs)
        # Some HH formats leave dangling text after the split
        # ie. </game> (split) </session>EOL
        # Remove this dangler if less than 50 characters and warn in the log
        if len(handlist[-1]) <= 50:
            handlist.pop()
            log.warn(_("Removing text < 50 characters"))
        return handlist

    def processHand(self, handText):
        gametype = self.determineGameType(handText)
        log.debug("gametype %s" % gametype)
        hand = None
        l = None
        if gametype is None:
            gametype = "unmatched"
            # TODO: not ideal, just trying to not error. Throw ParseException?
            self.numErrors += 1
        else:
            # See if gametype is supported.
            type = gametype['type']
            base = gametype['base']
            limit = gametype['limitType']
            l = [type] + [base] + [limit]

        if l in self.readSupportedGames():
            if gametype['base'] == 'hold':
                log.debug("hand = Hand.HoldemOmahaHand(self, self.sitename, gametype, handtext)")
                hand = Hand.HoldemOmahaHand(self.config, self, self.sitename, gametype, handText)
            elif gametype['base'] == 'stud':
                hand = Hand.StudHand(self.config, self, self.sitename, gametype, handText)
            elif gametype['base'] == 'draw':
                hand = Hand.DrawHand(self.config, self, self.sitename, gametype, handText)
        else:
            log.info(_("Unsupported game type: %s" % gametype))
            raise FpdbParseError(_("Unsupported game type: %s" % gametype))

        if hand:
            #hand.writeHand(self.out_fh)
            return hand
        else:
            log.error(_("Unsupported game type: %s" % gametype))
            # TODO: pity we don't know the HID at this stage. Log the entire hand?


    # These functions are parse actions that may be overridden by the inheriting class
    # This function should return a list of lists looking like:
    # return [["ring", "hold", "nl"], ["tour", "hold", "nl"]]
    # Showing all supported games limits and types

    def readSupportedGames(self): abstract

    # should return a list
    #   type  base limit
    # [ ring, hold, nl   , sb, bb ]
    # Valid types specified in docs/tabledesign.html in Gametypes
    def determineGameType(self, handText): abstract
    """return dict with keys/values:
    'type'       in ('ring', 'tour')
    'limitType'  in ('nl', 'cn', 'pl', 'cp', 'fl')
    'base'       in ('hold', 'stud', 'draw')
    'category'   in ('holdem', 'omahahi', omahahilo', 'razz', 'studhi', 'studhilo', 'fivedraw', '27_1draw', '27_3draw', 'badugi')
    'hilo'       in ('h','l','s')
    'smallBlind' int?
    'bigBlind'   int?
    'smallBet'
    'bigBet'
    'currency'  in ('USD', 'EUR', 'T$', <countrycode>)
or None if we fail to get the info """
    #TODO: which parts are optional/required?

    def readHandInfo(self, hand): abstract
    """Read and set information about the hand being dealt, and set the correct 
    variables in the Hand object 'hand

    * hand.startTime - a datetime object
    * hand.handid - The site identified for the hand - a string.
    * hand.tablename
    * hand.buttonpos
    * hand.maxseats
    * hand.mixed

    Tournament fields:

    * hand.tourNo - The site identified tournament id as appropriate - a string.
    * hand.buyin
    * hand.fee
    * hand.buyinCurrency
    * hand.koBounty
    * hand.isKO
    * hand.level
    """
    #TODO: which parts are optional/required?

    def readPlayerStacks(self, hand): abstract
    """This function is for identifying players at the table, and to pass the 
    information on to 'hand' via Hand.addPlayer(seat, name, chips)

    At the time of writing the reference function in the PS converter is:
        log.debug("readPlayerStacks")
        m = self.re_PlayerInfo.finditer(hand.handText)
        for a in m:
            hand.addPlayer(int(a.group('SEAT')), a.group('PNAME'), a.group('CASH'))

    Which is pretty simple because the hand history format is consistent. Other hh formats aren't so nice.

    This is the appropriate place to identify players that are sitting out and ignore them

    *** NOTE: You may find this is a more appropriate place to set hand.maxseats ***
    """

    def compilePlayerRegexs(self): abstract
    """Compile dynamic regexes -- compile player dependent regexes.

    Depending on the ambiguity of lines you may need to match, and the complexity of 
    player names - we found that we needed to recompile some regexes for player actions so that they actually contained the player names.

    eg.
    We need to match the ante line:
    <Player> antes $1.00

    But <Player> is actually named

    YesI antes $4000 - A perfectly legal playername

    Giving:

    YesI antes $4000 antes $1.00

    Which without care in your regexes most people would match 'YesI' and not 'YesI antes $4000'
    """

    # Needs to return a MatchObject with group names identifying the streets into the Hand object
    # so groups are called by street names 'PREFLOP', 'FLOP', 'STREET2' etc
    # blinds are done seperately
    def markStreets(self, hand): abstract
    """For dividing the handText into sections.

    The function requires you to pass a MatchObject with groups specifically labeled with
    the 'correct' street names.

    The Hand object will use the various matches for assigning actions to the correct streets.

    Flop Based Games:
    PREFLOP, FLOP, TURN, RIVER

    Draw Based Games:
    PREDEAL, DEAL, DRAWONE, DRAWTWO, DRAWTHREE

    Stud Based Games:
    ANTES, THIRD, FOURTH, FIFTH, SIXTH, SEVENTH

    The Stars HHC has a good reference implementation
    """

    #Needs to return a list in the format
    # ['player1name', 'player2name', ...] where player1name is the sb and player2name is bb,
    # addtional players are assumed to post a bb oop
    def readBlinds(self, hand): abstract
    """Function for reading the various blinds from the hand history.

    Pass any small blind to hand.addBlind(<name>, "small blind", <value>)
    - unless it is a single dead small blind then use:
        hand.addBlind(<name>, 'secondsb', <value>)
    Pass any big blind to hand.addBlind(<name>, "big blind", <value>)
    Pass any play posting both big and small blinds to hand.addBlind(<name>, 'both', <vale>)
    """
    def readAntes(self, hand): abstract
    """Function for reading the antes from the hand history and passing the hand.addAnte"""
    def readBringIn(self, hand): abstract
    def readButton(self, hand): abstract
    def readHeroCards(self, hand): abstract
    def readPlayerCards(self, hand, street): abstract
    def readAction(self, hand, street): abstract
    def readCollectPot(self, hand): abstract
    def readShownCards(self, hand): abstract

    # Some sites do odd stuff that doesn't fall in to the normal HH parsing.
    # e.g., FTP doesn't put mixed game info in the HH, but puts in in the
    # file name. Use readOther() to clean up those messes.
    def readOther(self, hand): pass

    # Some sites don't report the rake. This will be called at the end of the hand after the pot total has been calculated
    # an inheriting class can calculate it for the specific site if need be.
    def getRake(self, hand):
        hand.rake = hand.totalpot - hand.totalcollected #  * Decimal('0.05') # probably not quite right


    def sanityCheck(self):
        """Check we aren't going to do some stupid things"""
        #TODO: the hhbase stuff needs to be in fpdb_import
        sane = False
        base_w = False
        #~ #Check if hhbase exists and is writable
        #~ #Note: Will not try to create the base HH directory
        #~ if not (os.access(self.hhbase, os.W_OK) and os.path.isdir(self.hhbase)):
            #~ print "HH Sanity Check: Directory hhbase '" + self.hhbase + "' doesn't exist or is not writable"
        #~ else:
            #~ #Check if hhdir exists and is writable
            #~ if not os.path.isdir(self.hhdir):
                #~ # In first pass, dir may not exist. Attempt to create dir
                #~ print "Creating directory: '%s'" % (self.hhdir)
                #~ os.mkdir(self.hhdir)
                #~ sane = True
            #~ elif os.access(self.hhdir, os.W_OK):
                #~ sane = True
            #~ else:
                #~ print "HH Sanity Check: Directory hhdir '" + self.hhdir + "' or its parent directory are not writable"

        # Make sure input and output files are different or we'll overwrite the source file
        if True: # basically.. I don't know
            sane = True

        if self.in_path != '-' and self.out_path == self.in_path:
            print _("HH Sanity Check: output and input files are the same, check config")
            sane = False


        return sane

    # Functions not necessary to implement in sub class
    def setFileType(self, filetype = "text", codepage='utf8'):
        self.filetype = filetype
        self.codepage = codepage

    def __listof(self, x):
        if isinstance(x, list) or isinstance(x, tuple):
            return x
        else:
            return [x]

    def readFile(self):
        """Open in_path according to self.codepage. Exceptions caught further up"""

        if self.filetype == "text":
            if self.in_path == '-':
                # read from stdin
                log.debug(_("Reading stdin with %s") % self.codepage) # is this necessary? or possible? or what?
                in_fh = codecs.getreader('cp1252')(sys.stdin)
            else:
                for kodec in self.__listof(self.codepage):
                    #print "trying", kodec
                    try:
                        in_fh = codecs.open(self.in_path, 'r', kodec)
                        whole_file = in_fh.read()
                        in_fh.close()
                        self.obs = whole_file[self.index:]
                        self.index = len(whole_file)
                        break
                    except:
                        pass
                else:
                    print _("unable to read file with any codec in list!"), self.in_path
                    self.obs = ""
        elif self.filetype == "xml":
            doc = xml.dom.minidom.parse(filename)
            self.doc = doc

    def guessMaxSeats(self, hand):
        """Return a guess at maxseats when not specified in HH."""
        # if some other code prior to this has already set it, return it
        if self.maxseats > 1 and self.maxseats < 11:
            return self.maxseats
        mo = self.maxOccSeat(hand)

        if mo == 10: return 10 #that was easy

        if hand.gametype['base'] == 'stud':
            if mo <= 8: return 8
            else: return mo

        if hand.gametype['base'] == 'draw':
            if mo <= 6: return 6
            else: return mo

        if mo == 2: return 2
        if mo <= 6: return 6
        return 10

    def maxOccSeat(self, hand):
        max = 0
        for player in hand.players:
            if player[0] > max:
                max = player[0]
        return max

    def getStatus(self):
        #TODO: Return a status of true if file processed ok
        return self.status

    def getProcessedHands(self):
        return self.processedHands

    def getProcessedFile(self):
        return self.out_path

    def getLastCharacterRead(self):
        return self.index

    def isSummary(self, topline):
        return " Tournament Summary " in topline

    def getParsedObjectType(self):
        return self.parsedObjectType

    #returns a status (True/False) indicating wether the parsing could be done correctly or not
    def readSummaryInfo(self, summaryInfoList): abstract

    def getTourney(self):
        return self.tourney
        
    @staticmethod
    def changeTimezone(time, givenTimezone, wantedTimezone):
        """Takes a givenTimezone in format AAA or AAA+HHMM where AAA is a standard timezone
           and +HHMM is an optional offset (+/-) in hours (HH) and minutes (MM)
           (See OnGameToFpdb.py for example use of the +HHMM part)
           Tries to convert the time parameter (with no timezone) from the givenTimezone to 
           the wantedTimeZone (currently only allows "UTC")
        """
        log.debug( _("raw time:")+str(time) + _(" given TZ:")+str(givenTimezone) )
        if wantedTimezone=="UTC":
            wantedTimezone = pytz.utc
        else:
            raise Error #TODO raise appropriate error

        givenTZ = None
        if HandHistoryConverter.re_tzOffset.match(givenTimezone):
            offset = int(givenTimezone[-5:])
            givenTimezone = givenTimezone[0:-5]
            log.debug( _("changeTimeZone: offset=") + str(offset) )
        else: offset=0

        if givenTimezone=="ET":
            givenTZ = timezone('US/Eastern')
        elif givenTimezone=="CET":
            givenTZ = timezone('Europe/Berlin')
            #Note: Daylight Saving Time is standardised across the EU so this should be fine
        elif givenTimezone == 'GMT': # Greenwich Mean Time (same as UTC - no change to time)
            givenTZ = timezone('GMT')
        elif givenTimezone == 'HST': # Hawaiian Standard Time
            pass
        elif givenTimezone == 'AKT': # Alaska Time
            pass
        elif givenTimezone == 'PT': # Pacific Time
            pass
        elif givenTimezone == 'MT': # Mountain Time
            pass
        elif givenTimezone == 'CT': # Central Time
            pass
        elif givenTimezone == 'AT': # Atlantic Time
            pass
        elif givenTimezone == 'NT': # Newfoundland Time
            pass
        elif givenTimezone == 'ART': # Argentinian Time
            pass
        elif givenTimezone == 'BRT': # Brasilia Time
            pass
        elif givenTimezone == 'AKT': # Alaska Time
            pass
        elif givenTimezone == 'WET': # Western European Time
            pass
        elif givenTimezone == 'EET': # Eastern European Time
            pass
        elif givenTimezone == 'MSK': # Moscow Standard Time
            pass
        elif givenTimezone == 'IST': # India Standard Time
            pass
        elif givenTimezone == 'CCT': # China Coast Time
            pass
        elif givenTimezone == 'JST': # Japan Standard Time
            pass
        elif givenTimezone == 'AWST': # Australian Western Standard Time
            givenTZ = timezone('Australia/West')
        elif givenTimezone == 'ACST': # Australian Central Standard Time
            givenTZ = timezone('Australia/Darwin')
        elif givenTimezone == 'AEST': # Australian Eastern Standard Time
            # Each State on the East Coast has different DSTs.
            # Melbournce is out because I don't like AFL, Queensland doesn't have DST
            # ACT is full of politicians and Tasmania will never notice.
            # Using Sydney. 
            givenTZ = timezone('Australia/Sydney')
        elif givenTimezone == 'NZT': # New Zealand Time
            pass
        else:
            raise Error #TODO raise appropriate error
        
        if givenTZ is None:
            raise Error #TODO raise appropriate error
                        # (or just return time unchanged?)

        localisedTime = givenTZ.localize(time)
        utcTime = localisedTime.astimezone(wantedTimezone) + datetime.timedelta(seconds=-3600*(offset/100)-60*(offset%100))
        log.debug( _("utcTime:")+str(utcTime) )
        return utcTime
    #end @staticmethod def changeTimezone

    @staticmethod
    def getTableTitleRe(type, table_name=None, tournament = None, table_number=None):
        "Returns string to search in windows titles"
        if type=="tour":
            return "%s.+Table.+%s" % (tournament, table_number)
        else:
            return table_name

    @staticmethod
    def getTableNoRe(tournament):
        "Returns string to search window title for tournament table no."
# Full Tilt:  $30 + $3 Tournament (181398949), Table 1 - 600/1200 Ante 100 - Limit Razz
# PokerStars: WCOOP 2nd Chance 02: $1,050 NLHE - Tournament 307521826 Table 1 - Blinds $30/$60
        return "%s.+Table (\d+)" % (tournament, )

def getTableTitleRe(config, sitename, *args, **kwargs):
    "Returns string to search in windows titles for current site"
    return getSiteHhc(config, sitename).getTableTitleRe(*args, **kwargs)

def getTableNoRe(config, sitename, *args, **kwargs):
    "Returns string to search window titles for tournament table no."
    return getSiteHhc(config, sitename).getTableNoRe(*args, **kwargs)



def getSiteHhc(config, sitename):
    "Returns HHC class for current site"
    hhcName = config.supported_sites[sitename].converter
    hhcModule = __import__(hhcName)
    return getattr(hhcModule, hhcName[:-6])

def get_out_fh(out_path, parameters):
    if out_path == '-':
        return(sys.stdout)
    elif parameters['saveStarsHH']:
        out_dir = os.path.dirname(out_path) 
        if not os.path.isdir(out_dir) and out_dir != '': 
            try: 
                os.makedirs(out_dir) 
            except: # we get a WindowsError here in Windows.. pretty sure something else for Linux :D 
                log.error(_("Unable to create output directory %s for HHC!") % out_dir) 
                print _("*** ERROR: UNABLE TO CREATE OUTPUT DIRECTORY"), out_dir 
            else: 
                log.info(_("Created directory '%s'") % out_dir) 
        try: 
            return(codecs.open(out_path, 'w', 'utf8')) 
        except: 
            log.error(_("out_path %s couldn't be opened") % (out_path)) 
    else:
        return(sys.stdout)