pyechonext package

Subpackages

Submodules

pyechonext.app module

class pyechonext.app.ApplicationType(*values)[source]

Bases: Enum

This enum class describes an application type.

HTML = 'text/html'
JSON = 'application/json'
PLAINTEXT = 'text/plain'
TEAPOT = 'server/teapot'
class pyechonext.app.EchoNext(app_name: str, settings: Settings, middlewares: List[Type[BaseMiddleware]], urls: List[URL] | None = [], application_type: ApplicationType | None = ApplicationType.JSON, static_files: List[StaticFile] | None = [])[source]

Bases: object

This class describes an EchoNext WSGI Application.

__init__(app_name: str, settings: Settings, middlewares: List[Type[BaseMiddleware]], urls: List[URL] | None = [], application_type: ApplicationType | None = ApplicationType.JSON, static_files: List[StaticFile] | None = [])[source]

Initialize a WSGI

Parameters:

  • app_name (str) – application name

  • settings (Settings) – settings of app middlewares (List[Type[BaseMiddleware]]): list of middlewares

  • urls (Optional[List[URL]], optional) – basic URLs list. Defaults to [].

  • application_type (Optional[ApplicationType], optional) – application type. Defaults to ApplicationType.JSON.

  • static_files (Optional[List[StaticFile]], optional) – static files list. Defaults to [].

Raises:

TeapotError – Easter Egg

add_route(page_path: str, handler: Callable | PageController, methods: List[str] | None = None, summary: str | None = None)[source]

Add page route without decorator

Parameters:

  • page_path (str) – page path url

  • handler (Callable) – handler of route

  • methods (Optional[List[str]]) – supported methods of handler. Defaults to None.

  • summary (Optional[str], optional) – summary documentation. Defaults to None.

app_name: str
application_type: ApplicationType
get_and_save_cache_item(key: str, value: Any) → Any[source]

Set and save item to cache

Parameters:

  • key (str) – key

  • value (Any) – value

Returns:

item from cache

Return type:

Any

history: List[HistoryEntry]
include_router(new_router: Router)[source]

Include new router to additional routers list

Parameters:

new_router (Router) – new router object

main_cache: InMemoryCache
middlewares: List[Type[BaseMiddleware]]
route_page(page_path: str, methods: List[str] | None = None, summary: str | None = None) → Callable[source]

Route page decorator

Parameters:

  • page_path (str) – page path url

  • methods (Optional[List[str]]) – supported methods of handler. Defaults to None.

  • summary (Optional[str], optional) – summary documentation. Defaults to None.

Returns:

wrapper

Return type:

Callable

router: Router
settings: Settings
static_files: List[StaticFile]
static_files_manager: StaticFilesManager
test_session(host: str = 'echonext') → Session[source]

Test Session

Parameters:

host (str, optional) – hostname of session. Defaults to “echonext”.

Returns:

request session for tests

Return type:

RequestsSession

urls: List[URL]
class pyechonext.app.HistoryEntry(request: pyechonext.request.Request, response: pyechonext.response.Response)[source]

Bases: object

__init__(request: Request, response: Response) → None
request: Request
response: Response
pyechonext.app.method()

recv(buffersize[, flags]) -> data

Receive up to buffersize bytes from the socket. For the optional flags argument, see the Unix manual. When no data is available, block until at least one byte is available or until the remote end is closed. When the remote end is closed and all data is read, return the empty string.

pyechonext.cache module

class pyechonext.cache.CacheEntry(name: str, value: ~typing.Any, expiry: float, extra_params: dict = <factory>)[source]

Bases: object

This class describes a cache entry.

__init__(name: str, value: ~typing.Any, expiry: float, extra_params: dict = <factory>) → None
expiry: float
extra_params: dict
name: str
value: Any
class pyechonext.cache.Cacheable(cache: InMemoryCache)[source]

Bases: object

This class describes a Interface for caching.

__init__(cache: InMemoryCache)[source]

Initialize Cachable Interace

Args:

cache (InMemoryCache): cache instance

clear_data(key: str)[source]

Clear item data by key

Args:

key (str): item key

save(key: str, data: Any)[source]

Save item in cache

Args:

key (str): item key data (Any): item data

update(key: str, new_data: Any)[source]

Update item by key

Args:

key (str): item key new_data (Any): new item data

class pyechonext.cache.InMemoryCache(timeout: int = 300)[source]

Bases: object

This class describes in memory cache.

__init__(timeout: int = 300)[source]

Initialize InMemoryCace

Args:

timeout (int, optional): _description_. Defaults to 300.

clean_up()[source]

Clean up cache

clear()[source]

Clears all items

get(key: str) → Any | None[source]

Get item by specified key

Args:

key (str): key item

Returns:

Optional[Any]: item value

invalidate(key: str)[source]

Invalidate item by key

Args:

key (str): item key

set(key: str, value: Any, **kwargs)[source]

Set item into cache

Args:

key (str): key value (Any): value

pyechonext.config module

class pyechonext.config.Settings(BASE_DIR: str, TEMPLATES_DIR: str, SECRET_KEY: str = '14486.16035.57675.50643.69546.16035.85036.32515.16035.72836', VERSION: str = '1.0.0', DESCRIPTION: str = 'Echonext webapp', LOCALE: str = 'DEFAULT', LOCALE_DIR: str = None, STATIC_DIR: str = 'static')[source]

Bases: object

This class describes settings.

BASE_DIR: str
DESCRIPTION: str = 'Echonext webapp'
LOCALE: str = 'DEFAULT'
LOCALE_DIR: str = None
SECRET_KEY: str = '14486.16035.57675.50643.69546.16035.85036.32515.16035.72836'
STATIC_DIR: str = 'static'
TEMPLATES_DIR: str
VERSION: str = '1.0.0'
__init__(BASE_DIR: str, TEMPLATES_DIR: str, SECRET_KEY: str = '14486.16035.57675.50643.69546.16035.85036.32515.16035.72836', VERSION: str = '1.0.0', DESCRIPTION: str = 'Echonext webapp', LOCALE: str = 'DEFAULT', LOCALE_DIR: str = None, STATIC_DIR: str = 'static') → None
class pyechonext.config.SettingsConfigType(*values)[source]

Bases: Enum

This class describes a settings configuration type.

DOTENV = 'dotenv'
INI = 'ini'
JSON = 'json'
PYMODULE = 'pymodule'
TOML = 'toml'
YAML = 'yaml'
class pyechonext.config.SettingsLoader(config_type: SettingsConfigType, filename: str = None)[source]

Bases: object

This class describes a settings loader.

__init__(config_type: SettingsConfigType, filename: str = None)[source]

Initialize a basic settings info

Parameters:

  • config_type (SettingsConfigType) – file config type

  • filename (str, optional) – config filename. Defaults to None.

Raises:

FileNotFoundError – _description_

config
config_type: SettingsConfigType
filename: Path
get_settings() → Settings[source]

Get the settings dataclass

Returns:

settings object

Return type:

Settings

pyechonext.config.dynamic_import(module: str)[source]

Dynamic import with importlib

Parameters:

module (str) – module name

Returns:

imported module

Return type:

module

pyechonext.middleware module

class pyechonext.middleware.BaseMiddleware[source]

Bases: ABC

This abstract class describes a base middleware.

abstractmethod process_exception(exception: Exception)[source]

Process exception with middleware

Parameters:

exception (Exception) – exception class

Raises:

exception – exception from arguments

abstractmethod process_template(*args, **kwargs)[source]

Process template with middleware

Raises:

NotImplementedError – abstract method

abstractmethod to_request(request: Request)[source]

Apply actions to request

Parameters:

request (Request) – request object

Raises:

NotImplementedError – abstract method

abstractmethod to_response(response: Response)[source]

Apply actions to response

Parameters:

response (Response) – response object

Raises:

NotImplementedError – abstract method

class pyechonext.middleware.SessionMiddleware[source]

Bases: BaseMiddleware

This class describes a session (cookie) middleware.

process_exception(exception: Exception)[source]

Process exception with middleware

Parameters:

exception (Exception) – exception class

Raises:

exception – exception from arguments

process_template(*args, **kwargs)[source]

Process template with middleware

Raises:

NotImplementedError – abstract method

to_request(request: Request)[source]

Apply cookies to request

Parameters:

request (Request) – request object

to_response(response: Response)[source]

Get session uuid by response

Parameters:

response (Response) – response

pyechonext.permissions module

class pyechonext.permissions.AbstractController(permission_checker: PermissionChecker)[source]

Bases: ABC

This class describes a abstract controller.

abstractmethod __init__(permission_checker: PermissionChecker)[source]

Constructs a new instance

Args:

permission_checker (PermissionChecker): permission checker class

abstractmethod check(current_user: User, resource: Type[Resource], permission: Permission) → bool[source]

Check permissions for user

Args:

current_user (User): user object resource (Resource): resource object permission (Permission): permission object

Raises:

NotImplementedError: abstractmethod

Returns:

bool: true is valid, otherwise false

class pyechonext.permissions.AbstractPermission[source]

Bases: ABC

This class describes an abstract permission.

class pyechonext.permissions.AbstractRole[source]

Bases: ABC

This class describes an abstract role.

abstractmethod get_name() → str[source]

Get the role name

Raises:

NotImplementedError: abstract method

Returns:

str: role name

abstractmethod get_permissions() → Set[AbstractPermission][source]

Get list of permissions

Raises:

NotImplementedError: abstract method

Returns:

Set[AbstractPermission]: set with abstract permissions

abstractmethod has_permission(permission: Type[AbstractPermission]) → bool[source]

Determines if permission

Args:

permission (AbstractPermission): permission object

Raises:

NotImplementedError: abstract method

Returns:

bool: true is has, false otherwise

class pyechonext.permissions.AccessControlRule(role: Type[AbstractRole], permission: Type[AbstractPermission], resource: Type[Resource], allowed: bool)[source]

Bases: object

This class describes an access control rule.

__init__(role: Type[AbstractRole], permission: Type[AbstractPermission], resource: Type[Resource], allowed: bool)[source]

Constructs a new instance

Args:

role (Type[AbstractRole]): role object permission (Type[AbstractPermission]): permission object resource (Type[Resource]): resource object allowed (bool): allowed status

applies_to(user: User, resource: Type[Resource], permission: Type[AbstractPermission]) → bool[source]

Applies to user

Args:

user (User): user resource (Type[Resource]): resource permission (Type[AbstractPermission]): permissions

Returns:

bool: true if is applies, false otherwise

class pyechonext.permissions.AgeRestrictionsABP(conditions: Dict[str, Any], rules: List[AccessControlRule])[source]

Bases: Policy

This class describes an age restrictions abp.

__init__(conditions: Dict[str, Any], rules: List[AccessControlRule])[source]

Initialize a Age Policy

Args:

conditions (Dict[str, Any]): conditions rules (List[AccessControlRule]): rules list

evaluate(user: User, resource: Type[Resource], permission: Type[AbstractPermission]) → bool[source]

Evaluate policy access

Args:

user (User): user object resource (Resource): resource object permission (AbstractPermission): permission object

Returns:

bool: evaluation status

class pyechonext.permissions.AttributeBasedPolicy(conditions: Dict[str, Any])[source]

Bases: Policy

This class describes an attribute based policy.

__init__(conditions: Dict[str, Any])[source]

Constructs a new instance

Args:

conditions (Dict[str, Any]): conditions dictionary

evaluate(user: User, resource: Type[Resource], permission: Type[AbstractPermission]) → bool[source]

Evaluate policy access

Args:

user (User): user model resource (Resource): resource model permission (AbstractPermission): permission model

Returns:

bool: evaluation status

class pyechonext.permissions.DefaultPermissionChecker(policy: Policy)[source]

Bases: PermissionChecker

This class describes a default permission checker.

__init__(policy: Policy)[source]

Initialize a checker

Args:

policy (Policy): policy for checkr

check(user: User, resource: Type[Resource], permission: Type[AbstractPermission]) → bool[source]

Check user permissions

Args:

user (User): user object resource (Resource): resource object permission (AbstractPermission): permissions object

Returns:

bool: true is valid, false otherwise

class pyechonext.permissions.Permission(name: str)[source]

Bases: AbstractPermission

This class describes a permission.

__init__(name: str)[source]

Initialize a permission

Args:

name (str): permission name

class pyechonext.permissions.PermissionChecker[source]

Bases: ABC

This class describes a permission checker.

abstractmethod check(user: User, resource: Type[Resource], permission: Type[AbstractPermission]) → bool[source]

Check permissions for user

Args:

user (User): user object resource (Resource): resource object permission (AbstractPermission): permission object

Raises:

NotImplementedError: abstract method

Returns:

bool: true is valid, false otherwise

class pyechonext.permissions.Policy[source]

Bases: object

This class describes a policy.

__init__()[source]

Constructs a new instance.

add_rule(rule: AccessControlRule)[source]

Add a new rule

Args:

rule (AccessControlRule): new rule

evaluate(user: User, resource: Type[Resource], permission: Type[AbstractPermission]) → bool[source]

Evaluate policty access

Args:

user (User): user object resource (Resource): resource permission (AbstractPermission): permission

Returns:

bool: true is allowed, false otherwise

class pyechonext.permissions.Resource(name: str)[source]

Bases: object

This class describes a resource.

__init__(name: str)[source]

Constructs a new resource

Args:

name (str): resource name

class pyechonext.permissions.Role(name: str)[source]

Bases: AbstractRole

This class describes a role.

__init__(name: str)[source]

Constructs a new instance

Args:

name (str): role name

add_permission(permission: AbstractPermission)[source]

Add a permission

Args:

permission (AbstractPermission): permission object

get_name() → str[source]

Get the role name

Returns:

str: role name

get_permissions() → Set[AbstractPermission][source]

Get list of permissions

Returns:

Set[AbstractPermission]: set with abstract permissions

has_permission(permission: AbstractPermission) → bool[source]

Determines if permission

Args:

permission (AbstractPermission): permission object

bool: true is has, false otherwise

remove_permission(permission: AbstractPermission)[source]

Remove a permission

Args:

permission (AbstractPermission): permission object

class pyechonext.permissions.User(username: str, attributes: Dict[str, Any] = {})[source]

Bases: object

This class describes an user.

__init__(username: str, attributes: Dict[str, Any] = {})[source]

Constructs a new instance

Args:

username (str): name of user attributes (Dict[str, Any], optional): attributes for user. Defaults to {}.

add_role(role: AbstractRole)[source]

Adds a role

Args:

role (AbstractRole): role object

get_roles() → Set[AbstractRole][source]

Get roles

Returns:

Set[AbstractRole]: roles set

get_username() → str[source]

Get username

Returns:

str: username

has_permission(permission: AbstractPermission) → bool[source]

Determines if permission

Args:

permission (Type[AbstractPermission]): permission object

Returns:

bool: true is has, false otherwise

remove_role(role: AbstractRole)[source]

Remove a role

Args:

role (Type[AbstractRole]): role object

class pyechonext.permissions.UserController(permission_checker: PermissionChecker)[source]

Bases: AbstractController

Controls the data flow into an user object and updates the view whenever data changes.

__init__(permission_checker: PermissionChecker)[source]

Constructs a new instance

Args:

permission_checker (PermissionChecker): permission checker class

check(current_user: User, resource: Type[Resource], permission: Permission) → bool[source]

Check permissions for user

Args:

current_user (User): current user object resource (Resource): resource object permission (Permission): user permission

Returns:

bool: True is valid, false otherwise

edit_users(current_user: User, resource: Type[Resource]) → Tuple[str][source]

Edit users with current user and resource

Args:

current_user (User): user object resource (Resource): resource object

Returns:

Tuple[str]: data

view_users(current_user: User, resource: Type[Resource]) → Tuple[str][source]

View users by current user and resource

Args:

current_user (User): current user object resource (Resource): resource object

Returns:

Tuple[str]: data

pyechonext.request module

class pyechonext.request.Request(environ: dict = {}, settings: Settings = None)[source]

Bases: object

This class describes a request.

GET: Dict[Any, Any]
POST: Dict[Any, Any]
__init__(environ: dict = {}, settings: Settings = None)[source]

Constructs a new request

Args:

environ (dict, optional): environ info. Defaults to {}. settings (Settings, optional): settings of app. Defaults to None.

environ: Dict[str, Any]
extra: Dict[Any, Any]
method: str
path: str
settings: Settings
user_agent: str

pyechonext.response module

class pyechonext.response.Response(request: Request = None, status_code: int | None = 200, body: str | Dict | None = None, headers=None, content_type: str | None = None, charset: str | None = None)[source]

Bases: object

This dataclass describes a response.

__init__(request: Request = None, status_code: int | None = 200, body: str | Dict | None = None, headers=None, content_type: str | None = None, charset: str | None = None)[source]

Initialize new response

Parameters:

  • request (Request, optional) – request object. Defaults to None.

  • use_i18n (bool, optional) – i18n using status. Defaults to False.

  • status_code (Optional[int], optional) – default status code. Defaults to 200.

  • body (Optional[str], optional) – response body. Defaults to None.

  • headers (Optional[Dict[str, str]], optional) – http headers. Defaults to {}.

  • content_type (Optional[str], optional) – content type. Defaults to None.

  • charset (Optional[str], optional) – charset. Defaults to None.

  • i18n_params (Optional[dict], optional) – params for i18n. Defaults to {}.

add_headers(headers: List[Tuple[str, str]])[source]

Adds new headers

Parameters:

headers (List[Tuple[str, str]]) – new headers

body: str
charset: str
content_type: str
default_body_encoding: str = 'UTF-8'
default_charset: str = 'UTF-8'
default_conditional_response: bool = False
default_content_type: str = 'text/html'
extra: Dict[Any, Any]
headers
property json: str | dict[Any, Any]

Get response body as JSON

Returns:

_description_

Return type:

dict

request: Request
status_code: str
unicode_errors: str = 'strict'
pyechonext.response.method()

recv(buffersize[, flags]) -> data

Receive up to buffersize bytes from the socket. For the optional flags argument, see the Unix manual. When no data is available, block until at least one byte is available or until the remote end is closed. When the remote end is closed and all data is read, return the empty string.

pyechonext.static module

class pyechonext.static.StaticFile(settings: Settings, filename: str, update_timeout: int | None = 3600, precache: bool | None = False)[source]

Bases: object

This class describes a static file.

__init__(settings: Settings, filename: str, update_timeout: int | None = 3600, precache: bool | None = False)[source]

Constructs a Static File

Parameters:

  • settings (Settings) – settings of webapp.

  • filename (str, optional) – static filename without static dir.

  • update_timeout (int, optional) – timeout to update inmemory-cache file content. Defaults to 3600.

  • precache (bool, optional) – preload a file content flag. Defaults to False.

Raises:

StaticFileNotFoundError – static file at static dir not found

caching_static_file()[source]

Set and save static file to cache

get_content_type() → str[source]

Get content type

Returns:

get mimetype

Return type:

str

get_file_size() → int[source]

Get file size

Returns:

file st size

Return type:

int

class pyechonext.static.StaticFilesManager(static_files: List[StaticFile])[source]

Bases: object

This class describes a static files manager.

__init__(static_files: List[StaticFile])[source]

Initialize manager

Parameters:

static_files (List[StaticFile]) – list of static files.

get_file_size(url: str) → int | None[source]

Get file size

Parameters:

url (str) – url of static page

Returns:

file size

Return type:

int | None

get_file_type(url: str) → str | None[source]

Get file content type

Parameters:

url (str) – static file url

Returns:

content type

Return type:

str | None

serve_static_file(url: str) → str | bool[source]

Serve static files

Parameters:

url (str) – URL for serving

Returns:

static file content or False if static file not found

Return type:

str | bool

pyechonext.urls module

class pyechonext.urls.URL(path: str, controller: PageController | type, summary: str | None = None)[source]

Bases: object

This dataclass describes an url.

__init__(path: str, controller: PageController | type, summary: str | None = None) → None
controller: PageController | type
path: str
summary: str | None = None

Module contents

EchoNext is a lightweight, fast and scalable web framework for Python Copyright (C) 2024 Alexeev Bronislav (C) 2024

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

pyechonext.check_for_update()[source]

Check for update in pypi