tina4-python 0.2.72__tar.gz → 0.2.74__tar.gz

{tina4_python-0.2.72 → tina4_python-0.2.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tina4-python
-Version: 0.2.72
+Version: 0.2.74
 Summary: Tina4Python - This is not another framework for Python
 Author: Andre van Zuydam
 Author-email: andrevanzuydam@gmail.com
@@ -16,8 +16,10 @@ Requires-Dist: cryptography (>=42.0.5,<43.0.0)
 Requires-Dist: libsass (>=0.22.0,<0.23.0)
 Requires-Dist: litequeue (>=0.9,<0.10)
 Requires-Dist: mypy (>=0.991,<0.992)
+Requires-Dist: poetry-plugin-export (>=1.9.0,<2.0.0)
 Requires-Dist: pyjwt (>=2.8.0,<3.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: simple-websocket (>=1.1.0,<2.0.0)
 Requires-Dist: watchdog (>=4.0.0,<5.0.0)
 Description-Content-Type: text/markdown
 
@@ -432,3 +434,15 @@ docker run -d --hostname=my-kafka --name=some-kafka -p 9092:9092 apache/kafka
 docker run -d --hostname=my-rabbit --name=some-rabbit -p 15672:15672 -p 5672:5672 rabbitmq:3
 ```
 
+## Websocket Testing
+
+```bash
+brew install websocat
+```
+
+```python
+websocat http://localhost:7145/websocket
+```
+
+
+

{tina4_python-0.2.72 → tina4_python-0.2.74}/README.md

@@ -408,3 +408,15 @@ docker run -d --hostname=my-kafka --name=some-kafka -p 9092:9092 apache/kafka
 ```bash
 docker run -d --hostname=my-rabbit --name=some-rabbit -p 15672:15672 -p 5672:5672 rabbitmq:3
 ```
+
+## Websocket Testing
+
+```bash
+brew install websocat
+```
+
+```python
+websocat http://localhost:7145/websocket
+```
+
+

{tina4_python-0.2.72 → tina4_python-0.2.74}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tina4-python"
-version = "0.2.72"
+version = "0.2.74"
 description = "Tina4Python - This is not another framework for Python"
 authors = ["Andre van Zuydam <andrevanzuydam@gmail.com>"]
 readme = "README.md"
@@ -18,6 +18,8 @@ cryptography = "^42.0.5"
 watchdog = "^4.0.0"
 bcrypt = "^4.1.3"
 litequeue = "^0.9"
+simple-websocket = "^1.1.0"
+poetry-plugin-export = "^1.9.0"
 
 [tool.poetry.group.dev.dependencies]
 flake8 = "^7.0.0"

{tina4_python-0.2.72 → tina4_python-0.2.74}/tina4_python/DatabaseResult.py

@@ -54,7 +54,7 @@ class DatabaseResult:
 
         return {"recordsTotal": self.total_count, "recordsOffset": self.skip,  "recordCount": self.count, "recordsFiltered": self.total_count, "fields": self.columns, "data": self.to_array(), "dataError": self.error}
 
-    def to_array(self):
+    def to_array(self, _filter=None):
         """
         Creates an array or list of the items
         :return:
@@ -78,17 +78,20 @@ class DatabaseResult:
                     else:
                         json_record[key] = record[key]
 
+                if _filter is not None:
+                    json_record = _filter(json_record)
+
                 json_records.append(json_record)
 
             return json_records
         else:
             return []
 
-    def to_list(self):
-        return self.to_array()
+    def to_list(self, _filter=None):
+        return self.to_array(_filter)
 
-    def to_json(self):
-        return json.dumps(self.to_array())
+    def to_json(self, _filter=None):
+        return json.dumps(self.to_array(_filter))
 
     def __getitem__(self, item):
         if item < len(self.records):

{tina4_python-0.2.72 → tina4_python-0.2.74}/tina4_python/ORM.py

@@ -280,7 +280,7 @@ class ORM:
         if init_object is not None:
             self.__populate_orm(init_object)
 
-        Debug("Checking for", self.__table_name__, TINA4_LOG_INFO)
+        # Debug("Checking for", self.__table_name__, TINA4_LOG_INFO)
         if self.__dba__:
             self.__table_exists = self.__dba__.table_exists(self.__table_name__)
             if not self.__table_exists:
@@ -290,7 +290,7 @@ class ORM:
                 with open(filename, "w") as f:
                     f.write(sql)
                     f.close()
-            Debug("Table Exists", self.__table_exists, TINA4_LOG_INFO)
+            # Debug("Table Exists", self.__table_exists, TINA4_LOG_INFO)
         else:
             self.__table_exists = False
 

{tina4_python-0.2.72 → tina4_python-0.2.74}/tina4_python/Request.py

@@ -14,5 +14,8 @@ cookies = {}
 url = None
 session = None
 files = {}
+raw_request = None
 raw_data = None
 raw_content = None
+transport = None
+asgi_response = None

{tina4_python-0.2.72 → tina4_python-0.2.74}/tina4_python/Router.py

@@ -148,6 +148,8 @@ class Router:
                 Request.raw_request = request["raw_request"] if "raw_request" in request else None
                 Request.raw_content = request["raw_content"] if "raw_content" in request else None
                 Request.url = url
+                Request.transport = request["transport"] if "transport" in request else None
+                Request.asgi_response = request["asgi_response"] if "asgi_response" in request else None
 
                 tina4_python.tina4_current_request = Request
 

{tina4_python-0.2.72 → tina4_python-0.2.74}/tina4_python/Webserver.py

@@ -23,7 +23,7 @@ from tina4_python.Template import Template
 
 def is_int(v):
     try:
-        f=int(v)
+        f = int(v)
     except ValueError:
         return False
     return True
@@ -107,7 +107,7 @@ class Webserver:
         self.send_header("Connection", "Keep-Alive", headers)
         self.send_header("Keep-Alive", "timeout=5, max=30", headers)
 
-    async def get_response(self, method, asgi_response=False):
+    async def get_response(self, method, transport, asgi_response=False):
         """
         Get response
         :param method: GET, POST, PATCH, DELETE, PUT
@@ -152,13 +152,13 @@ class Webserver:
                         if isinstance(start_var, dict) and var_name in start_var:
                             start_var = start_var[var_name]
                         else:
-                            if counter+1 < len(var_names) and is_int(var_names[counter+1]) :
+                            if counter + 1 < len(var_names) and is_int(var_names[counter + 1]):
                                 if var_name not in start_var:
                                     start_var[var_name] = []
                                 start_var = start_var[var_name]
                             else:
-                                if counter-1 > 0 and is_int(var_names[counter-1]):
-                                    index = int(var_names[counter-1])
+                                if counter - 1 > 0 and is_int(var_names[counter - 1]):
+                                    index = int(var_names[counter - 1])
                                     new_value = {var_name: value}
                                     if index in range(len(start_var)):
                                         start_var[index].update(new_value)
@@ -169,7 +169,7 @@ class Webserver:
                                     start_var = start_var[index]
                                 else:
                                     if isinstance(start_var, dict):
-                                        if counter+1 == len(var_names):
+                                        if counter + 1 == len(var_names):
                                             start_var[var_name] = value
                                         else:
                                             start_var[var_name] = {}
@@ -186,7 +186,8 @@ class Webserver:
             body = None
 
         request = {"params": params, "body": body, "raw_data": self.request, "url": self.path, "session": self.session,
-                   "headers": self.lowercase_headers, "raw_request": self.request_raw, "raw_content": self.content_raw}
+                   "headers": self.lowercase_headers, "raw_request": self.request_raw, "raw_content": self.content_raw,
+                   "transport": transport, "asgi_response": asgi_response}
 
         tina4_python.tina4_current_request = request
 
@@ -230,9 +231,8 @@ class Webserver:
         return headers.encode()
 
     async def run_server(self):
-        server = await asyncio.start_server(self.handle_client, self.host_name, self.port)
-        async with server:
-            await server.serve_forever()
+        self.server = await asyncio.start_server(self.handle_client, self.host_name, self.port)
+        await self.server.serve_forever()
 
     async def get_data(self, reader):
         try:
@@ -291,6 +291,7 @@ class Webserver:
             self.method = protocol[0]
             self.path = protocol[1]
 
+
             method_list = [Constant.TINA4_GET, Constant.TINA4_DELETE, Constant.TINA4_PUT, Constant.TINA4_ANY,
                            Constant.TINA4_POST, Constant.TINA4_PATCH, Constant.TINA4_OPTIONS]
 
@@ -298,7 +299,7 @@ class Webserver:
 
             request_handled = False
             # return static content asap
-            if self.method == "GET":
+            if self.method == "GET" and "sec-websocket-key" not in self.lowercase_headers:
                 # split URL and extract query string
                 url = Router.clean_url(self.path)
                 url_parts = url.split('?')
@@ -314,14 +315,16 @@ class Webserver:
                         self.send_header("Content-Type", mime_type, headers)
                         await self.send_basic_headers(headers)
                         content = file.read()
-                        headers =  await self.get_headers(headers, self.response_protocol, HTTP_OK)
+                        headers = await self.get_headers(headers, self.response_protocol, HTTP_OK)
                         writer.write(headers + content)
                         await writer.drain()
+                        await writer.close()
                         request_handled = True
 
             if not request_handled:
                 # parse cookies
                 cookie_list = {}
+                content = ""
                 if "cookie" in self.lowercase_headers:
                     cookie_list_temp = self.lowercase_headers["cookie"].split(";")
                     for cookie_value in cookie_list_temp:
@@ -341,17 +344,27 @@ class Webserver:
                 else:
                     self.cookies[os.getenv("TINA4_SESSION", "PY_SESS")] = self.session.start()
 
-                if self.method != "" and contains_method:
-                    content = await (self.get_response(self.method))
-                    writer.write(content)
-                    await writer.drain()
+                if "sec-websocket-key" not in self.lowercase_headers:
+                    try:
+                        if self.method != "" and contains_method:
+                            content = await (self.get_response(self.method, writer))
+                        if content != "":
+                            writer.write(content)
+                            await writer.drain()
+                        writer.close()
+                    except BrokenPipeError as e:
+                        # socket got terminated
+                        pass
+                else:
+                    # for sockets
+                    await (self.get_response(self.method, writer))
+
 
-            writer.close()
         except Exception as e:
             error_string = tina4_python.global_exception_handler(e)
             headers = []
             await self.send_basic_headers(headers)
-            headers =  await self.get_headers(headers, self.response_protocol, HTTP_SERVER_ERROR)
+            headers = await self.get_headers(headers, self.response_protocol, HTTP_SERVER_ERROR)
             url = Router.clean_url(self.path)
 
             content_type = "text/html"
@@ -359,9 +372,12 @@ class Webserver:
                 content_type = self.lowercase_headers["content-type"].lower()
 
             if content_type == "application/json":
-                html = json.dumps({"error": "500 - Internal Server Error", "data": {"server": {"url": url}, "error_message": error_string}})
+                html = json.dumps({"error": "500 - Internal Server Error",
+                                   "data": {"server": {"url": url}, "error_message": error_string}})
             else:
-                html = Template.render_twig_template("errors/500.twig",  {"server": {"url": url}, "error_message": error_string})
+                html = Template.render_twig_template("errors/500.twig",
+                                                     {"server": {"url": url}, "error_message": error_string})
+
             writer.write(headers + html.encode())
             await writer.drain()
             writer.close()
@@ -382,6 +398,7 @@ class Webserver:
         self.port = port
         self.router_handler = None
         self.running = False
+        self.server = None
 
     async def serve_forever(self):
         await self.run_server()
@@ -389,4 +406,3 @@ class Webserver:
     def server_close(self):
         self.running = False
         self.server_socket.close()
-

tina4_python-0.2.74/tina4_python/Websocket.py

@@ -0,0 +1,39 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+import importlib
+import os
+from tina4_python.Debug import Debug
+
+class Websocket:
+    """
+    Websocket class which wraps simple_websocket library
+    """
+    def __init__(self, request):
+        try:
+            self.server = importlib.import_module("simple_websocket")
+            self.request = request
+        except Exception as e:
+            Debug.error("Error creating Websocket, perhaps you need to install simple_websocket ?", e)
+
+    async def connection(self):
+        """
+        Returns a websocket connection
+        :return:
+        """
+        try:
+            if self.request.asgi_response:
+                connection = await self.server.AioServer.accept(asgi=self.request.transport)
+            else:
+                if os.name == "nt":
+                    connection = await self.server.AioServer.accept(sock=self.request.transport.get_extra_info('socket'), headers=self.request.headers)
+                else:
+                    connection = await self.server.AioServer.accept(sock=self.request.transport.get_extra_info('socket').dup(), headers=self.request.headers)
+
+            return connection
+        except Exception as e:
+            Debug.error("Could not establish a socket connection:", str(e))
+            return None

{tina4_python-0.2.72 → tina4_python-0.2.74}/tina4_python/__init__.py

@@ -13,6 +13,8 @@ import sys
 import traceback
 import sass
 from pathlib import Path
+
+from safety.scan.command import scan_system_app
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler, FileSystemEvent
 from tina4_python.Router import get
@@ -263,8 +265,12 @@ async def app(scope, receive, send):
     :return:
     """
     body = b""
-    while True and scope['type'] == 'http':
-        message =  await receive()
+    while True and scope['type'] == 'http' or scope['type'] == 'websocket':
+        if scope['type'] != 'websocket':
+            message =  await receive()
+        else:
+            message = {'type': 'websocket'}
+
         if "body" in message:
             body += message["body"]
         if message['type'] == 'lifespan.startup':
@@ -273,7 +279,7 @@ async def app(scope, receive, send):
         elif message['type'] == 'lifespan.shutdown':
             await send({'type': 'lifespan.shutdown.complete'})
             return
-        elif message["type"] == "http.disconnect":
+        elif message["type"] == "http.disconnect" or message["type"] == "websocket.disconnect":
             return
         elif not message.get("more_body"):
             webserver = Webserver(scope["server"][0], scope["server"][1])
@@ -293,8 +299,13 @@ async def app(scope, receive, send):
 
             webserver.headers = parsed_headers
             webserver.lowercase_headers = parsed_headers_lowercase
+
             webserver.path = scope["path"]+"?"+scope["query_string"].decode()
-            webserver.method = scope["method"]
+
+            if "method" in scope:
+                webserver.method = scope["method"]
+            else:
+                webserver.method = "GET"
 
             if message["type"] == "http.request":
                 webserver.content_raw = body
@@ -324,26 +335,27 @@ async def app(scope, receive, send):
             else:
                 webserver.cookies[os.getenv("TINA4_SESSION", "PY_SESS")] = webserver.session.start()
 
-            tina4_response, tina4_headers = await webserver.get_response(scope["method"], True)
+            tina4_response, tina4_headers = await webserver.get_response(webserver.method, (scope,receive,send),True)
 
-            response_headers = []
-            for header in tina4_headers:
-                header = header.split(":")
-                response_headers.append([header[0].strip().encode(), header[1].strip().encode()])
+            if message["type"] != "websocket":
+                response_headers = []
+                for header in tina4_headers:
+                    header = header.split(":")
+                    response_headers.append([header[0].strip().encode(), header[1].strip().encode()])
 
-            await send({
-                'type': 'http.response.start',
-                'status': tina4_response.http_code,
-                'headers': response_headers,
-            })
-
-            if isinstance(tina4_response.content, str):
                 await send({
-                    'type': 'http.response.body',
-                    'body': tina4_response.content.encode(),
-                })
-            else:
-                await send({
-                    'type': 'http.response.body',
-                    'body': tina4_response.content,
+                    'type': 'http.response.start',
+                    'status': tina4_response.http_code,
+                    'headers': response_headers,
                 })
+
+                if isinstance(tina4_response.content, str):
+                    await send({
+                        'type': 'http.response.body',
+                        'body': tina4_response.content.encode(),
+                    })
+                else:
+                    await send({
+                        'type': 'http.response.body',
+                        'body': tina4_response.content,
+                    })

tina4_python-0.2.74/tina4_python/public/js/reconnecting-websocket.js

@@ -0,0 +1,365 @@
+// MIT License:
+//
+// Copyright (c) 2010-2012, Joe Walnes
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/**
+ * This behaves like a WebSocket in every way, except if it fails to connect,
+ * or it gets disconnected, it will repeatedly poll until it successfully connects
+ * again.
+ *
+ * It is API compatible, so when you have:
+ *   ws = new WebSocket('ws://....');
+ * you can replace with:
+ *   ws = new ReconnectingWebSocket('ws://....');
+ *
+ * The event stream will typically look like:
+ *  onconnecting
+ *  onopen
+ *  onmessage
+ *  onmessage
+ *  onclose // lost connection
+ *  onconnecting
+ *  onopen  // sometime later...
+ *  onmessage
+ *  onmessage
+ *  etc...
+ *
+ * It is API compatible with the standard WebSocket API, apart from the following members:
+ *
+ * - `bufferedAmount`
+ * - `extensions`
+ * - `binaryType`
+ *
+ * Latest version: https://github.com/joewalnes/reconnecting-websocket/
+ * - Joe Walnes
+ *
+ * Syntax
+ * ======
+ * var socket = new ReconnectingWebSocket(url, protocols, options);
+ *
+ * Parameters
+ * ==========
+ * url - The url you are connecting to.
+ * protocols - Optional string or array of protocols.
+ * options - See below
+ *
+ * Options
+ * =======
+ * Options can either be passed upon instantiation or set after instantiation:
+ *
+ * var socket = new ReconnectingWebSocket(url, null, { debug: true, reconnectInterval: 4000 });
+ *
+ * or
+ *
+ * var socket = new ReconnectingWebSocket(url);
+ * socket.debug = true;
+ * socket.reconnectInterval = 4000;
+ *
+ * debug
+ * - Whether this instance should log debug messages. Accepts true or false. Default: false.
+ *
+ * automaticOpen
+ * - Whether or not the websocket should attempt to connect immediately upon instantiation. The socket can be manually opened or closed at any time using ws.open() and ws.close().
+ *
+ * reconnectInterval
+ * - The number of milliseconds to delay before attempting to reconnect. Accepts integer. Default: 1000.
+ *
+ * maxReconnectInterval
+ * - The maximum number of milliseconds to delay a reconnection attempt. Accepts integer. Default: 30000.
+ *
+ * reconnectDecay
+ * - The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. Accepts integer or float. Default: 1.5.
+ *
+ * timeoutInterval
+ * - The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. Accepts integer. Default: 2000.
+ *
+ */
+(function (global, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define([], factory);
+    } else if (typeof module !== 'undefined' && module.exports){
+        module.exports = factory();
+    } else {
+        global.ReconnectingWebSocket = factory();
+    }
+})(this, function () {
+
+    if (!('WebSocket' in window)) {
+        return;
+    }
+
+    function ReconnectingWebSocket(url, protocols, options) {
+
+        // Default settings
+        var settings = {
+
+            /** Whether this instance should log debug messages. */
+            debug: false,
+
+            /** Whether or not the websocket should attempt to connect immediately upon instantiation. */
+            automaticOpen: true,
+
+            /** The number of milliseconds to delay before attempting to reconnect. */
+            reconnectInterval: 1000,
+            /** The maximum number of milliseconds to delay a reconnection attempt. */
+            maxReconnectInterval: 30000,
+            /** The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. */
+            reconnectDecay: 1.5,
+
+            /** The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. */
+            timeoutInterval: 2000,
+
+            /** The maximum number of reconnection attempts to make. Unlimited if null. */
+            maxReconnectAttempts: null,
+
+            /** The binary type, possible values 'blob' or 'arraybuffer', default 'blob'. */
+            binaryType: 'blob'
+        }
+        if (!options) { options = {}; }
+
+        // Overwrite and define settings with options if they exist.
+        for (var key in settings) {
+            if (typeof options[key] !== 'undefined') {
+                this[key] = options[key];
+            } else {
+                this[key] = settings[key];
+            }
+        }
+
+        // These should be treated as read-only properties
+
+        /** The URL as resolved by the constructor. This is always an absolute URL. Read only. */
+        this.url = url;
+
+        /** The number of attempted reconnects since starting, or the last successful connection. Read only. */
+        this.reconnectAttempts = 0;
+
+        /**
+         * The current state of the connection.
+         * Can be one of: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED
+         * Read only.
+         */
+        this.readyState = WebSocket.CONNECTING;
+
+        /**
+         * A string indicating the name of the sub-protocol the server selected; this will be one of
+         * the strings specified in the protocols parameter when creating the WebSocket object.
+         * Read only.
+         */
+        this.protocol = null;
+
+        // Private state variables
+
+        var self = this;
+        var ws;
+        var forcedClose = false;
+        var timedOut = false;
+        var eventTarget = document.createElement('div');
+
+        // Wire up "on*" properties as event handlers
+
+        eventTarget.addEventListener('open',       function(event) { self.onopen(event); });
+        eventTarget.addEventListener('close',      function(event) { self.onclose(event); });
+        eventTarget.addEventListener('connecting', function(event) { self.onconnecting(event); });
+        eventTarget.addEventListener('message',    function(event) { self.onmessage(event); });
+        eventTarget.addEventListener('error',      function(event) { self.onerror(event); });
+
+        // Expose the API required by EventTarget
+
+        this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
+        this.removeEventListener = eventTarget.removeEventListener.bind(eventTarget);
+        this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);
+
+        /**
+         * This function generates an event that is compatible with standard
+         * compliant browsers and IE9 - IE11
+         *
+         * This will prevent the error:
+         * Object doesn't support this action
+         *
+         * http://stackoverflow.com/questions/19345392/why-arent-my-parameters-getting-passed-through-to-a-dispatched-event/19345563#19345563
+         * @param s String The name that the event should use
+         * @param args Object an optional object that the event will use
+         */
+        function generateEvent(s, args) {
+            var evt = document.createEvent("CustomEvent");
+            evt.initCustomEvent(s, false, false, args);
+            return evt;
+        };
+
+        this.open = function (reconnectAttempt) {
+            ws = new WebSocket(self.url, protocols || []);
+            ws.binaryType = this.binaryType;
+
+            if (reconnectAttempt) {
+                if (this.maxReconnectAttempts && this.reconnectAttempts > this.maxReconnectAttempts) {
+                    return;
+                }
+            } else {
+                eventTarget.dispatchEvent(generateEvent('connecting'));
+                this.reconnectAttempts = 0;
+            }
+
+            if (self.debug || ReconnectingWebSocket.debugAll) {
+                console.debug('ReconnectingWebSocket', 'attempt-connect', self.url);
+            }
+
+            var localWs = ws;
+            var timeout = setTimeout(function() {
+                if (self.debug || ReconnectingWebSocket.debugAll) {
+                    console.debug('ReconnectingWebSocket', 'connection-timeout', self.url);
+                }
+                timedOut = true;
+                localWs.close();
+                timedOut = false;
+            }, self.timeoutInterval);
+
+            ws.onopen = function(event) {
+                clearTimeout(timeout);
+                if (self.debug || ReconnectingWebSocket.debugAll) {
+                    console.debug('ReconnectingWebSocket', 'onopen', self.url);
+                }
+                self.protocol = ws.protocol;
+                self.readyState = WebSocket.OPEN;
+                self.reconnectAttempts = 0;
+                var e = generateEvent('open');
+                e.isReconnect = reconnectAttempt;
+                reconnectAttempt = false;
+                eventTarget.dispatchEvent(e);
+            };
+
+            ws.onclose = function(event) {
+                clearTimeout(timeout);
+                ws = null;
+                if (forcedClose) {
+                    self.readyState = WebSocket.CLOSED;
+                    eventTarget.dispatchEvent(generateEvent('close'));
+                } else {
+                    self.readyState = WebSocket.CONNECTING;
+                    var e = generateEvent('connecting');
+                    e.code = event.code;
+                    e.reason = event.reason;
+                    e.wasClean = event.wasClean;
+                    eventTarget.dispatchEvent(e);
+                    if (!reconnectAttempt && !timedOut) {
+                        if (self.debug || ReconnectingWebSocket.debugAll) {
+                            console.debug('ReconnectingWebSocket', 'onclose', self.url);
+                        }
+                        eventTarget.dispatchEvent(generateEvent('close'));
+                    }
+
+                    var timeout = self.reconnectInterval * Math.pow(self.reconnectDecay, self.reconnectAttempts);
+                    setTimeout(function() {
+                        self.reconnectAttempts++;
+                        self.open(true);
+                    }, timeout > self.maxReconnectInterval ? self.maxReconnectInterval : timeout);
+                }
+            };
+            ws.onmessage = function(event) {
+                if (self.debug || ReconnectingWebSocket.debugAll) {
+                    console.debug('ReconnectingWebSocket', 'onmessage', self.url, event.data);
+                }
+                var e = generateEvent('message');
+                e.data = event.data;
+                eventTarget.dispatchEvent(e);
+            };
+            ws.onerror = function(event) {
+                if (self.debug || ReconnectingWebSocket.debugAll) {
+                    console.debug('ReconnectingWebSocket', 'onerror', self.url, event);
+                }
+                eventTarget.dispatchEvent(generateEvent('error'));
+            };
+        }
+
+        // Whether or not to create a websocket upon instantiation
+        if (this.automaticOpen == true) {
+            this.open(false);
+        }
+
+        /**
+         * Transmits data to the server over the WebSocket connection.
+         *
+         * @param data a text string, ArrayBuffer or Blob to send to the server.
+         */
+        this.send = function(data) {
+            if (ws) {
+                if (self.debug || ReconnectingWebSocket.debugAll) {
+                    console.debug('ReconnectingWebSocket', 'send', self.url, data);
+                }
+                return ws.send(data);
+            } else {
+                throw 'INVALID_STATE_ERR : Pausing to reconnect websocket';
+            }
+        };
+
+        /**
+         * Closes the WebSocket connection or connection attempt, if any.
+         * If the connection is already CLOSED, this method does nothing.
+         */
+        this.close = function(code, reason) {
+            // Default CLOSE_NORMAL code
+            if (typeof code == 'undefined') {
+                code = 1000;
+            }
+            forcedClose = true;
+            if (ws) {
+                ws.close(code, reason);
+            }
+        };
+
+        /**
+         * Additional public API method to refresh the connection if still open (close, re-open).
+         * For example, if the app suspects bad data / missed heart beats, it can try to refresh.
+         */
+        this.refresh = function() {
+            if (ws) {
+                ws.close();
+            }
+        };
+    }
+
+    /**
+     * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+     * this indicates that the connection is ready to send and receive data.
+     */
+    ReconnectingWebSocket.prototype.onopen = function(event) {};
+    /** An event listener to be called when the WebSocket connection's readyState changes to CLOSED. */
+    ReconnectingWebSocket.prototype.onclose = function(event) {};
+    /** An event listener to be called when a connection begins being attempted. */
+    ReconnectingWebSocket.prototype.onconnecting = function(event) {};
+    /** An event listener to be called when a message is received from the server. */
+    ReconnectingWebSocket.prototype.onmessage = function(event) {};
+    /** An event listener to be called when an error occurs. */
+    ReconnectingWebSocket.prototype.onerror = function(event) {};
+
+    /**
+     * Whether all instances of ReconnectingWebSocket should log debug messages.
+     * Setting this to true is the equivalent of setting all instances of ReconnectingWebSocket.debug to true.
+     */
+    ReconnectingWebSocket.debugAll = false;
+
+    ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING;
+    ReconnectingWebSocket.OPEN = WebSocket.OPEN;
+    ReconnectingWebSocket.CLOSING = WebSocket.CLOSING;
+    ReconnectingWebSocket.CLOSED = WebSocket.CLOSED;
+
+    return ReconnectingWebSocket;
+});