web-framework-api 3.1.0__py3-none-any.whl

web_framework_api/WebFramework.py

@@ -0,0 +1,143 @@
+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
+    """
+
+    @staticmethod
+    def get_web_framework_version() -> str:
+        """
+        Get WebFramework version
+        :return: String representation of version in format {major}.{minor}.{patch}
+        """
+        version = DLLHandler.get_instance().call_function("getWebFrameworkVersion", ctypes.c_char_p)
+
+        return str(version.decode())
+
+    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().delete_web_framework(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().delete_web_framework_exception(self.__implementation)

web_framework_api/utility/Config.py

@@ -0,0 +1,319 @@
+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.delete_web_framework_string(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.delete_web_framework_string(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.delete_web_framework_string(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()
+
+    def __del__(self):
+        DLLHandler.get_instance().delete_web_framework_config(self.implementation)

web_framework_api/utility/DLLHandler.py

@@ -0,0 +1,88 @@
+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) -> "DLLHandler":
+        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 delete_web_framework_string(self, implementation: ctypes.c_void_p):
+        self.call_function("deleteWebFrameworkString", None, ctypes.c_uint64(implementation))
+
+    def delete_web_framework_config(self, implementation: ctypes.c_void_p):
+        self.call_function("deleteWebFrameworkConfig", None, ctypes.c_uint64(implementation))
+
+    def delete_web_framework(self, implementation: ctypes.c_void_p):
+        self.call_function("deleteWebFramework", None, ctypes.c_uint64(implementation))
+
+    def delete_web_framework_exception(self, implementation: ctypes.c_void_p):
+        self.call_function("deleteWebFrameworkException", None, ctypes.c_uint64(implementation))

web_framework_api/utility/Utils.py

@@ -0,0 +1,88 @@
+import os.path
+import shutil
+import sys
+import zipfile
+
+import requests
+
+from tqdm import tqdm
+
+WEB_FRAMEWORK_MAJOR_VERSION = "3"
+WEB_FRAMEWORK_MINOR_VERSION = "1"
+WEB_FRAMEWORK_PATCH_VERSION = "0"
+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, "Release_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, "Release_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/v{WEB_FRAMEWORK_MAJOR_VERSION}.{WEB_FRAMEWORK_MINOR_VERSION}.{WEB_FRAMEWORK_PATCH_VERSION}/windows.zip"
+    else:
+        return f"https://github.com/LazyPanda07/WebFramework/releases/download/v{WEB_FRAMEWORK_MAJOR_VERSION}.{WEB_FRAMEWORK_MINOR_VERSION}.{WEB_FRAMEWORK_PATCH_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-3.1.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.2
+Name: web_framework_api
+Version: 3.1.0
+Summary: Python API for WebFramework
+Keywords: Web
+Author-Email: LazyPanda07 <semengricenko@gmail.com>
+Maintainer-Email: LazyPanda07 <semengricenko@gmail.com>
+License: MIT License
+         
+         Copyright (c) 2020 Semyon Gritsenko
+         
+         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.
+         
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Project-URL: Repository, http://github.com/LazyPanda07/WebFramework
+Project-URL: Wiki, http://github.com/LazyPanda07/WebFramework/wiki
+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/latest/download/hello_executor_windows.zip)
+	* [Linux](https://github.com/LazyPanda07/WebFramework/releases/latest/download/hello_executor_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/latest/download/hello_executor_windows.zip)
+  * [Linux](https://github.com/LazyPanda07/WebFramework/releases/latest/download/hello_executor_linux.zip)

web_framework_api-3.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+web_framework_api/WebFramework.py,sha256=Psw-khF5AL2vK8WXiCtu1eYBoYhysBYksE9GryllDWU,5397
+web_framework_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+web_framework_api/exceptions/WebFrameworkException.py,sha256=8U6_0kRz9FBLivaH88yP6q7kYSkRbkL3CKg5OCKvwp4,641
+web_framework_api/utility/Config.py,sha256=1_KPFzfCvS7UE5-xCIpKyYzKrj_tIMXnp0atTzIskSM,12702
+web_framework_api/utility/DLLHandler.py,sha256=VJJg3cjXKSVEur1j_bGta3BCvo3N-niX_wDy40WXmiQ,3196
+web_framework_api/utility/Utils.py,sha256=UYe8KqUnldwe6w-REzqBnlS6dDUEwsLbjzoS1VBTbMQ,3073
+web_framework_api-3.1.0.dist-info/METADATA,sha256=nEjpRFc527agv8hTLLA-32q6pDx78KlwYh3TPqlgQ6U,5365
+web_framework_api-3.1.0.dist-info/WHEEL,sha256=gxW59xGPYrrbXjuxOwDtUfAuLQzXH6BJZostV-5Lvqc,106
+web_framework_api-3.1.0.dist-info/licenses/license/LICENSE,sha256=2qWVL8xV3683inNKbRMFVlYfedj3s4dGzhpZuPH51kA,1073
+web_framework_api-3.1.0.dist-info/RECORD,,

web_framework_api-3.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: py3-none-linux_x86_64
+

web_framework_api-3.1.0.dist-info/licenses/license/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Semyon Gritsenko
+
+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.