django-nativemojo 0.1.10__py3-none-any.whl → 0.1.16__py3-none-any.whl

mojo/ws4redis/redis.py

@@ -1,183 +0,0 @@
-from redis import ConnectionPool, StrictRedis
-
-from mojo.ws4redis import settings
-import time
-from objict import objict
-
-from mojo.helpers.logit import get_logger
-logger = get_logger("async", filename="async.log")
-
-
-REDIS_CON_POOL = None
-
-
-def getRedisClient():
-    global REDIS_CON_POOL
-    if REDIS_CON_POOL is None:
-        REDIS_CON_POOL = ConnectionPool(**settings.WS4REDIS_CONNECTION)
-    return StrictRedis(connection_pool=REDIS_CON_POOL)
-
-
-# Function to check the number of connections in use and available
-def getPoolStatus():
-    status = objict()
-    if REDIS_CON_POOL is None:
-        return status
-    status.max_size = REDIS_CON_POOL.max_connections
-    status.size = REDIS_CON_POOL._created_connections
-    status.in_use = len(REDIS_CON_POOL._in_use_connections)
-    status.available = len(REDIS_CON_POOL._available_connections)
-    return status
-
-
-class RedisMessage(bytes):
-    def __new__(cls, value):
-        if isinstance(value, str):
-            if value != settings.WS4REDIS_HEARTBEAT:
-                return bytes(value, 'utf-8')
-        elif isinstance(value, list):
-            if len(value) >= 2 and value[0] == b'message':
-                return value[2]
-        elif isinstance(value, dict):
-            if not hasattr(value, "toJSON"):
-                value = objict(value)
-            return bytes(value.toJSON(as_string=True), 'utf-8')
-        elif isinstance(value, bytes):
-            return value
-        return None
-
-
-class RedisStore():
-    def __init__(self, connection=None):
-        self.connection = connection
-        if self.connection is None:
-            self.connection = getRedisClient()
-        self.subscriptions = []
-        self.pubsub = None
-        self.online_pk = None
-        self.online_channel = None
-        self.only_one = False  # don't count connections, only allows one instance
-        self.expire = settings.WS4REDIS_EXPIRE
-
-    def publish(self, message, channel, facility="events", pk=None, expire=None, prefix=settings.WS4REDIS_PREFIX):
-        if expire is None:
-            expire = self.expire
-        if not isinstance(message, RedisMessage):
-            message = RedisMessage(message)
-
-        if not isinstance(message, bytes):
-            raise ValueError('message is {} but should be bytes'.format(type(message)))
-
-        if isinstance(pk, list):
-            count = 0
-            for spk in pk:
-                count += self.publish(message, channel, facility, pk=spk, expire=expire, prefix=prefix)
-            return count
-
-        channel_key = self.channelToKey(channel, facility, pk, prefix)
-        if settings.WS4REDIS_LOG_DEBUG:
-            logger.info("publishing msg to: {0}".format(channel_key), message)
-        count = self.connection.publish(channel_key, message)
-        return count
-
-    def getSubMessage(self):
-        # get a message pending from subscription
-        if self.pubsub:
-            return self.pubsub.parse_response()
-        return None
-
-    def getPendingMessage(self, channel, facility="events", pk=None, prefix=settings.WS4REDIS_PREFIX):
-        # get a message from the connection channel
-        channel_key = self.channelToKey(channel, facility, pk, prefix)
-        return self.connection.get(channel_key)
-
-    def channelToKey(self, channel, facility="events", pk=None, prefix=settings.WS4REDIS_PREFIX):
-        if not pk:
-            key = F'{prefix}:{channel}:{facility}'
-        else:
-            key = F'{prefix}:{channel}:{pk}:{facility}'
-        return key
-
-    def subscribe(self, channel, facility="events", pk=None, prefix=settings.WS4REDIS_PREFIX):
-        if self.pubsub is None:
-            self.pubsub = self.connection.pubsub()
-        key = self.channelToKey(channel, facility, pk, prefix)
-        if key not in self.subscriptions:
-            if settings.WS4REDIS_LOG_DEBUG:
-                logger.info(F"subscribing to: {key}")
-            self.subscriptions.append(key)
-            self.pubsub.subscribe(key)
-        return key
-
-    def unsubscribe(self, channel, facility, pk=None, prefix=settings.WS4REDIS_PREFIX):
-        key = self.channelToKey(channel, facility, pk, prefix)
-        if key in self.subscriptions:
-            if settings.WS4REDIS_LOG_DEBUG:
-                logger.info(F"unsubscribing to: {key}")
-            self.subscriptions.remove(key)
-            self.pubsub.unsubscribe(key)
-
-    def publishModelOnline(self, name, pk, only_one=False):
-        if self.online_pk is None:
-            self.online_pk = pk
-            self.online_channel = name
-            self.only_one = only_one
-            if self.only_one:
-                self.connection.sadd(F"{name}:online", pk)
-            else:
-                count = self.connection.hincrby(F"{name}:online:connections", pk, 1)
-                if count == 1:
-                    self.connection.sadd(F"{name}:online", pk)
-
-    def unpublishModelOnline(self):
-        if self.online_pk:
-            name = self.online_channel
-            pk = self.online_pk
-            self.online_channel = None
-            self.online_pk = None
-            if self.only_one:
-                self.connection.srem(F"{name}:online", pk)
-            else:
-                count = self.connection.hincrby(F"{name}:online:connections", pk, -1)
-                if count == 0:
-                    self.connection.srem(F"{name}:online", pk)
-
-    def waitForMessage(self, muid=None, timeout=55):
-        timeout_at = time.time() + timeout
-        while time.time() < timeout_at:
-            message = self.pubsub.get_message()
-            if message is not None and message.get("type") == "message":
-                imsg = objict.from_json(message.get("data"))
-                if muid is not None and imsg.muid == muid:
-                    return imsg
-                elif muid is None:
-                    return imsg
-            time.sleep(1.0)
-        return None
-
-    def get_file_descriptor(self):
-        """
-        Returns the file descriptor used for passing to the select call when listening
-        on the message queue.
-        """
-        if self.pubsub.connection:
-            return self.pubsub.connection._sock.fileno()
-        return None
-
-    def release(self):
-        """
-        New implementation to free up Redis subscriptions when websockets close. This prevents
-        memory sap when Redis Output Buffer and Output Lists build when websockets are abandoned.
-        """
-        self.unpublishModelOnline()
-        if self.pubsub and self.pubsub.subscribed:
-            self.pubsub.unsubscribe()
-            self.pubsub.reset()
-        self.connection = None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.release()
-        return False

mojo/ws4redis/servers/base.py

@@ -1,86 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-from redis import StrictRedis
-from http import client as http_client
-from mojo.ws4redis import settings as private_settings
-from mojo.ws4redis.exceptions import WebSocketError, HandshakeError, UpgradeRequiredError, SSLRequiredError
-from mojo.ws4redis.connection import WebsocketConnection
-
-from django.core.exceptions import PermissionDenied
-from django.utils.encoding import force_str
-from django import http
-
-from mojo.helpers.logit import get_logger
-logger = get_logger("async", filename="async.log")
-
-
-class WebsocketServerBase(object):
-    def __init__(self, redis_connection=None):
-        """
-        redis_connection can be overriden by a mock object.
-        """
-        self._websockets = set()  # a list of currently active websockets
-        self._redis_connection = redis_connection
-        if redis_connection is None:
-            self._redis_connection = StrictRedis(**private_settings.WS4REDIS_CONNECTION)
-
-        # clear out all online user connections from redis
-        self._redis_connection.delete("users:online:connections")
-        self._redis_connection.delete("users:online")
-
-    def assure_protocol_requirements(self, environ):
-        if environ.get('REQUEST_METHOD') != 'GET':
-            raise HandshakeError('HTTP method must be a GET')
-
-        if environ.get('SERVER_PROTOCOL') != 'HTTP/1.1':
-            raise HandshakeError('HTTP server protocol must be 1.1')
-
-        if environ.get('HTTP_UPGRADE', '').lower() != 'websocket':
-            raise HandshakeError('Client does not wish to upgrade to a websocket')
-
-    @property
-    def websockets(self):
-        return self._websockets
-
-    def __call__(self, environ, start_response):
-        """ Hijack the main loop from the original thread and listen on events on Redis and Websockets"""
-        connection = None
-        try:
-            self.assure_protocol_requirements(environ)
-            connection = WebsocketConnection(self, environ, start_response)
-            connection.handleComs()
-        except WebSocketError:
-            logger.exception()
-            response = http.HttpResponse(status=1001, content='Websocket Closed')
-        except UpgradeRequiredError as excpt:
-            logger.exception()
-            response = http.HttpResponseBadRequest(status=426, content=excpt)
-        except HandshakeError as excpt:
-            logger.exception()
-            response = http.HttpResponseBadRequest(content=excpt)
-        except PermissionDenied as excpt:
-            logger.exception("PermissionDenied")
-            logger.warning('PermissionDenied: {}'.format(excpt), exc_info=sys.exc_info())
-            response = http.HttpResponseForbidden(content=excpt)
-        except SSLRequiredError as excpt:
-            logger.exception("SSLRequiredError")
-            response = http.HttpResponseServerError(content=excpt)
-        except Exception as excpt:
-            logger.exception()
-            response = http.HttpResponseServerError(content=excpt)
-        else:
-            response = http.HttpResponse()
-        finally:
-            logger.info("closing websocket")
-            if connection:
-                connection.release()
-            else:
-                logger.warning('Starting late response on websocket')
-                status_text = http_client.responses.get(response.status_code, 'UNKNOWN STATUS CODE')
-                status = '{0} {1}'.format(response.status_code, status_text)
-                # headers = list(response._headers.values())
-                # if six.PY3:
-                #     headers = list(headers)
-                start_response(force_str(status), [])
-                logger.info('Finish non-websocket response with status code: {}'.format(response.status_code))
-        return response

mojo/ws4redis/servers/django.py

@@ -1,171 +0,0 @@
-#-*- coding: utf-8 -*-
-import base64
-import select
-from hashlib import sha1
-from wsgiref import util
-from django.core.handlers import wsgi as django_wsgi
-from django.core.wsgi import get_wsgi_application
-from django.core.servers.basehttp import WSGIServer, WSGIRequestHandler, ServerHandler
-
-from django.conf import settings
-from django.core.management.commands import runserver
-import socketserver
-from django.utils.encoding import force_str
-from mojo.ws4redis.websocket import WebSocket
-from mojo.ws4redis.servers.base import WebsocketServerBase, HandshakeError, UpgradeRequiredError
-
-from io import IOBase
-
-
-from mojo.helpers.logit import get_logger
-logger = get_logger("async", filename="async.log")
-
-logger.info("YES")
-
-util._hoppish = {}.__contains__
-
-
-class LimitedStreamPatched(IOBase):
-    """
-    Wrap another stream to disallow reading it past a number of bytes.
-
-    Based on the implementation from werkzeug.wsgi.LimitedStream
-    See https://github.com/pallets/werkzeug/blob/dbf78f67/src/werkzeug/wsgi.py#L828
-    """
-
-    def __init__(self, stream, limit):
-        self.stream = stream
-        self._read = stream.read
-        self._readline = stream.readline
-        self._pos = 0
-        self.limit = limit
-
-    def read(self, size=-1, /):
-        _pos = self._pos
-        limit = self.limit
-        if _pos >= limit:
-            return b""
-        if size == -1 or size is None:
-            size = limit - _pos
-        else:
-            size = min(size, limit - _pos)
-        data = self._read(size)
-        self._pos += len(data)
-        return data
-
-    def readline(self, size=-1, /):
-        _pos = self._pos
-        limit = self.limit
-        if _pos >= limit:
-            return b""
-        if size == -1 or size is None:
-            size = limit - _pos
-        else:
-            size = min(size, limit - _pos)
-        line = self._readline(size)
-        self._pos += len(line)
-        return line
-
-
-def patchLimitedStream():
-    django_wsgi.LimitedStream = LimitedStreamPatched
-
-
-class WSGIRequestHandlerRunServer(WSGIRequestHandler):
-    def handle(self):
-        self.raw_requestline = self.rfile.readline(65537)
-        if len(self.raw_requestline) > 65536:
-            self.requestline = ''
-            self.request_version = ''
-            self.command = ''
-            self.send_error(414)
-            return
-
-        if not self.parse_request():  # An error code has been sent, just exit
-            return
-
-        handler = ServerHandler(
-            self.rfile, self.wfile, self.get_stderr(), self.get_environ()
-        )
-        handler.request_handler = self      # backpointer for logging
-        handler.http_version = '1.1'
-        handler.run(self.server.get_app())
-
-
-class WebsocketRunServer(WebsocketServerBase):
-    WS_GUID = b'258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-    WS_VERSIONS = ('13', '8', '7')
-
-    def upgrade_websocket(self, environ, start_response):
-        """
-        Attempt to upgrade the socket environ['wsgi.input'] into a websocket enabled connection.
-        """
-        websocket_version = environ.get('HTTP_SEC_WEBSOCKET_VERSION', '')
-        if not websocket_version:
-            raise UpgradeRequiredError
-        elif websocket_version not in self.WS_VERSIONS:
-            raise HandshakeError('Unsupported WebSocket Version: {0}'.format(websocket_version))
-
-        key = environ.get('HTTP_SEC_WEBSOCKET_KEY', '').strip()
-        if not key:
-            raise HandshakeError('Sec-WebSocket-Key header is missing/empty')
-        try:
-            key_len = len(base64.b64decode(key))
-        except TypeError:
-            raise HandshakeError('Invalid key: {0}'.format(key))
-        if key_len != 16:
-            # 5.2.1 (3)
-            raise HandshakeError('Invalid key: {0}'.format(key))
-
-        sec_ws_accept = base64.b64encode(sha1(key.encode('utf-8') + self.WS_GUID).digest())
-        sec_ws_accept = sec_ws_accept.decode('ascii')
-        headers = [
-            ('Upgrade', 'websocket'),
-            ('Connection', 'Upgrade'),
-            ('Sec-WebSocket-Accept', sec_ws_accept),
-            ('Sec-WebSocket-Version', str(websocket_version)),
-        ]
-        if environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL') is not None:
-            headers.append(('Sec-WebSocket-Protocol', environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL')))
-
-        logger.debug('WebSocket request accepted, switching protocols')
-        start_response(force_str('101 Switching Protocols'), headers)
-        start_response.__self__.finish_content()
-        winput = environ['wsgi.input']
-        if not hasattr(winput, "stream"):
-            # hack to get the stream back in later DJANGO
-            winput.stream = winput._read.__self__
-        return WebSocket(winput.stream)
-
-    def select(self, rlist, wlist, xlist, timeout=None):
-        return select.select(rlist, wlist, xlist, timeout)
-
-
-def run(addr, port, wsgi_handler, ipv6=False, threading=False, server_cls=None, **kwargs):
-    """
-    Function to monkey patch the internal Django command: manage.py runserver
-    """
-    server_address = (addr, port)
-    logger.info('Websocket support is enabled', server_address)
-    if not threading:
-        raise Exception("Django's Websocket server must run with threading enabled")
-    httpd_cls = type('WSGIServer', (socketserver.ThreadingMixIn, WSGIServer), {'daemon_threads': True})
-    httpd = httpd_cls(server_address, WSGIRequestHandlerRunServer, ipv6=ipv6)
-    httpd.set_app(wsgi_handler)
-    httpd.serve_forever()
-
-
-patchLimitedStream()
-
-runserver.run = run
-
-_django_app = get_wsgi_application()
-_websocket_app = WebsocketRunServer()
-_websocket_url = getattr(settings, 'WEBSOCKET_URL')
-
-
-def application(environ, start_response):
-    if _websocket_url and environ.get('PATH_INFO').startswith(_websocket_url):
-        # logger.info("environ", environ)
-        return _websocket_app(environ, start_response)
-    return _django_app(environ, start_response)

mojo/ws4redis/servers/uwsgi.py

@@ -1,63 +0,0 @@
-# -*- coding: utf-8 -*-
-import uwsgi
-import gevent.select
-
-import django
-django.setup()
-
-from mojo.ws4redis.exceptions import WebSocketError, SSLRequiredError
-from mojo.ws4redis.servers.base import WebsocketServerBase
-
-
-class uWSGIWebsocket(object):
-    def __init__(self):
-        self._closed = False
-
-    def get_file_descriptor(self):
-        """Return the file descriptor for the given websocket"""
-        try:
-            return uwsgi.connection_fd()
-        except IOError as e:
-            self.close()
-            raise WebSocketError(e)
-
-    @property
-    def closed(self):
-        return self._closed
-
-    def receive(self):
-        if self._closed:
-            raise WebSocketError("Connection is already closed")
-        try:
-            return uwsgi.websocket_recv_nb()
-        except IOError as e:
-            self.close()
-            raise WebSocketError(e)
-
-    def flush(self):
-        try:
-            uwsgi.websocket_recv_nb()
-        except IOError:
-            self.close()
-
-    def send(self, message, binary=None):
-        try:
-            uwsgi.websocket_send(message)
-        except IOError as e:
-            self.close()
-            raise WebSocketError(e)
-
-    def close(self, code=1000, message=''):
-        self._closed = True
-
-
-class uWSGIWebsocketServer(WebsocketServerBase):
-    def upgrade_websocket(self, environ, start_response):
-        try:
-            uwsgi.websocket_handshake(environ['HTTP_SEC_WEBSOCKET_KEY'], environ.get('HTTP_ORIGIN', ''))
-        except Exception:
-            raise SSLRequiredError("UWSGI REQUIRES SSL SUPPORT!")
-        return uWSGIWebsocket()
-
-    def select(self, rlist, wlist, xlist, timeout=None):
-        return gevent.select.select(rlist, wlist, xlist, timeout)

mojo/ws4redis/settings.py

@@ -1,45 +0,0 @@
-# -*- coding: utf-8 -*-
-from django.conf import settings
-
-WEBSOCKET_URL = getattr(settings, 'WEBSOCKET_URL', '/ws/')
-
-WS4REDIS_CONNECTION = getattr(settings, 'WS4REDIS_CONNECTION', {
-    'host': 'localhost',
-    'port': 6379,
-    'db': 0,
-    'password': None,
-})
-
-"""
-A string to prefix elements in the Redis datastore, to avoid naming conflicts with other services.
-"""
-WS4REDIS_PREFIX = getattr(settings, 'WS4REDIS_PREFIX', None)
-
-"""
-The time in seconds, items shall be persisted by the Redis datastore.
-"""
-WS4REDIS_EXPIRE = getattr(settings, 'WS4REDIS_EXPIRE', 3600)
-
-"""
-Replace the subscriber class by a customized version.
-"""
-WS4REDIS_SUBSCRIBER = getattr(settings, 'WS4REDIS_SUBSCRIBER', 'ws4redis.subscriber.RedisSubscriber')
-
-"""
-This set the magic string to recognize heartbeat messages. If set, this message string is ignored
-by the server and also shall be ignored on the client.
-
-If WS4REDIS_HEARTBEAT is not None, the server sends at least every 4 seconds a heartbeat message.
-It is then up to the client to decide, what to do with these messages.
-"""
-WS4REDIS_HEARTBEAT = getattr(settings, 'WS4REDIS_HEARTBEAT', None)
-
-# by default we only allow the "events" facillity
-WS4REDIS_FACILITIES = getattr(settings, "WS4REDIS_FACILITIES", ["events"])
-WS4REDIS_CHANNELS = getattr(settings, "WS4REDIS_CHANNELS", {})
-WS4REDIS_AUTHENTICATORS = getattr(settings, "WS4REDIS_AUTHENTICATORS", {})
-
-URL_AUTHENTICATOR = getattr(settings, "URL_AUTHENTICATOR", None)
-
-WS4REDIS_LOG_DEBUG = getattr(settings, 'WS4REDIS_LOG_DEBUG', False)
-WS4REDIS_NOAUTH_CLOSE = getattr(settings, 'WS4REDIS_NOAUTH_CLOSE', False)

mojo/ws4redis/utf8validator.py

@@ -1,128 +0,0 @@
-###############################################################################
-##
-##  Copyright 2011-2013 Tavendo GmbH
-##
-##  Note:
-##
-##  This code is a Python implementation of the algorithm
-##
-##            "Flexible and Economical UTF-8 Decoder"
-##
-##  by Bjoern Hoehrmann
-##
-##       bjoern@hoehrmann.de
-##       http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-##
-##  Licensed under the Apache License, Version 2.0 (the "License");
-##  you may not use this file except in compliance with the License.
-##  You may obtain a copy of the License at
-##
-##      http://www.apache.org/licenses/LICENSE-2.0
-##
-##  Unless required by applicable law or agreed to in writing, software
-##  distributed under the License is distributed on an "AS IS" BASIS,
-##  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-##  See the License for the specific language governing permissions and
-##  limitations under the License.
-##
-###############################################################################
-
-
-## use Cython implementation of UTF8 validator if available
-##
-try:
-    from wsaccel.utf8validator import Utf8Validator
-except:
-    ## fallback to pure Python implementation
-
-    class Utf8Validator:
-        """
-        Incremental UTF-8 validator with constant memory consumption (minimal
-        state).
-
-        Implements the algorithm "Flexible and Economical UTF-8 Decoder" by
-        Bjoern Hoehrmann (http://bjoern.hoehrmann.de/utf-8/decoder/dfa/).
-        """
-
-        ## DFA transitions
-        UTF8VALIDATOR_DFA = [
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  # 00..1f
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  # 20..3f
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  # 40..5f
-            0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  # 60..7f
-            1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,  # 80..9f
-            7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  # a0..bf
-            8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  # c0..df
-            0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3,  # e0..ef
-            0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,  # f0..ff
-            0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1,  # s0..s0
-            1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1,  # s1..s2
-            1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,  # s3..s4
-            1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1,  # s5..s6
-            1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  # s7..s8
-        ]
-
-        UTF8_ACCEPT = 0
-        UTF8_REJECT = 1
-
-        def __init__(self):
-            self.reset()
-
-        def decode(self, b):
-            """
-            Eat one UTF-8 octet, and validate on the fly.
-
-            Returns UTF8_ACCEPT when enough octets have been consumed, in which case
-            self.codepoint contains the decoded Unicode code point.
-
-            Returns UTF8_REJECT when invalid UTF-8 was encountered.
-
-            Returns some other positive integer when more octets need to be eaten.
-            """
-            type = Utf8Validator.UTF8VALIDATOR_DFA[b]
-
-            if self.state != Utf8Validator.UTF8_ACCEPT:
-                self.codepoint = (b & 0x3f) | (self.codepoint << 6)
-            else:
-                self.codepoint = (0xff >> type) & b
-
-            self.state = Utf8Validator.UTF8VALIDATOR_DFA[256 + self.state * 16 + type]
-
-            return self.state
-
-        def reset(self):
-            """
-            Reset validator to start new incremental UTF-8 decode/validation.
-            """
-            self.state = Utf8Validator.UTF8_ACCEPT
-            self.codepoint = 0
-            self.i = 0
-
-        def validate(self, ba):
-            """
-            Incrementally validate a chunk of bytes provided as string.
-
-            Will return a quad (valid?, endsOnCodePoint?, currentIndex, totalIndex).
-
-            As soon as an octet is encountered which renders the octet sequence
-            invalid, a quad with valid? == False is returned. currentIndex returns
-            the index within the currently consumed chunk, and totalIndex the
-            index within the total consumed sequence that was the point of bail out.
-            When valid? == True, currentIndex will be len(ba) and totalIndex the
-            total amount of consumed bytes.
-            """
-
-            l = len(ba)
-
-            for i in range(l):
-                ## optimized version of decode(), since we are not interested in actual code points
-
-                self.state = Utf8Validator.UTF8VALIDATOR_DFA[256 + (self.state << 4) + Utf8Validator.UTF8VALIDATOR_DFA[ord(ba[i])]]
-
-                if self.state == Utf8Validator.UTF8_REJECT:
-                    self.i += i
-                    return False, False, i, self.i
-
-            self.i += l
-
-            return True, self.state == Utf8Validator.UTF8_ACCEPT, l, self.i