Application: gvSIG desktop » gvSIG scripting

######################## BEGIN LICENSE BLOCK ########################

# The Original Code is Mozilla Universal charset detector code.

#

# The Initial Developer of the Original Code is

#          Shy Shalom

# Portions created by the Initial Developer are Copyright (C) 2005

# the Initial Developer. All Rights Reserved.

#

# Contributor(s):

#   Mark Pilgrim - port to Python

#

# This library is free software; you can redistribute it and/or

# modify it under the terms of the GNU Lesser General Public

# License as published by the Free Software Foundation; either

# version 2.1 of the License, or (at your option) any later version.

#

# This library 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

# Lesser General Public License for more details.

#

# You should have received a copy of the GNU Lesser General Public

# License along with this library; if not, write to the Free Software

# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

# 02110-1301  USA

######################### END LICENSE BLOCK #########################

from .charsetprober import CharSetProber

from .constants import eNotMe, eDetecting

from .compat import wrap_ord

# This prober doesn't actually recognize a language or a charset.

# It is a helper prober for the use of the Hebrew model probers

### General ideas of the Hebrew charset recognition ###

#

# Four main charsets exist in Hebrew:

# "ISO-8859-8" - Visual Hebrew

# "windows-1255" - Logical Hebrew

# "ISO-8859-8-I" - Logical Hebrew

# "x-mac-hebrew" - ?? Logical Hebrew ??

#

# Both "ISO" charsets use a completely identical set of code points, whereas

# "windows-1255" and "x-mac-hebrew" are two different proper supersets of

# these code points. windows-1255 defines additional characters in the range

# 0x80-0x9F as some misc punctuation marks as well as some Hebrew-specific

# diacritics and additional 'Yiddish' ligature letters in the range 0xc0-0xd6.

# x-mac-hebrew defines similar additional code points but with a different

# mapping.

#

# As far as an average Hebrew text with no diacritics is concerned, all four

# charsets are identical with respect to code points. Meaning that for the

# main Hebrew alphabet, all four map the same values to all 27 Hebrew letters

# (including final letters).

#

# The dominant difference between these charsets is their directionality.

# "Visual" directionality means that the text is ordered as if the renderer is

# not aware of a BIDI rendering algorithm. The renderer sees the text and

# draws it from left to right. The text itself when ordered naturally is read

# backwards. A buffer of Visual Hebrew generally looks like so:

# "[last word of first line spelled backwards] [whole line ordered backwards

# and spelled backwards] [first word of first line spelled backwards]

# [end of line] [last word of second line] ... etc' "

# adding punctuation marks, numbers and English text to visual text is

# naturally also "visual" and from left to right.

#

# "Logical" directionality means the text is ordered "naturally" according to

# the order it is read. It is the responsibility of the renderer to display

# the text from right to left. A BIDI algorithm is used to place general

# punctuation marks, numbers and English text in the text.

#

# Texts in x-mac-hebrew are almost impossible to find on the Internet. From

# what little evidence I could find, it seems that its general directionality

# is Logical.

#

# To sum up all of the above, the Hebrew probing mechanism knows about two

# charsets:

# Visual Hebrew - "ISO-8859-8" - backwards text - Words and sentences are

#    backwards while line order is natural. For charset recognition purposes

#    the line order is unimportant (In fact, for this implementation, even

#    word order is unimportant).

# Logical Hebrew - "windows-1255" - normal, naturally ordered text.

#

# "ISO-8859-8-I" is a subset of windows-1255 and doesn't need to be

#    specifically identified.

# "x-mac-hebrew" is also identified as windows-1255. A text in x-mac-hebrew

#    that contain special punctuation marks or diacritics is displayed with

#    some unconverted characters showing as question marks. This problem might

#    be corrected using another model prober for x-mac-hebrew. Due to the fact

#    that x-mac-hebrew texts are so rare, writing another model prober isn't

#    worth the effort and performance hit.

#

#### The Prober ####

#

# The prober is divided between two SBCharSetProbers and a HebrewProber,

# all of which are managed, created, fed data, inquired and deleted by the

# SBCSGroupProber. The two SBCharSetProbers identify that the text is in

# fact some kind of Hebrew, Logical or Visual. The final decision about which

# one is it is made by the HebrewProber by combining final-letter scores

# with the scores of the two SBCharSetProbers to produce a final answer.

#

# The SBCSGroupProber is responsible for stripping the original text of HTML

# tags, English characters, numbers, low-ASCII punctuation characters, spaces

# and new lines. It reduces any sequence of such characters to a single space.

# The buffer fed to each prober in the SBCS group prober is pure text in

# high-ASCII.

# The two SBCharSetProbers (model probers) share the same language model:

# Win1255Model.

# The first SBCharSetProber uses the model normally as any other

# SBCharSetProber does, to recognize windows-1255, upon which this model was

# built. The second SBCharSetProber is told to make the pair-of-letter

# lookup in the language model backwards. This in practice exactly simulates

# a visual Hebrew model using the windows-1255 logical Hebrew model.

#

# The HebrewProber is not using any language model. All it does is look for

# final-letter evidence suggesting the text is either logical Hebrew or visual

# Hebrew. Disjointed from the model probers, the results of the HebrewProber

# alone are meaningless. HebrewProber always returns 0.00 as confidence

# since it never identifies a charset by itself. Instead, the pointer to the

# HebrewProber is passed to the model probers as a helper "Name Prober".

# When the Group prober receives a positive identification from any prober,

# it asks for the name of the charset identified. If the prober queried is a

# Hebrew model prober, the model prober forwards the call to the

# HebrewProber to make the final decision. In the HebrewProber, the

# decision is made according to the final-letters scores maintained and Both

# model probers scores. The answer is returned in the form of the name of the

# charset identified, either "windows-1255" or "ISO-8859-8".

# windows-1255 / ISO-8859-8 code points of interest

FINAL_KAF = 0xea

NORMAL_KAF = 0xeb

FINAL_MEM = 0xed

NORMAL_MEM = 0xee

FINAL_NUN = 0xef

NORMAL_NUN = 0xf0

FINAL_PE = 0xf3

NORMAL_PE = 0xf4

FINAL_TSADI = 0xf5

NORMAL_TSADI = 0xf6

# Minimum Visual vs Logical final letter score difference.

# If the difference is below this, don't rely solely on the final letter score

# distance.

MIN_FINAL_CHAR_DISTANCE = 5

# Minimum Visual vs Logical model score difference.

# If the difference is below this, don't rely at all on the model score

# distance.

MIN_MODEL_DISTANCE = 0.01

VISUAL_HEBREW_NAME = "ISO-8859-8"

LOGICAL_HEBREW_NAME = "windows-1255"

class HebrewProber(CharSetProber):

    def __init__(self):

        CharSetProber.__init__(self)

        self._mLogicalProber = None

        self._mVisualProber = None

        self.reset()

    def reset(self):

        self._mFinalCharLogicalScore = 0

        self._mFinalCharVisualScore = 0

        # The two last characters seen in the previous buffer,

        # mPrev and mBeforePrev are initialized to space in order to simulate

        # a word delimiter at the beginning of the data

        self._mPrev = ' '

        self._mBeforePrev = ' '

        # These probers are owned by the group prober.

    def set_model_probers(self, logicalProber, visualProber):

        self._mLogicalProber = logicalProber

        self._mVisualProber = visualProber

    def is_final(self, c):

        return wrap_ord(c) in [FINAL_KAF, FINAL_MEM, FINAL_NUN, FINAL_PE,

                               FINAL_TSADI]

    def is_non_final(self, c):

        # The normal Tsadi is not a good Non-Final letter due to words like

        # 'lechotet' (to chat) containing an apostrophe after the tsadi. This

        # apostrophe is converted to a space in FilterWithoutEnglishLetters

        # causing the Non-Final tsadi to appear at an end of a word even

        # though this is not the case in the original text.

        # The letters Pe and Kaf rarely display a related behavior of not being

        # a good Non-Final letter. Words like 'Pop', 'Winamp' and 'Mubarak'

        # for example legally end with a Non-Final Pe or Kaf. However, the

        # benefit of these letters as Non-Final letters outweighs the damage

        # since these words are quite rare.

        return wrap_ord(c) in [NORMAL_KAF, NORMAL_MEM, NORMAL_NUN, NORMAL_PE]

    def feed(self, aBuf):

        # Final letter analysis for logical-visual decision.

        # Look for evidence that the received buffer is either logical Hebrew

        # or visual Hebrew.

        # The following cases are checked:

        # 1) A word longer than 1 letter, ending with a final letter. This is

        #    an indication that the text is laid out "naturally" since the

        #    final letter really appears at the end. +1 for logical score.

        # 2) A word longer than 1 letter, ending with a Non-Final letter. In

        #    normal Hebrew, words ending with Kaf, Mem, Nun, Pe or Tsadi,

        #    should not end with the Non-Final form of that letter. Exceptions

        #    to this rule are mentioned above in isNonFinal(). This is an

        #    indication that the text is laid out backwards. +1 for visual

        #    score

        # 3) A word longer than 1 letter, starting with a final letter. Final

        #    letters should not appear at the beginning of a word. This is an

        #    indication that the text is laid out backwards. +1 for visual

        #    score.

        #

        # The visual score and logical score are accumulated throughout the

        # text and are finally checked against each other in GetCharSetName().

        # No checking for final letters in the middle of words is done since

        # that case is not an indication for either Logical or Visual text.

        #

        # We automatically filter out all 7-bit characters (replace them with

        # spaces) so the word boundary detection works properly. [MAP]

        if self.get_state() == eNotMe:

            # Both model probers say it's not them. No reason to continue.

            return eNotMe

        aBuf = self.filter_high_bit_only(aBuf)

        for cur in aBuf:

            if cur == ' ':

                # We stand on a space - a word just ended

                if self._mBeforePrev != ' ':

                    # next-to-last char was not a space so self._mPrev is not a

                    # 1 letter word

                    if self.is_final(self._mPrev):

                        # case (1) [-2:not space][-1:final letter][cur:space]

                        self._mFinalCharLogicalScore += 1

                    elif self.is_non_final(self._mPrev):

                        # case (2) [-2:not space][-1:Non-Final letter][

                        #  cur:space]

                        self._mFinalCharVisualScore += 1

            else:

                # Not standing on a space

                if ((self._mBeforePrev == ' ') and

                        (self.is_final(self._mPrev)) and (cur != ' ')):

                    # case (3) [-2:space][-1:final letter][cur:not space]

                    self._mFinalCharVisualScore += 1

            self._mBeforePrev = self._mPrev

            self._mPrev = cur

        # Forever detecting, till the end or until both model probers return

        # eNotMe (handled above)

        return eDetecting

    def get_charset_name(self):

        # Make the decision: is it Logical or Visual?

        # If the final letter score distance is dominant enough, rely on it.

        finalsub = self._mFinalCharLogicalScore - self._mFinalCharVisualScore

        if finalsub >= MIN_FINAL_CHAR_DISTANCE:

            return LOGICAL_HEBREW_NAME

        if finalsub <= -MIN_FINAL_CHAR_DISTANCE:

            return VISUAL_HEBREW_NAME

        # It's not dominant enough, try to rely on the model scores instead.

        modelsub = (self._mLogicalProber.get_confidence()

                    - self._mVisualProber.get_confidence())

        if modelsub > MIN_MODEL_DISTANCE:

            return LOGICAL_HEBREW_NAME

        if modelsub < -MIN_MODEL_DISTANCE:

            return VISUAL_HEBREW_NAME

        # Still no good, back to final letter distance, maybe it'll save the

        # day.

        if finalsub < 0.0:

            return VISUAL_HEBREW_NAME

        # (finalsub > 0 - Logical) or (don't know what to do) default to

        # Logical.

        return LOGICAL_HEBREW_NAME

    def get_state(self):

        # Remain active as long as any of the model probers are active.

        if (self._mLogicalProber.get_state() == eNotMe) and \

           (self._mVisualProber.get_state() == eNotMe):

            return eNotMe

        return eDetecting