golden hour

/lib/python2.7/site-packages/chardet

File/Folder	Size	Actions
__init__.py	1.26 KB
__init__.pyc	797 B
__init__.pyo	797 B
big5freq.py	80.66 KB
big5freq.pyc	111.11 KB
big5freq.pyo	111.11 KB
big5prober.py	1.64 KB
big5prober.pyc	1.07 KB
big5prober.pyo	1.07 KB
chardetect.py	1.09 KB
chardetect.pyc	1.46 KB
chardetect.pyo	1.46 KB
chardistribution.py	9.01 KB
chardistribution.pyc	7.35 KB
chardistribution.pyo	7.35 KB
charsetgroupprober.py	3.7 KB
charsetgroupprober.pyc	2.48 KB
charsetgroupprober.pyo	2.48 KB
charsetprober.py	1.86 KB
charsetprober.pyc	2.08 KB
charsetprober.pyo	2.08 KB
codingstatemachine.py	2.26 KB
codingstatemachine.pyc	1.74 KB
codingstatemachine.pyo	1.74 KB
compat.py	1.13 KB
compat.pyc	559 B
compat.pyo	559 B
constants.py	1.3 KB
constants.pyc	332 B
constants.pyo	332 B
cp949prober.py	1.74 KB
cp949prober.pyc	1.07 KB
cp949prober.pyo	1.07 KB
escprober.py	3.11 KB
escprober.pyc	2.31 KB
escprober.pyo	2.31 KB
escsm.py	7.66 KB
escsm.pyc	7.13 KB
escsm.pyo	7.13 KB
eucjpprober.py	3.59 KB
eucjpprober.pyc	2.71 KB
eucjpprober.pyo	2.71 KB
euckrfreq.py	44.9 KB
euckrfreq.pyc	86.69 KB
euckrfreq.pyo	86.69 KB
euckrprober.py	1.64 KB
euckrprober.pyc	1.08 KB
euckrprober.pyo	1.08 KB
euctwfreq.py	34.05 KB
euctwfreq.pyc	59.74 KB
euctwfreq.pyo	59.74 KB
euctwprober.py	1.64 KB
euctwprober.pyc	1.08 KB
euctwprober.pyo	1.08 KB
gb2312freq.py	35.17 KB
gb2312freq.pyc	67.17 KB
gb2312freq.pyo	67.17 KB
gb2312prober.py	1.64 KB
gb2312prober.pyc	1.08 KB
gb2312prober.pyo	1.08 KB
hebrewprober.py	13.05 KB
hebrewprober.pyc	3.32 KB
hebrewprober.pyo	3.32 KB
jisfreq.py	46.21 KB
jisfreq.pyc	82.03 KB
jisfreq.pyo	82.03 KB
jpcntx.py	18.66 KB
jpcntx.pyc	24.04 KB
jpcntx.pyo	24.04 KB
langbulgarianmodel.py	12.48 KB
langbulgarianmodel.pyc	24.3 KB
langbulgarianmodel.pyo	24.3 KB
langcyrillicmodel.py	17.31 KB
langcyrillicmodel.pyc	29.85 KB
langcyrillicmodel.pyo	29.85 KB
langgreekmodel.py	12.33 KB
langgreekmodel.pyc	24 KB
langgreekmodel.pyo	24 KB
langhebrewmodel.py	11.05 KB
langhebrewmodel.pyc	22.84 KB
langhebrewmodel.pyo	22.84 KB
langhungarianmodel.py	12.24 KB
langhungarianmodel.pyc	24.29 KB
langhungarianmodel.pyo	24.29 KB
langthaimodel.py	11.01 KB
langthaimodel.pyc	22.83 KB
langthaimodel.pyo	22.83 KB
latin1prober.py	5.12 KB
latin1prober.pyc	3.37 KB
latin1prober.pyo	3.37 KB
mbcharsetprober.py	3.19 KB
mbcharsetprober.pyc	2.36 KB
mbcharsetprober.pyo	2.36 KB
mbcsgroupprober.py	1.92 KB
mbcsgroupprober.pyc	1.22 KB
mbcsgroupprober.pyo	1.22 KB
mbcssm.py	19.15 KB
mbcssm.pyc	17.25 KB
mbcssm.pyo	17.25 KB
sbcharsetprober.py	4.68 KB
sbcharsetprober.pyc	3.22 KB
sbcharsetprober.pyo	3.22 KB
sbcsgroupprober.py	3.21 KB
sbcsgroupprober.pyc	1.89 KB
sbcsgroupprober.pyo	1.89 KB
sjisprober.py	3.65 KB
sjisprober.pyc	2.73 KB
sjisprober.pyo	2.73 KB
universaldetector.py	6.67 KB
universaldetector.pyc	4.02 KB
universaldetector.pyo	4.02 KB
utf8prober.py	2.59 KB
utf8prober.pyc	2.14 KB
utf8prober.pyo	2.14 KB

Edit: universaldetector.py

######################## BEGIN LICENSE BLOCK ########################
# The Original Code is Mozilla Universal charset detector code.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 2001
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
#   Mark Pilgrim - port to Python
#   Shy Shalom - original C code
#
# 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 . import constants
import sys
import codecs
from .latin1prober import Latin1Prober  # windows-1252
from .mbcsgroupprober import MBCSGroupProber  # multi-byte character sets
from .sbcsgroupprober import SBCSGroupProber  # single-byte character sets
from .escprober import EscCharSetProber  # ISO-2122, etc.
import re

MINIMUM_THRESHOLD = 0.20
ePureAscii = 0
eEscAscii = 1
eHighbyte = 2

class UniversalDetector:
    def __init__(self):
        self._highBitDetector = re.compile(b'[\x80-\xFF]')
        self._escDetector = re.compile(b'(\033|~{)')
        self._mEscCharSetProber = None
        self._mCharSetProbers = []
        self.reset()

def reset(self):
        self.result = {'encoding': None, 'confidence': 0.0}
        self.done = False
        self._mStart = True
        self._mGotData = False
        self._mInputState = ePureAscii
        self._mLastChar = b''
        if self._mEscCharSetProber:
            self._mEscCharSetProber.reset()
        for prober in self._mCharSetProbers:
            prober.reset()

def feed(self, aBuf):
        if self.done:
            return

aLen = len(aBuf)
        if not aLen:
            return

if not self._mGotData:
            # If the data starts with BOM, we know it is UTF
            if aBuf[:3] == codecs.BOM:
                # EF BB BF  UTF-8 with BOM
                self.result = {'encoding': "UTF-8", 'confidence': 1.0}
            elif aBuf[:4] == codecs.BOM_UTF32_LE:
                # FF FE 00 00  UTF-32, little-endian BOM
                self.result = {'encoding': "UTF-32LE", 'confidence': 1.0}
            elif aBuf[:4] == codecs.BOM_UTF32_BE:
                # 00 00 FE FF  UTF-32, big-endian BOM
                self.result = {'encoding': "UTF-32BE", 'confidence': 1.0}
            elif aBuf[:4] == b'\xFE\xFF\x00\x00':
                # FE FF 00 00  UCS-4, unusual octet order BOM (3412)
                self.result = {
                    'encoding': "X-ISO-10646-UCS-4-3412",
                    'confidence': 1.0
                }
            elif aBuf[:4] == b'\x00\x00\xFF\xFE':
                # 00 00 FF FE  UCS-4, unusual octet order BOM (2143)
                self.result = {
                    'encoding': "X-ISO-10646-UCS-4-2143",
                    'confidence': 1.0
                }
            elif aBuf[:2] == codecs.BOM_LE:
                # FF FE  UTF-16, little endian BOM
                self.result = {'encoding': "UTF-16LE", 'confidence': 1.0}
            elif aBuf[:2] == codecs.BOM_BE:
                # FE FF  UTF-16, big endian BOM
                self.result = {'encoding': "UTF-16BE", 'confidence': 1.0}

self._mGotData = True
        if self.result['encoding'] and (self.result['confidence'] > 0.0):
            self.done = True
            return

if self._mInputState == ePureAscii:
            if self._highBitDetector.search(aBuf):
                self._mInputState = eHighbyte
            elif ((self._mInputState == ePureAscii) and
                    self._escDetector.search(self._mLastChar + aBuf)):
                self._mInputState = eEscAscii

self._mLastChar = aBuf[-1:]

if self._mInputState == eEscAscii:
            if not self._mEscCharSetProber:
                self._mEscCharSetProber = EscCharSetProber()
            if self._mEscCharSetProber.feed(aBuf) == constants.eFoundIt:
                self.result = {'encoding': self._mEscCharSetProber.get_charset_name(),
                               'confidence': self._mEscCharSetProber.get_confidence()}
                self.done = True
        elif self._mInputState == eHighbyte:
            if not self._mCharSetProbers:
                self._mCharSetProbers = [MBCSGroupProber(), SBCSGroupProber(),
                                         Latin1Prober()]
            for prober in self._mCharSetProbers:
                if prober.feed(aBuf) == constants.eFoundIt:
                    self.result = {'encoding': prober.get_charset_name(),
                                   'confidence': prober.get_confidence()}
                    self.done = True
                    break

def close(self):
        if self.done:
            return
        if not self._mGotData:
            if constants._debug:
                sys.stderr.write('no data received!\n')
            return
        self.done = True

if self._mInputState == ePureAscii:
            self.result = {'encoding': 'ascii', 'confidence': 1.0}
            return self.result

if self._mInputState == eHighbyte:
            proberConfidence = None
            maxProberConfidence = 0.0
            maxProber = None
            for prober in self._mCharSetProbers:
                if not prober:
                    continue
                proberConfidence = prober.get_confidence()
                if proberConfidence > maxProberConfidence:
                    maxProberConfidence = proberConfidence
                    maxProber = prober
            if maxProber and (maxProberConfidence > MINIMUM_THRESHOLD):
                self.result = {'encoding': maxProber.get_charset_name(),
                               'confidence': maxProber.get_confidence()}
                return self.result

if constants._debug:
            sys.stderr.write('no probers hit minimum threshhold\n')
            for prober in self._mCharSetProbers[0].mProbers:
                if not prober:
                    continue
                sys.stderr.write('%s confidence = %s\n' %
                                 (prober.get_charset_name(),
                                  prober.get_confidence()))