web-framework-api 1.0.0__py2.py3-none-any.whl

web_framework_api/WebFramework.py

@@ -0,0 +1,133 @@
+import ctypes
+import os
+from typing import Callable
+
+from .utility import Config
+from web_framework_api.utility.DLLHandler import DLLHandler
+from web_framework_api.exceptions.WebFrameworkException import WebFrameworkException
+
+
+class WebFramework:
+    """
+    Web server
+    """
+
+    def __init__(self, implementation: ctypes.c_void_p):
+        self.__implementation = implementation
+        self.__function_signature = ctypes.CFUNCTYPE(None)
+        self.__on_start_server = None
+
+    @classmethod
+    def from_path(cls, config_path: str) -> "WebFramework":
+        """
+
+        :param config_path: Path to *.json config
+        :return:
+        """
+        config_path = os.path.abspath(config_path)
+
+        if not os.path.exists(config_path):
+            raise FileNotFoundError(f"Path {config_path} doesn't exist")
+
+        exception = ctypes.c_void_p(0)
+        implementation = DLLHandler.get_instance().call_function("createWebFrameworkFromPath", ctypes.c_void_p,
+                                                                 ctypes.c_char_p(config_path.encode()),
+                                                                 ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return cls(implementation)
+
+    @classmethod
+    def from_string(cls, server_configuration: str, application_directory: str) -> "WebFramework":
+        """
+
+        :param server_configuration: *.json config file content
+        :param application_directory: Working directory
+        :return:
+        """
+        exception = ctypes.c_void_p(0)
+        implementation = DLLHandler.get_instance().call_function("createWebFrameworkFromString", ctypes.c_void_p,
+                                                                 ctypes.c_char_p(server_configuration.encode()),
+                                                                 ctypes.c_char_p(application_directory.encode()),
+                                                                 ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return cls(implementation)
+
+    @classmethod
+    def from_config(cls, config: Config) -> "WebFramework":
+        """
+
+        :param config: Config instance
+        :return:
+        """
+        exception = ctypes.c_void_p(0)
+        implementation = DLLHandler.get_instance().call_function("createWebFrameworkFromConfig", ctypes.c_void_p,
+                                                                 ctypes.c_uint64(config.implementation),
+                                                                 ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return cls(implementation)
+
+    def start(self, wait: bool = False, on_start_server: Callable[[], None] = None):
+        """
+        Start server
+        :param wait: Wait until server stop(False doesn't work)
+        :param on_start_server: On start server callback
+        :return:
+        """
+        if on_start_server is None:
+            def default_function():
+                pass
+
+            on_start_server = default_function
+
+        self.__on_start_server = on_start_server
+        exception = ctypes.c_void_p(0)
+
+        DLLHandler.get_instance().call_class_member_function("startWebFrameworkServer", None, self.__implementation,
+                                                             wait,
+                                                             self.__function_signature(self.__on_start_server),
+                                                             ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+    def stop(self, wait: bool = True):
+        """
+        Stop server
+        :param wait: Wait until server stop
+        :return:
+        """
+        exception = ctypes.c_void_p(0)
+        DLLHandler.get_instance().call_class_member_function("stopWebFrameworkServer", None, self.__implementation,
+                                                             wait,
+                                                             ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+    def is_server_running(self) -> bool:
+        """
+        Is server running
+        :return:
+        """
+
+        exception = ctypes.c_void_p(0)
+        result = DLLHandler.get_instance().call_class_member_function("isServerRunning", ctypes.c_bool,
+                                                                      self.__implementation,
+                                                                      ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return result
+
+    def __del__(self):
+        DLLHandler.get_instance().free(self.__implementation)

web_framework_api/exceptions/WebFrameworkException.py

@@ -0,0 +1,18 @@
+import ctypes
+
+from web_framework_api.utility.DLLHandler import DLLHandler
+
+
+class WebFrameworkException(Exception):
+    """
+    Exception class for WebFramework exceptions
+    """
+    def __init__(self, implementation: ctypes.c_void_p):
+        self.__implementation = implementation
+
+    def __str__(self) -> str:
+        return DLLHandler.get_instance().call_function("getErrorMessage", ctypes.c_char_p,
+                                                       ctypes.c_uint64(self.__implementation)).decode()
+
+    def __del__(self):
+        DLLHandler.get_instance().free(self.__implementation)

web_framework_api/utility/Config.py

@@ -0,0 +1,316 @@
+import ctypes
+from typing import List
+
+from multipledispatch import dispatch
+
+from web_framework_api.utility.DLLHandler import DLLHandler
+from web_framework_api.exceptions.WebFrameworkException import WebFrameworkException
+
+
+class Config:
+    """
+    Config file representation
+    """
+
+    def __init__(self, implementation: ctypes.c_void_p):
+        self.implementation = implementation
+
+    @classmethod
+    def from_path(cls, config_path: str) -> "Config":
+        """
+
+        :param config_path: Path to *.json config file
+        :return:
+        """
+        exception = ctypes.c_void_p(0)
+        implementation = DLLHandler.get_instance().call_function("createConfigFromPath", ctypes.c_void_p,
+                                                                 ctypes.c_char_p(config_path.encode()),
+                                                                 ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return cls(implementation)
+
+    @classmethod
+    def from_string(cls, server_configuration: str, application_directory: str) -> "Config":
+        """
+
+        :param server_configuration: *.json config file content
+        :param application_directory: Working directory
+        :return:
+        """
+        exception = ctypes.c_void_p(0)
+        implementation = DLLHandler.get_instance().call_function("createConfigFromString", ctypes.c_void_p,
+                                                                 ctypes.c_char_p(server_configuration.encode()),
+                                                                 ctypes.c_char_p(application_directory.encode()),
+                                                                 ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return cls(implementation)
+
+    @dispatch(str, str, bool)
+    def override_configuration(self, key: str, value: str, recursive: bool = True) -> "Config":
+        """
+        Override string
+        :param key: JSON key
+        :param value: New string value
+        :param recursive: Recursive search for key
+        :return: self
+        """
+        exception = ctypes.c_void_p(0)
+
+        DLLHandler.get_instance().call_class_member_function("overrideConfigurationString", None, self.implementation,
+                                                             ctypes.c_char_p(key.encode()),
+                                                             ctypes.c_char_p(value.encode()),
+                                                             recursive, ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return self
+
+    @dispatch(str, int, bool)
+    def override_configuration(self, key: str, value: int, recursive: bool = True) -> "Config":
+        """
+        Override integer
+        :param key: JSON key
+        :param value: New integer value
+        :param recursive: Recursive search for key
+        :return: self
+        """
+        exception = ctypes.c_void_p(0)
+
+        DLLHandler.get_instance().call_class_member_function("overrideConfigurationInteger", None, self.implementation,
+                                                             ctypes.c_char_p(key.encode()), ctypes.c_int64(value),
+                                                             recursive, ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return self
+
+    @dispatch(str, bool, bool)
+    def override_configuration(self, key: str, value: bool, recursive: bool = True) -> "Config":
+        """
+        Override bool
+        :param key: JSON key
+        :param value: New bool value
+        :param recursive: Recursive search for key
+        :return: self
+        """
+        exception = ctypes.c_void_p(0)
+
+        DLLHandler.get_instance().call_class_member_function("overrideConfigurationBoolean", None, self.implementation,
+                                                             ctypes.c_char_p(key.encode()), value,
+                                                             recursive, ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return self
+
+    def override_configuration_string_array(self, key: str, value: List[str], recursive: bool = True) -> "Config":
+        """
+        Override string array
+        :param key: JSON key
+        :param value: New string array value
+        :param recursive: Recursive search for key
+        :return: self
+        """
+        exception = ctypes.c_void_p(0)
+
+        data = (ctypes.c_char_p * len(value))()
+
+        for i in range(len(value)):
+            data[i] = value[i].encode()
+
+        DLLHandler.get_instance().call_class_member_function("overrideConfigurationStringArray", None,
+                                                             self.implementation,
+                                                             ctypes.c_char_p(key.encode()), ctypes.pointer(data),
+                                                             recursive, ctypes.c_int64(len(value)),
+                                                             ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return self
+
+    def override_configuration_integer_array(self, key: str, value: List[int], recursive: bool = True) -> "Config":
+        """
+        Override integer array
+        :param key: JSON key
+        :param value: New integer array value
+        :param recursive: Recursive search for key
+        :return: self
+        """
+        exception = ctypes.c_void_p(0)
+
+        data = (ctypes.c_int64 * len(value))()
+
+        for i in range(len(value)):
+            data[i] = value[i]
+
+        DLLHandler.get_instance().call_class_member_function("overrideConfigurationIntegerArray", None,
+                                                             self.implementation,
+                                                             ctypes.c_char_p(key.encode()), ctypes.pointer(data),
+                                                             recursive, ctypes.c_int64(len(value)),
+                                                             ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return self
+
+    def override_base_path(self, base_path: str) -> "Config":
+        """
+        Override config file directory
+        :param base_path: New base path
+        :return: self
+        """
+
+        exception = ctypes.c_void_p(0)
+
+        DLLHandler.get_instance().call_class_member_function("overrideBasePath", None, self.implementation,
+                                                             ctypes.c_char_p(base_path.encode()),
+                                                             ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return self
+
+    def get_configuration_string(self, key: str, recursive: bool = True) -> str:
+        """
+        Get string from config
+        :param key: Config key
+        :param recursive: Search recursively
+        :return: Config string value
+        """
+
+        exception = ctypes.c_void_p(0)
+
+        handler = DLLHandler.get_instance()
+        string_implementation = handler.call_class_member_function("getConfigurationString",
+                                                                   ctypes.c_void_p,
+                                                                   self.implementation,
+                                                                   ctypes.c_char_p(key.encode()),
+                                                                   recursive, ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        result_ptr = handler.call_function("getDataFromString", ctypes.c_char_p,
+                                           ctypes.c_uint64(string_implementation))
+
+        result = str(result_ptr.decode())
+
+        handler.free(string_implementation)
+
+        return result
+
+    def get_configuration_integer(self, key: str, recursive: bool = True) -> int:
+        """
+        Get integer from config
+        :param key: Config key
+        :param recursive: Search recursively
+        :return: Config integer value
+        """
+
+        exception = ctypes.c_void_p(0)
+
+        result = DLLHandler.get_instance().call_class_member_function("getConfigurationInteger",
+                                                                      ctypes.c_int64,
+                                                                      self.implementation,
+                                                                      ctypes.c_char_p(key.encode()),
+                                                                      recursive, ctypes.byref(exception))
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return result
+
+    def get_configuration_boolean(self, key: str, recursive: bool = True) -> bool:
+        """
+        Get boolean from config
+        :param key: Config key
+        :param recursive: Search recursively
+        :return: Config boolean value
+        """
+
+        exception = ctypes.c_void_p(0)
+
+        result = DLLHandler.get_instance().call_class_member_function("getConfigurationBoolean",
+                                                                      ctypes.c_bool,
+                                                                      self.implementation,
+                                                                      ctypes.c_char_p(key.encode()),
+                                                                      recursive, ctypes.byref(exception))
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return result
+
+    def get_configuration(self) -> str:
+        """
+        Get current config JSON string data
+        :return:
+        """
+        exception = ctypes.c_void_p(0)
+
+        handler = DLLHandler.get_instance()
+        string_implementation = handler.call_class_member_function("getConfiguration", ctypes.c_void_p,
+                                                                   self.implementation,
+                                                                   ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        result_ptr = handler.call_function("getDataFromString", ctypes.c_char_p,
+                                           ctypes.c_uint64(string_implementation))
+
+        result = str(result_ptr.decode())
+
+        handler.free(string_implementation)
+
+        return result
+
+    def get_base_path(self) -> str:
+        """
+        Get config file directory
+        :return:
+        """
+        exception = ctypes.c_void_p(0)
+
+        handler = DLLHandler.get_instance()
+        string_implementation = handler.call_class_member_function("getBasePath", ctypes.c_void_p,
+                                                                   self.implementation,
+                                                                   ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        result_ptr = handler.call_function("getDataFromString", ctypes.c_char_p,
+                                           ctypes.c_uint64(string_implementation))
+
+        result = str(result_ptr.decode())
+
+        handler.free(string_implementation)
+
+        return result
+
+    def get_raw_configuration(self) -> str:
+        """
+        Get raw config JSON string data
+        :return:
+        """
+        exception = ctypes.c_void_p(0)
+
+        result = DLLHandler.get_instance().call_class_member_function("getRawConfiguration", ctypes.c_char_p,
+                                                                      self.implementation,
+                                                                      ctypes.byref(exception))
+
+        if exception:
+            raise WebFrameworkException(exception.value)
+
+        return result.decode()

web_framework_api/utility/DLLHandler.py

@@ -0,0 +1,79 @@
+import ctypes
+import sys
+import os
+
+from pathlib import Path
+
+from web_framework_api.utility.Utils import get_libraries
+
+
+def initialize_web_framework(path_to_dll: str = ""):
+    """
+    Load WebFramework shared library
+    :param path_to_dll: Path to shared library without prefixes(lib for Linux) and file extensions(.dll, .so). By default, take path to WebFramework library from pip package
+    :return:
+    """
+    if DLLHandler.instance is not None:
+        return
+
+    shared_libraries_dir = os.path.abspath(
+        os.path.join(Path(__file__).parent.parent, "dll" if sys.platform == "win32" else "lib"))
+    download = False
+    empty_path_to_dll = len(path_to_dll) == 0
+
+    if len(path_to_dll) == 0:
+        path_to_dll = os.path.join(shared_libraries_dir, "WebFramework")
+        download = True
+
+    path_to_dll = os.path.abspath(path_to_dll)
+
+    if sys.platform == "win32":
+        path_to_dll = f"{path_to_dll}.dll"
+
+        os.environ["PATH"] += os.pathsep + f"{shared_libraries_dir}"
+    else:
+        path = Path(path_to_dll)
+        path_to_dll = f"{path.parent}/lib{path.name}.so"
+
+        if empty_path_to_dll and ("LD_LIBRARY_PATH" in os.environ and shared_libraries_dir not in os.environ[
+            "LD_LIBRARY_PATH"]) or "LD_LIBRARY_PATH" not in os.environ:
+            raise Exception(f"{shared_libraries_dir} not in LD_LIBRARY_PATH")
+
+    if not os.path.exists(path_to_dll):
+        if not download:
+            raise FileNotFoundError(f"Path {path_to_dll} doesn't exist")
+        else:
+            get_libraries(shared_libraries_dir)
+
+    DLLHandler.instance = DLLHandler(path_to_dll)
+
+
+class DLLHandler:
+    instance = None
+
+    def __init__(self, path_to_dll: str):
+        self.__handle = ctypes.CDLL(path_to_dll)
+
+    @classmethod
+    def get_instance(cls):
+        if cls.instance is None:
+            raise Exception("WebFramework must be initialized with initialize_web_framework function")
+
+        return cls.instance
+
+    def call_function(self, function_name: str, return_type, *args):
+        function = self.__handle[function_name]
+
+        function.restype = return_type
+
+        return function(*args)
+
+    def call_class_member_function(self, function_name: str, return_type, implementation: ctypes.c_void_p, *args):
+        function = self.__handle[function_name]
+
+        function.restype = return_type
+
+        return function(ctypes.c_uint64(implementation), *args)
+
+    def free(self, implementation: ctypes.c_void_p):
+        self.call_function("deleteWebFrameworkObject", None, ctypes.c_uint64(implementation))

web_framework_api/utility/Utils.py

@@ -0,0 +1,86 @@
+import os.path
+import shutil
+import sys
+import zipfile
+
+import requests
+
+from tqdm import tqdm
+
+WEB_FRAMEWORK_MAJOR_VERSION = "0"
+WEB_FRAMEWORK_MINOR_VERSION = "5"
+WEB_FRAMEWORK_LIBRARIES_FILE_NAME = "libraries.zip"
+WEB_FRAMEWORK_DOWNLOAD_BLOCK_SIZE = 1024
+
+
+def download_libraries(download_path: str):
+    url = get_url()
+    response = requests.get(url, stream=True)
+
+    total_size = int(response.headers.get("content-length", 0))
+
+    with tqdm(total=total_size, unit="B", unit_scale=True) as progress_bar:
+        progress_bar.set_description(f"Downloading {url}")
+
+        with open(f"{download_path}/{WEB_FRAMEWORK_LIBRARIES_FILE_NAME}", "wb") as file:
+            for data in response.iter_content(WEB_FRAMEWORK_DOWNLOAD_BLOCK_SIZE):
+                progress_bar.update(len(data))
+                file.write(data)
+
+    if total_size != 0 and progress_bar.n != total_size:
+        raise RuntimeError("Could not download file")
+
+    return f"{download_path}/{WEB_FRAMEWORK_LIBRARIES_FILE_NAME}"
+
+
+def unzip_libraries(path_to_zip: str, output_path: str):
+    with zipfile.ZipFile(path_to_zip, "r") as zip_file:
+        zip_file.extractall(output_path)
+
+
+def copy_libraries(libraries_directory: str):
+    if sys.platform == "win32":
+        directory_path = os.path.join(libraries_directory, "ReleaseDLL_Windows", "dll")
+
+        for file in os.listdir(directory_path):
+            shutil.copy(os.path.join(directory_path, file), libraries_directory)
+
+    else:
+        directory_path = os.path.join(libraries_directory, "ReleaseDLL_Linux", "lib")
+
+        for file in os.listdir(directory_path):
+            if file.endswith(".so"):
+                shutil.copy(os.path.join(directory_path, file), libraries_directory)
+
+
+def remove_files(libraries_directory: str):
+    for file in os.listdir(libraries_directory):
+        if os.path.isdir(os.path.join(libraries_directory, file)):
+            shutil.rmtree(os.path.join(libraries_directory, file))
+
+    os.remove(os.path.join(libraries_directory, WEB_FRAMEWORK_LIBRARIES_FILE_NAME))
+
+
+def create_directories(libraries_directory: str):
+    if sys.platform == "win32":
+        os.makedirs(os.path.join(libraries_directory, "dll"))
+    else:
+        os.makedirs(os.path.join(libraries_directory, "lib"))
+
+def get_url():
+    if sys.platform == "win32":
+        return f"https://github.com/LazyPanda07/WebFramework/releases/download/v3.{WEB_FRAMEWORK_MAJOR_VERSION}.{WEB_FRAMEWORK_MINOR_VERSION}/windows.zip"
+    else:
+        return f"https://github.com/LazyPanda07/WebFramework/releases/download/v3.{WEB_FRAMEWORK_MAJOR_VERSION}.{WEB_FRAMEWORK_MINOR_VERSION}/linux.zip"
+
+
+def get_libraries(libraries_directory: str):
+    create_directories(libraries_directory)
+
+    zip_path = download_libraries(libraries_directory)
+
+    unzip_libraries(zip_path, libraries_directory)
+
+    copy_libraries(libraries_directory)
+
+    remove_files(libraries_directory)

web_framework_api-1.0.0.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.3
+Name: web_framework_api
+Version: 1.0.0
+Summary: Python API for WebFramework
+Project-URL: Repository, http://github.com/LazyPanda07/WebFramework
+Project-URL: Wiki, http://github.com/LazyPanda07/WebFramework/wiki
+Author-email: LazyPanda07 <semengricenko@gmail.com>
+Maintainer-email: LazyPanda07 <semengricenko@gmail.com>
+License: MIT License
+Keywords: Web
+Requires-Dist: multipledispatch
+Requires-Dist: requests
+Requires-Dist: tqdm
+Description-Content-Type: text/markdown
+
+C++ HTTP/HTTPS server with Python API
+
+
+* [Quick start](#quick-start)
+  * [main.py](#mainpy)
+  * [Settings](#settings)
+  * [Config](#config)
+  * [Run sample](#run-sample)
+* [Executors](#executors)
+
+
+## Quick start
+Server needs few files to run: 
+* [web.json](#settings) with routes
+* [Executors](#executors)
+	* [Windows](https://github.com/LazyPanda07/WebFramework/releases/download/Assets/windows.zip)
+	* [Linux](https://github.com/LazyPanda07/WebFramework/releases/download/Assets/linux.zip)
+* [config.json](#config) with server settings  
+All these files must be in the same directory as ```main.py```
+
+
+### main.py
+```python
+from web_framework_api.WebFramework import WebFramework  # Server
+from web_framework_api.utility.DLLHandler import initialize_web_framework  # WebFramework initialization 
+from web_framework_api.exceptions.WebFrameworkException import WebFrameworkException  # Exception
+
+def on_start():
+  print("Server is running")
+
+if __name__ == '__main__':
+  try:
+    initialize_web_framework()  # Load WebFramework shared library
+
+    server = WebFramework.from_path("config.json")  # Create server
+
+    server.start(True, on_start)  # Start server and wait
+  except WebFrameworkException as exception:
+    print(exception)
+
+    exit(-1)
+```
+
+
+### Settings
+```web.json```
+```json
+{
+  "HelloExecutor": {
+    "route": "",
+    "loadType": "initialization"
+  }
+}
+```
+
+
+### Config
+```config.json```
+```json
+{
+  "WebServer": {
+    "ip": "0.0.0.0",
+    "port": 8080,
+    "timeout": 0
+  },
+  "WebFramework": {
+    "settingsPaths": [
+      "web.json"
+    ],
+    "loadSources": [
+      "hello_executor"
+    ],
+    "assetsPath": "assets",
+    "templatesPath": "templates",
+    "cachingSize": 536870912,
+    "webServerType": "multiThreaded",
+    "HTTPS": {
+      "useHTTPS": false,
+      "pathToCertificate": "certificates/cert.pem",
+      "pathToKey": "certificates/key.pem"
+    },
+    "defaultAssetsPath": "WebFrameworkAssets"
+  },
+  "Logging": {
+    "usingLogging": false,
+    "dateFormat": "DMY",
+    "logFileSize": 134217728
+  },
+  "ThreadPoolServer": {
+    "threadCount": 0
+  }
+}
+```
+
+
+### Run sample
+After running server open url [127.0.0.1:8080](http://127.0.0.1:8080).  
+You will see response from server
+```json
+{
+  "message": "Hello, World!"
+}
+```
+
+
+## Executors
+Executors are C++ classes that responsible for giving responses for their route(url).  
+Source code of HelloExecutor from example  
+```HelloExecutor.h```
+```cpp
+#pragma once
+
+#include "Executors/BaseStatelessExecutor.h"
+
+namespace executors
+{
+	class HelloExecutor : public framework::BaseStatelessExecutor
+	{
+	public:
+		HelloExecutor() = default;
+
+		void doGet(framework::HTTPRequest& request, framework::HTTPResponse& response) override;
+
+		~HelloExecutor() = default;
+	};
+}
+```
+```HelloExecutor.cpp```
+```cpp
+#include "HelloExecutor.h"
+
+#include "JSONBuilder.h"
+
+namespace executors
+{
+	void HelloExecutor::doGet(framework::HTTPRequest& request, framework::HTTPResponse& response)
+	{
+		response.addBody(json::JSONBuilder(CP_UTF8).appendString("message", "Hello, World!"));
+	}
+
+	DECLARE_EXECUTOR(HelloExecutor);
+}
+```
+More information you can find in [wiki](https://github.com/LazyPanda07/WebFramework/wiki/Executors).
+
+
+### Hello executor
+* Links
+  * [Windows](https://github.com/LazyPanda07/WebFramework/releases/download/Assets/windows.zip)
+  * [Linux](https://github.com/LazyPanda07/WebFramework/releases/download/Assets/linux.zip)

web_framework_api-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+web_framework_api/WebFramework.py,sha256=G4KemXk2P8xl66v_zZGQelbSiSBp2u_czGa3qtbgbyk,4895
+web_framework_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+web_framework_api/exceptions/WebFrameworkException.py,sha256=ObFOGfBZmLtzg6TBg5N0iaZRvjW6CZSUpxRhL4lkq20,597
+web_framework_api/utility/Config.py,sha256=bqicvmhqBWLTG2hLCWTGRJTumBHJG59C5fjF8Sqt1Mo,12207
+web_framework_api/utility/DLLHandler.py,sha256=79vZJnebMZxyjXBrlkMtXpOirw59IkH38yzvgSMtrBI,2642
+web_framework_api/utility/Utils.py,sha256=itgwHSyL9HHYe3jZBAr5E3OqIPRkdAoUsdJxxc4zkSA,2986
+web_framework_api-1.0.0.dist-info/METADATA,sha256=8JpDkBi_mwyPhEPtnZeSzX-gB9jDBu558fw-Z0GNwzY,3908
+web_framework_api-1.0.0.dist-info/WHEEL,sha256=fl6v0VwpzfGBVsGtkAkhILUlJxROXbA3HvRL6Fe3140,105
+web_framework_api-1.0.0.dist-info/RECORD,,

web_framework_api-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any