Blazeio 0.0.0.9__tar.gz

blazeio-0.0.0.9/Blazeio/Client/__init__.py

@@ -0,0 +1,208 @@
+# Blazeio.Client
+from asyncio import Protocol, get_event_loop, sleep
+from time import perf_counter
+from ssl import create_default_context, SSLError
+from ujson import loads, dumps
+from collections import deque, defaultdict
+
+p = print
+
+class Err(Exception):
+    def __init__(app, message=None):
+        super().__init__(message)
+        app.message = str(message)
+
+    def __str__(app) -> str:
+        return app.message
+
+class BlazeioClientProtocol(Protocol):
+    def __init__(app):
+        app.buffer = deque()
+        app.response_headers = defaultdict(str)
+        app.remaining = bytearray()
+        app.__is_at_eof__ = False
+        app.__is_connection_lost__ = False
+        app.__pulled_length__ = 0
+        app.__perf_counter__ = perf_counter()
+        app.__all__ = bytearray()
+
+    def connection_made(app, transport):
+        app.transport = transport
+
+    def data_received(app, data):
+        app.buffer.append(data)
+
+    def eof_received(app):
+        app.__is_at_eof__ = True
+
+    def connection_lost(app, exc):
+        app.__is_connection_lost__ = True
+
+    async def push(app, chunk):
+        if not isinstance(chunk, (bytes, bytearray)):
+            chunk = chunk.encode()
+
+        if not app.__is_connection_lost__:
+            app.transport.write(chunk)
+        
+    async def pull(app, all=False, timeout=2):
+        if all:
+            yield b"" + app.__all__
+            
+        else:
+            if app.remaining:
+                chunk = b"" + app.remaining
+                yield chunk
+                app.__pulled_length__ += len(app.remaining)
+
+        endl = b"\r\n0\r\n\r\n"
+
+        while True:
+            await sleep(0)
+                
+            while app.buffer:
+                await sleep(0)
+                chunk = app.buffer.popleft()
+                yield chunk
+
+                if endl in chunk:
+                    app.__is_at_eof__ = True
+
+            if app.__is_connection_lost__:
+                break
+            if app.__is_at_eof__:
+                break
+            
+            if perf_counter() - app.__perf_counter__ >= float(timeout):
+                break
+            yield None
+
+    async def fetch_headers(app):
+        tmp = bytearray()
+        sepr = b"\r\n\r\n"
+
+        async for data in app.pull():
+            if data:
+                tmp.extend(data)
+                app.__all__.extend(data)
+                if sepr in tmp:
+                    _ = tmp.split(sepr)
+                    app.remaining.extend(sepr.join(_[1:]))
+
+                    if (i := b'\r\n') in app.remaining:
+                        app.remaining = i.join(app.remaining.split(i)[1:])
+
+                    tmp = _[0]
+                    break
+
+        other_parts = tmp.decode("utf-8")
+
+        if '\r\n' in other_parts:
+            sepr = ': '
+            for header in other_parts.split('\r\n'):
+                await sleep(0)
+                if sepr in header:
+                    key, val = header.split(sepr, 1)
+                    app.response_headers[key.strip()] = val.strip()
+            
+            app.response_headers = dict(app.response_headers)
+        else:
+            return
+
+loop = get_event_loop()
+
+class Session:
+    def __init__(app, url: str, method: str = "GET", headers: dict = {}, port:int = 80, connect_only=False, params=None, body=None, **kwargs):
+        app.__dict__.update(locals())
+        app.host = app.url
+        
+    async def __aenter__(app):
+        if app.params:
+            prms = ""
+            if not (i := "?") in url:
+                prms += i
+            else:
+                prms += "&"
+
+            for key, val in app.params.items():
+                await sleep(0)
+                data = "%s=%s" % (str(key), str(val))
+                if "=" in prms:
+                    prms += "&"
+
+                prms += data
+
+            app.url += prms
+
+        await app.url_to_host()
+        
+        if app.port == 443:
+            app.ssl_context = create_default_context()
+
+        protocol = BlazeioClientProtocol()
+        app.protocol = protocol
+
+        transport, protocol_instance = await loop.create_connection(
+            lambda: protocol,
+            app.host, app.port, ssl=app.ssl_context if app.port == 443 else None
+        )
+        
+        await app.protocol.push(f"{app.method} {app.path} HTTP/1.1\r\n".encode())
+
+        if not "Host" in app.headers:
+            app.headers["Host"] = app.host
+        
+        if app.body:
+            app.headers["Content-Length"] = len(app.body)
+            
+        for key, val in app.headers.items():
+            await app.protocol.push(f"{key}: {val}\r\n".encode())
+            await sleep(0)
+            
+        await app.protocol.push("\r\n".encode())
+        
+        if app.connect_only: return app.protocol
+        
+        if app.method in ["GET", "HEAD", "OPTIONS"]:
+            await app.protocol.fetch_headers()
+        else:
+            if app.body:
+                await app.protocol.push(app.body)
+
+                await app.protocol.fetch_headers()
+
+        return app.protocol
+
+    async def url_to_host(app):
+        sepr = "://"
+        sepr2 = ":"
+        sepr3 = "/"
+        
+        if "https" in app.host:
+            if app.port == 80: app.port = 443
+
+        if sepr in app.host:
+            app.host = app.host.split(sepr)[-1]
+
+        if sepr2 in app.host:
+            app.host, app.port = app.host.split(sepr2)
+            if sepr3 in app.port:
+                app.port = app.port.split(sepr3)
+                try:app.port = int(app.port[0])
+                except: pass
+        
+        if sepr3 in app.host:
+            app.host = app.host.split(sepr3)[0]
+        
+        if sepr3 in app.url and len((_ := app.url.split(sepr3))) >= 3:
+            app.path = sepr3 + sepr3.join(_[3:])
+        else:
+            app.path = sepr3
+
+    async def __aexit__(app, exc_type, exc_val, exc_tb):
+        try:
+            app.protocol.transport.close()
+        except SSLError as e:
+            return
+        except Exception as e:
+            p("Exception: " + str(e))

blazeio-0.0.0.9/Blazeio/Client/__main__.py

@@ -0,0 +1,38 @@
+from Client import Session
+from time import perf_counter
+from asyncio import run, sleep, gather, create_task
+
+class Test:
+    async def test(app, url="http://example.com"):
+        try:
+            async with Session(url) as r:
+                async for data in r.get_data():
+                    #p(data)
+                    p("\n\n")
+                    
+                return r.response_headers
+
+        except Exception as e:
+            p("Test Exception: " + str(e))
+            
+    async def main(app):
+        urls = ["https://example.com", "https://www.google.com", "https://ipify.org", "https://youtube.com"]
+        queue = []
+        
+        start = perf_counter()
+
+        for url in urls:
+            task = create_task(app.test(url))
+            queue.append(task)
+            await sleep(0)
+
+        result = await gather(*queue)
+        p(result)
+        
+        p(f"Duration: {perf_counter() - start:.4f} seconds")
+        
+     
+if __name__ == "__main__":
+    #run(Test().test())
+    run(Test().main())
+    

blazeio-0.0.0.9/Blazeio/Client/other.py

@@ -0,0 +1,68 @@
+    async def text(app, chunk_size = 1024, decode = True):
+        sepr = b"\r\n\r\n"
+        chunks = b""
+        headers = b""
+        app.resp_headers = None
+        
+        async for chunk in app.stream(chunk_size):
+            chunks += chunk
+            if not app.resp_headers and chunks.rfind(sepr) != -1:
+                headers = chunks.split(sepr)[0] 
+                if b"\r\n" in headers:
+                    app.resp_headers = {}
+                    
+                    for h in headers.split(b"\r\n"):
+                        h = h.decode("utf-8")
+                        if ": " in h:
+                            _ = h.split(": ")
+                            key, val = _[0], ": ".join(_[1:])
+                            
+                            app.resp_headers[key] = val
+
+        if chunks.rfind(sepr) == -1:
+            return chunks
+
+        text = sepr.join(chunks.split(sepr)[1:])
+        
+        if decode:
+            text = text.decode("utf-8")
+            
+        return text
+        
+    async def json(app, chunk_size = 1024, decode = True):
+        sepr = b"\r\n\r\n"
+        chunks = b""
+        headers = b""
+        app.resp_headers = None
+        
+        async for chunk in app.stream(chunk_size):
+            chunks += chunk
+            if not app.resp_headers and chunks.rfind(sepr) != -1:
+                headers = chunks.split(sepr)[0] 
+                if b"\r\n" in headers:
+                    app.resp_headers = {}
+                    
+                    for h in headers.split(b"\r\n"):
+                        h = h.decode("utf-8")
+                        if ": " in h:
+                            _ = h.split(": ")
+                            key, val = _[0], ": ".join(_[1:])
+                            
+                            app.resp_headers[key] = val
+
+        if chunks.rfind(sepr) == -1:
+            return chunks
+
+        text = sepr.join(chunks.split(sepr)[1:])
+
+        text = b"{".join(text.split(b"{")[1:])
+        text = b"{" + text
+                
+        text = b"}".join(text.split(b"}")[:-1])
+        text += b"}"
+        
+        text = text.decode("utf-8")
+
+        text = loads(text)
+
+        return text

blazeio-0.0.0.9/Blazeio/Client/test.py

@@ -0,0 +1,40 @@
+from . import Session
+from time import perf_counter
+from asyncio import run, sleep, gather, create_task
+
+p = print
+
+class Test:
+    async def test(app, url="http://example.com"):
+        try:
+            async with Session(url) as r:
+                async for data in r.get_data():
+                    #p(data)
+                    p("\n\n")
+                    
+                return r.response_headers
+
+        except Exception as e:
+            p("Test Exception: " + str(e))
+            
+    async def main(app):
+        urls = ["https://example.com", "https://www.google.com", "https://ipify.org", "https://youtube.com"]
+        queue = []
+        
+        start = perf_counter()
+
+        for url in urls:
+            task = create_task(app.test(url))
+            queue.append(task)
+            await sleep(0)
+
+        result = await gather(*queue)
+        p(result)
+        
+        p(f"Duration: {perf_counter() - start:.4f} seconds")
+        
+     
+if __name__ == "__main__":
+    #run(Test().test())
+    run(Test().main())
+    

blazeio-0.0.0.9/Blazeio/Dependencies/__init__.py

@@ -0,0 +1,214 @@
+# Dependencies.__init___.py
+from asyncio import new_event_loop, run as io_run, CancelledError, get_event_loop, current_task, all_tasks, to_thread, sleep, gather, Protocol as asyncProtocol, run, create_subprocess_shell
+
+from collections import deque, defaultdict, OrderedDict
+from types import MappingProxyType
+
+from ujson import dumps, loads, JSONDecodeError
+
+from sys import exit
+from datetime import datetime as dt
+from inspect import signature as sig, stack
+from typing import Callable
+
+"""File serving"""
+from aiofile import async_open as iopen
+from mimetypes import guess_type
+from os.path import basename, getsize, exists, join
+from gzip import compress as gzip_compress
+
+"""logging"""
+from aiologger import Logger
+
+"""analytics"""
+from time import perf_counter
+
+try:
+    import uvloop
+    uvloop.install()
+except:
+    pass
+
+logger = Logger.with_default_handlers(name='BlazeioLogger')
+
+class Err(Exception):
+    def __init__(app, message=None):
+        super().__init__(message)
+        app.message = str(message)
+
+    def __str__(app) -> str:
+        return app.message
+
+class ServerGotInTrouble(Exception):
+    def __init__(app, message=None):
+        super().__init__(message)
+        app.message = str(message)
+
+    def __str__(app) -> str:
+        return app.message
+
+class Packdata:
+    @classmethod
+    async def add(app, **kwargs):
+        app = app()
+        app.__dict__.update(**kwargs)
+        return app
+
+    @classmethod
+    def add_sync(app, **kwargs):
+        app = app()
+        app.__dict__.update(**kwargs)
+        return app
+
+loop = get_event_loop()
+
+class Log:
+    known_exceptions = [
+        "[Errno 104] Connection reset by peer",
+        "Client has disconnected.",
+        "Connection lost",
+    ]
+
+    colors = {
+        'info': '\033[32m',
+        'error': '\033[31m',
+        'warning': '\033[33m',
+        'critical': '\033[38;5;1m',
+        'debug': '\033[34m',
+        'reset': '\033[32m'
+    }
+
+    @classmethod
+    async def __log__(app, r=None, message=None, logger_=logger.info):
+
+        log_level = logger_.__name__.split('.')[-1]
+        
+        color = app.colors.get(log_level, app.colors['reset'])
+
+        if "BlazeioPayload" in str(r):
+            message = str(message).strip()
+
+            if message in app.known_exceptions:
+                return
+
+            message = f"{color}{message}{app.colors['reset']}"
+
+            await logger_(
+                "%s•%s | [%s:%s] %s" % (
+                    r.identifier,
+                    str(dt.now()),
+                    r.ip_host,
+                    str(r.ip_port),
+                    message
+                )
+            )
+        else:
+            _ = str(r).strip()
+            if message:
+                _ += message
+                
+            message = _
+
+            if message in app.known_exceptions:
+                return
+
+            msg = message
+            message = f"{color}{message}{app.colors['reset']}"
+
+            if msg == "":
+                await logger_(message)
+                return
+            
+            await logger_(
+                "%s•%s | %s" % (
+                    "",
+                    str(dt.now()),
+                    message
+                )
+            )
+
+    @classmethod
+    async def info(app, *args): await app.__log__(*args, logger_=logger.info)
+
+    @classmethod
+    async def error(app, *args): await app.__log__(*args, logger_=logger.error)
+
+    @classmethod
+    async def warning(app, *args): await app.__log__(*args, logger_=logger.warning)
+
+    @classmethod
+    async def critical(app, *args): await app.__log__(*args, logger_=logger.critical)
+
+    @classmethod
+    async def debug(app, *args): await app.__log__(*args, logger_=logger.debug)
+
+    @classmethod
+    async def m(app, *args): await app.__log__(*args, logger_=logger.error)
+
+    @classmethod
+    async def bench(app):
+        start_time = dt.now().timestamp()
+
+        async def w(task):
+            for method in dir(app):
+                method = getattr(app, method)
+    
+                if isinstance(method, Callable) and not (name := method.__name__).startswith((sepr := "__")) and not name.endswith(sepr) and method != app.bench and not name in ["type"]:
+    
+                    await method(None, name)
+            
+            await app.info("Task %s completed successfully in %s seconds" % (task, dt.now().timestamp() - start_time))
+
+        tasks = []
+
+        while len(tasks) < 500:
+            task = loop.create_task( w(len(tasks) +1 ) )
+            tasks.append(task)
+
+        await gather(*tasks)
+
+        exit()
+
+class VersionControlla:
+    @classmethod
+    async def control(app, ins, HOME, HOST, PORT, **kwargs):
+        async def runner():
+            process = await create_subprocess_shell(
+                cmd=f'python -m Blazeio --path "{HOME}" --host "{HOST}" --port "{PORT}"',
+                stdout=None,
+                stderr=None,
+            )
+            try:
+                await process.wait()
+            except CancelledError:
+                process.terminate()
+                await process.wait()
+                raise
+
+        while True:
+            size = getsize(HOME)
+            task = loop.create_task(runner())
+
+            while True:
+                if task.done():
+                    break
+                
+                if getsize(HOME) == size:
+                    await sleep(1)
+                else:
+                    await Log.warning(f"version change detected in {HOME}, reloading server...")
+                    break
+            
+            if not task.done():
+                try:
+                    task.cancel()
+                    await task
+                except CancelledError:
+                    pass
+
+            else:
+                break
+
+
+p = Log.info
+loop.run_until_complete(Log.debug(""))