claude-all-hands 1.0.0 → 1.0.1

package/.claude/envoy/.venv/lib/python3.9/site-packages/pip/_vendor/chardet/chardistribution.py

@@ -1,233 +0,0 @@
-######################## BEGIN LICENSE BLOCK ########################
-# The Original Code is Mozilla Communicator client code.
-#
-# The Initial Developer of the Original Code is
-# Netscape Communications Corporation.
-# Portions created by the Initial Developer are Copyright (C) 1998
-# 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 .euctwfreq import (EUCTW_CHAR_TO_FREQ_ORDER, EUCTW_TABLE_SIZE,
-                        EUCTW_TYPICAL_DISTRIBUTION_RATIO)
-from .euckrfreq import (EUCKR_CHAR_TO_FREQ_ORDER, EUCKR_TABLE_SIZE,
-                        EUCKR_TYPICAL_DISTRIBUTION_RATIO)
-from .gb2312freq import (GB2312_CHAR_TO_FREQ_ORDER, GB2312_TABLE_SIZE,
-                         GB2312_TYPICAL_DISTRIBUTION_RATIO)
-from .big5freq import (BIG5_CHAR_TO_FREQ_ORDER, BIG5_TABLE_SIZE,
-                       BIG5_TYPICAL_DISTRIBUTION_RATIO)
-from .jisfreq import (JIS_CHAR_TO_FREQ_ORDER, JIS_TABLE_SIZE,
-                      JIS_TYPICAL_DISTRIBUTION_RATIO)
-
-
-class CharDistributionAnalysis(object):
-    ENOUGH_DATA_THRESHOLD = 1024
-    SURE_YES = 0.99
-    SURE_NO = 0.01
-    MINIMUM_DATA_THRESHOLD = 3
-
-    def __init__(self):
-        # Mapping table to get frequency order from char order (get from
-        # GetOrder())
-        self._char_to_freq_order = None
-        self._table_size = None  # Size of above table
-        # This is a constant value which varies from language to language,
-        # used in calculating confidence.  See
-        # http://www.mozilla.org/projects/intl/UniversalCharsetDetection.html
-        # for further detail.
-        self.typical_distribution_ratio = None
-        self._done = None
-        self._total_chars = None
-        self._freq_chars = None
-        self.reset()
-
-    def reset(self):
-        """reset analyser, clear any state"""
-        # If this flag is set to True, detection is done and conclusion has
-        # been made
-        self._done = False
-        self._total_chars = 0  # Total characters encountered
-        # The number of characters whose frequency order is less than 512
-        self._freq_chars = 0
-
-    def feed(self, char, char_len):
-        """feed a character with known length"""
-        if char_len == 2:
-            # we only care about 2-bytes character in our distribution analysis
-            order = self.get_order(char)
-        else:
-            order = -1
-        if order >= 0:
-            self._total_chars += 1
-            # order is valid
-            if order < self._table_size:
-                if 512 > self._char_to_freq_order[order]:
-                    self._freq_chars += 1
-
-    def get_confidence(self):
-        """return confidence based on existing data"""
-        # if we didn't receive any character in our consideration range,
-        # return negative answer
-        if self._total_chars <= 0 or self._freq_chars <= self.MINIMUM_DATA_THRESHOLD:
-            return self.SURE_NO
-
-        if self._total_chars != self._freq_chars:
-            r = (self._freq_chars / ((self._total_chars - self._freq_chars)
-                 * self.typical_distribution_ratio))
-            if r < self.SURE_YES:
-                return r
-
-        # normalize confidence (we don't want to be 100% sure)
-        return self.SURE_YES
-
-    def got_enough_data(self):
-        # It is not necessary to receive all data to draw conclusion.
-        # For charset detection, certain amount of data is enough
-        return self._total_chars > self.ENOUGH_DATA_THRESHOLD
-
-    def get_order(self, byte_str):
-        # We do not handle characters based on the original encoding string,
-        # but convert this encoding string to a number, here called order.
-        # This allows multiple encodings of a language to share one frequency
-        # table.
-        return -1
-
-
-class EUCTWDistributionAnalysis(CharDistributionAnalysis):
-    def __init__(self):
-        super(EUCTWDistributionAnalysis, self).__init__()
-        self._char_to_freq_order = EUCTW_CHAR_TO_FREQ_ORDER
-        self._table_size = EUCTW_TABLE_SIZE
-        self.typical_distribution_ratio = EUCTW_TYPICAL_DISTRIBUTION_RATIO
-
-    def get_order(self, byte_str):
-        # for euc-TW encoding, we are interested
-        #   first  byte range: 0xc4 -- 0xfe
-        #   second byte range: 0xa1 -- 0xfe
-        # no validation needed here. State machine has done that
-        first_char = byte_str[0]
-        if first_char >= 0xC4:
-            return 94 * (first_char - 0xC4) + byte_str[1] - 0xA1
-        else:
-            return -1
-
-
-class EUCKRDistributionAnalysis(CharDistributionAnalysis):
-    def __init__(self):
-        super(EUCKRDistributionAnalysis, self).__init__()
-        self._char_to_freq_order = EUCKR_CHAR_TO_FREQ_ORDER
-        self._table_size = EUCKR_TABLE_SIZE
-        self.typical_distribution_ratio = EUCKR_TYPICAL_DISTRIBUTION_RATIO
-
-    def get_order(self, byte_str):
-        # for euc-KR encoding, we are interested
-        #   first  byte range: 0xb0 -- 0xfe
-        #   second byte range: 0xa1 -- 0xfe
-        # no validation needed here. State machine has done that
-        first_char = byte_str[0]
-        if first_char >= 0xB0:
-            return 94 * (first_char - 0xB0) + byte_str[1] - 0xA1
-        else:
-            return -1
-
-
-class GB2312DistributionAnalysis(CharDistributionAnalysis):
-    def __init__(self):
-        super(GB2312DistributionAnalysis, self).__init__()
-        self._char_to_freq_order = GB2312_CHAR_TO_FREQ_ORDER
-        self._table_size = GB2312_TABLE_SIZE
-        self.typical_distribution_ratio = GB2312_TYPICAL_DISTRIBUTION_RATIO
-
-    def get_order(self, byte_str):
-        # for GB2312 encoding, we are interested
-        #  first  byte range: 0xb0 -- 0xfe
-        #  second byte range: 0xa1 -- 0xfe
-        # no validation needed here. State machine has done that
-        first_char, second_char = byte_str[0], byte_str[1]
-        if (first_char >= 0xB0) and (second_char >= 0xA1):
-            return 94 * (first_char - 0xB0) + second_char - 0xA1
-        else:
-            return -1
-
-
-class Big5DistributionAnalysis(CharDistributionAnalysis):
-    def __init__(self):
-        super(Big5DistributionAnalysis, self).__init__()
-        self._char_to_freq_order = BIG5_CHAR_TO_FREQ_ORDER
-        self._table_size = BIG5_TABLE_SIZE
-        self.typical_distribution_ratio = BIG5_TYPICAL_DISTRIBUTION_RATIO
-
-    def get_order(self, byte_str):
-        # for big5 encoding, we are interested
-        #   first  byte range: 0xa4 -- 0xfe
-        #   second byte range: 0x40 -- 0x7e , 0xa1 -- 0xfe
-        # no validation needed here. State machine has done that
-        first_char, second_char = byte_str[0], byte_str[1]
-        if first_char >= 0xA4:
-            if second_char >= 0xA1:
-                return 157 * (first_char - 0xA4) + second_char - 0xA1 + 63
-            else:
-                return 157 * (first_char - 0xA4) + second_char - 0x40
-        else:
-            return -1
-
-
-class SJISDistributionAnalysis(CharDistributionAnalysis):
-    def __init__(self):
-        super(SJISDistributionAnalysis, self).__init__()
-        self._char_to_freq_order = JIS_CHAR_TO_FREQ_ORDER
-        self._table_size = JIS_TABLE_SIZE
-        self.typical_distribution_ratio = JIS_TYPICAL_DISTRIBUTION_RATIO
-
-    def get_order(self, byte_str):
-        # for sjis encoding, we are interested
-        #   first  byte range: 0x81 -- 0x9f , 0xe0 -- 0xfe
-        #   second byte range: 0x40 -- 0x7e,  0x81 -- oxfe
-        # no validation needed here. State machine has done that
-        first_char, second_char = byte_str[0], byte_str[1]
-        if (first_char >= 0x81) and (first_char <= 0x9F):
-            order = 188 * (first_char - 0x81)
-        elif (first_char >= 0xE0) and (first_char <= 0xEF):
-            order = 188 * (first_char - 0xE0 + 31)
-        else:
-            return -1
-        order = order + second_char - 0x40
-        if second_char > 0x7F:
-            order = -1
-        return order
-
-
-class EUCJPDistributionAnalysis(CharDistributionAnalysis):
-    def __init__(self):
-        super(EUCJPDistributionAnalysis, self).__init__()
-        self._char_to_freq_order = JIS_CHAR_TO_FREQ_ORDER
-        self._table_size = JIS_TABLE_SIZE
-        self.typical_distribution_ratio = JIS_TYPICAL_DISTRIBUTION_RATIO
-
-    def get_order(self, byte_str):
-        # for euc-JP encoding, we are interested
-        #   first  byte range: 0xa0 -- 0xfe
-        #   second byte range: 0xa1 -- 0xfe
-        # no validation needed here. State machine has done that
-        char = byte_str[0]
-        if char >= 0xA0:
-            return 94 * (char - 0xA1) + byte_str[1] - 0xa1
-        else:
-            return -1

package/.claude/envoy/.venv/lib/python3.9/site-packages/pip/_vendor/chardet/charsetgroupprober.py

@@ -1,107 +0,0 @@
-######################## BEGIN LICENSE BLOCK ########################
-# The Original Code is Mozilla Communicator client code.
-#
-# The Initial Developer of the Original Code is
-# Netscape Communications Corporation.
-# Portions created by the Initial Developer are Copyright (C) 1998
-# 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 .enums import ProbingState
-from .charsetprober import CharSetProber
-
-
-class CharSetGroupProber(CharSetProber):
-    def __init__(self, lang_filter=None):
-        super(CharSetGroupProber, self).__init__(lang_filter=lang_filter)
-        self._active_num = 0
-        self.probers = []
-        self._best_guess_prober = None
-
-    def reset(self):
-        super(CharSetGroupProber, self).reset()
-        self._active_num = 0
-        for prober in self.probers:
-            if prober:
-                prober.reset()
-                prober.active = True
-                self._active_num += 1
-        self._best_guess_prober = None
-
-    @property
-    def charset_name(self):
-        if not self._best_guess_prober:
-            self.get_confidence()
-            if not self._best_guess_prober:
-                return None
-        return self._best_guess_prober.charset_name
-
-    @property
-    def language(self):
-        if not self._best_guess_prober:
-            self.get_confidence()
-            if not self._best_guess_prober:
-                return None
-        return self._best_guess_prober.language
-
-    def feed(self, byte_str):
-        for prober in self.probers:
-            if not prober:
-                continue
-            if not prober.active:
-                continue
-            state = prober.feed(byte_str)
-            if not state:
-                continue
-            if state == ProbingState.FOUND_IT:
-                self._best_guess_prober = prober
-                self._state = ProbingState.FOUND_IT
-                return self.state
-            elif state == ProbingState.NOT_ME:
-                prober.active = False
-                self._active_num -= 1
-                if self._active_num <= 0:
-                    self._state = ProbingState.NOT_ME
-                    return self.state
-        return self.state
-
-    def get_confidence(self):
-        state = self.state
-        if state == ProbingState.FOUND_IT:
-            return 0.99
-        elif state == ProbingState.NOT_ME:
-            return 0.01
-        best_conf = 0.0
-        self._best_guess_prober = None
-        for prober in self.probers:
-            if not prober:
-                continue
-            if not prober.active:
-                self.logger.debug('%s not active', prober.charset_name)
-                continue
-            conf = prober.get_confidence()
-            self.logger.debug('%s %s confidence = %s', prober.charset_name, prober.language, conf)
-            if best_conf < conf:
-                best_conf = conf
-                self._best_guess_prober = prober
-        if not self._best_guess_prober:
-            return 0.0
-        return best_conf

package/.claude/envoy/.venv/lib/python3.9/site-packages/pip/_vendor/chardet/charsetprober.py

@@ -1,145 +0,0 @@
-######################## 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 #########################
-
-import logging
-import re
-
-from .enums import ProbingState
-
-
-class CharSetProber(object):
-
-    SHORTCUT_THRESHOLD = 0.95
-
-    def __init__(self, lang_filter=None):
-        self._state = None
-        self.lang_filter = lang_filter
-        self.logger = logging.getLogger(__name__)
-
-    def reset(self):
-        self._state = ProbingState.DETECTING
-
-    @property
-    def charset_name(self):
-        return None
-
-    def feed(self, buf):
-        pass
-
-    @property
-    def state(self):
-        return self._state
-
-    def get_confidence(self):
-        return 0.0
-
-    @staticmethod
-    def filter_high_byte_only(buf):
-        buf = re.sub(b'([\x00-\x7F])+', b' ', buf)
-        return buf
-
-    @staticmethod
-    def filter_international_words(buf):
-        """
-        We define three types of bytes:
-        alphabet: english alphabets [a-zA-Z]
-        international: international characters [\x80-\xFF]
-        marker: everything else [^a-zA-Z\x80-\xFF]
-
-        The input buffer can be thought to contain a series of words delimited
-        by markers. This function works to filter all words that contain at
-        least one international character. All contiguous sequences of markers
-        are replaced by a single space ascii character.
-
-        This filter applies to all scripts which do not use English characters.
-        """
-        filtered = bytearray()
-
-        # This regex expression filters out only words that have at-least one
-        # international character. The word may include one marker character at
-        # the end.
-        words = re.findall(b'[a-zA-Z]*[\x80-\xFF]+[a-zA-Z]*[^a-zA-Z\x80-\xFF]?',
-                           buf)
-
-        for word in words:
-            filtered.extend(word[:-1])
-
-            # If the last character in the word is a marker, replace it with a
-            # space as markers shouldn't affect our analysis (they are used
-            # similarly across all languages and may thus have similar
-            # frequencies).
-            last_char = word[-1:]
-            if not last_char.isalpha() and last_char < b'\x80':
-                last_char = b' '
-            filtered.extend(last_char)
-
-        return filtered
-
-    @staticmethod
-    def filter_with_english_letters(buf):
-        """
-        Returns a copy of ``buf`` that retains only the sequences of English
-        alphabet and high byte characters that are not between <> characters.
-        Also retains English alphabet and high byte characters immediately
-        before occurrences of >.
-
-        This filter can be applied to all scripts which contain both English
-        characters and extended ASCII characters, but is currently only used by
-        ``Latin1Prober``.
-        """
-        filtered = bytearray()
-        in_tag = False
-        prev = 0
-
-        for curr in range(len(buf)):
-            # Slice here to get bytes instead of an int with Python 3
-            buf_char = buf[curr:curr + 1]
-            # Check if we're coming out of or entering an HTML tag
-            if buf_char == b'>':
-                in_tag = False
-            elif buf_char == b'<':
-                in_tag = True
-
-            # If current character is not extended-ASCII and not alphabetic...
-            if buf_char < b'\x80' and not buf_char.isalpha():
-                # ...and we're not in a tag
-                if curr > prev and not in_tag:
-                    # Keep everything after last non-extended-ASCII,
-                    # non-alphabetic character
-                    filtered.extend(buf[prev:curr])
-                    # Output a space to delimit stretch we kept
-                    filtered.extend(b' ')
-                prev = curr + 1
-
-        # If we're not in a tag...
-        if not in_tag:
-            # Keep everything after last non-extended-ASCII, non-alphabetic
-            # character
-            filtered.extend(buf[prev:])
-
-        return filtered

package/.claude/envoy/.venv/lib/python3.9/site-packages/pip/_vendor/chardet/cli/__init__.py

@@ -1 +0,0 @@
-

package/.claude/envoy/.venv/lib/python3.9/site-packages/pip/_vendor/chardet/cli/chardetect.py

@@ -1,84 +0,0 @@
-"""
-Script which takes one or more file paths and reports on their detected
-encodings
-
-Example::
-
-    % chardetect somefile someotherfile
-    somefile: windows-1252 with confidence 0.5
-    someotherfile: ascii with confidence 1.0
-
-If no paths are provided, it takes its input from stdin.
-
-"""
-
-from __future__ import absolute_import, print_function, unicode_literals
-
-import argparse
-import sys
-
-from pip._vendor.chardet import __version__
-from pip._vendor.chardet.compat import PY2
-from pip._vendor.chardet.universaldetector import UniversalDetector
-
-
-def description_of(lines, name='stdin'):
-    """
-    Return a string describing the probable encoding of a file or
-    list of strings.
-
-    :param lines: The lines to get the encoding of.
-    :type lines: Iterable of bytes
-    :param name: Name of file or collection of lines
-    :type name: str
-    """
-    u = UniversalDetector()
-    for line in lines:
-        line = bytearray(line)
-        u.feed(line)
-        # shortcut out of the loop to save reading further - particularly useful if we read a BOM.
-        if u.done:
-            break
-    u.close()
-    result = u.result
-    if PY2:
-        name = name.decode(sys.getfilesystemencoding(), 'ignore')
-    if result['encoding']:
-        return '{}: {} with confidence {}'.format(name, result['encoding'],
-                                                     result['confidence'])
-    else:
-        return '{}: no result'.format(name)
-
-
-def main(argv=None):
-    """
-    Handles command line arguments and gets things started.
-
-    :param argv: List of arguments, as if specified on the command-line.
-                 If None, ``sys.argv[1:]`` is used instead.
-    :type argv: list of str
-    """
-    # Get command line arguments
-    parser = argparse.ArgumentParser(
-        description="Takes one or more file paths and reports their detected \
-                     encodings")
-    parser.add_argument('input',
-                        help='File whose encoding we would like to determine. \
-                              (default: stdin)',
-                        type=argparse.FileType('rb'), nargs='*',
-                        default=[sys.stdin if PY2 else sys.stdin.buffer])
-    parser.add_argument('--version', action='version',
-                        version='%(prog)s {}'.format(__version__))
-    args = parser.parse_args(argv)
-
-    for f in args.input:
-        if f.isatty():
-            print("You are running chardetect interactively. Press " +
-                  "CTRL-D twice at the start of a blank line to signal the " +
-                  "end of your input. If you want help, run chardetect " +
-                  "--help\n", file=sys.stderr)
-        print(description_of(f, f.name))
-
-
-if __name__ == '__main__':
-    main()

package/.claude/envoy/.venv/lib/python3.9/site-packages/pip/_vendor/chardet/codingstatemachine.py

@@ -1,88 +0,0 @@
-######################## BEGIN LICENSE BLOCK ########################
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is
-# Netscape Communications Corporation.
-# Portions created by the Initial Developer are Copyright (C) 1998
-# 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 #########################
-
-import logging
-
-from .enums import MachineState
-
-
-class CodingStateMachine(object):
-    """
-    A state machine to verify a byte sequence for a particular encoding. For
-    each byte the detector receives, it will feed that byte to every active
-    state machine available, one byte at a time. The state machine changes its
-    state based on its previous state and the byte it receives. There are 3
-    states in a state machine that are of interest to an auto-detector:
-
-    START state: This is the state to start with, or a legal byte sequence
-                 (i.e. a valid code point) for character has been identified.
-
-    ME state:  This indicates that the state machine identified a byte sequence
-               that is specific to the charset it is designed for and that
-               there is no other possible encoding which can contain this byte
-               sequence. This will to lead to an immediate positive answer for
-               the detector.
-
-    ERROR state: This indicates the state machine identified an illegal byte
-                 sequence for that encoding. This will lead to an immediate
-                 negative answer for this encoding. Detector will exclude this
-                 encoding from consideration from here on.
-    """
-    def __init__(self, sm):
-        self._model = sm
-        self._curr_byte_pos = 0
-        self._curr_char_len = 0
-        self._curr_state = None
-        self.logger = logging.getLogger(__name__)
-        self.reset()
-
-    def reset(self):
-        self._curr_state = MachineState.START
-
-    def next_state(self, c):
-        # for each byte we get its class
-        # if it is first byte, we also get byte length
-        byte_class = self._model['class_table'][c]
-        if self._curr_state == MachineState.START:
-            self._curr_byte_pos = 0
-            self._curr_char_len = self._model['char_len_table'][byte_class]
-        # from byte's class and state_table, we get its next state
-        curr_state = (self._curr_state * self._model['class_factor']
-                      + byte_class)
-        self._curr_state = self._model['state_table'][curr_state]
-        self._curr_byte_pos += 1
-        return self._curr_state
-
-    def get_current_charlen(self):
-        return self._curr_char_len
-
-    def get_coding_state_machine(self):
-        return self._model['name']
-
-    @property
-    def language(self):
-        return self._model['language']

package/.claude/envoy/.venv/lib/python3.9/site-packages/pip/_vendor/chardet/compat.py

@@ -1,36 +0,0 @@
-######################## BEGIN LICENSE BLOCK ########################
-# Contributor(s):
-#   Dan Blanchard
-#   Ian Cordasco
-#
-# 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 #########################
-
-import sys
-
-
-if sys.version_info < (3, 0):
-    PY2 = True
-    PY3 = False
-    string_types = (str, unicode)
-    text_type = unicode
-    iteritems = dict.iteritems
-else:
-    PY2 = False
-    PY3 = True
-    string_types = (bytes, str)
-    text_type = str
-    iteritems = dict.items