wasp_general.network.web package

Submodules

wasp_general.network.web.cookies module

class wasp_general.network.web.cookies.WHTTPCookie(name, value, **attrs)

Bases: object

This class represent a single HTTP Cookie as it is described in RFC 6265. Call WHTTPCookie.ro() method to create unchangeable cookie copy

attr(attr_name, attr_value=None)

Return attribute value. Attribute value can be updated with this method. In order to update attribute value attr_value must be set. Cookie attribute value couldn’t be changed if cookie is in read-only mode (RuntimeError exception is raised).

Parameters:

• attr_name – target attribute name
• attr_value – new value to set

Returns:

str

attrs_as_dict()

Return cookie attributes as dictionary, where keys are attribute names and values are their values

Returns:dict

static cookie_attr_value_check(attr_name, attr_value)

Check cookie attribute value for validity. Return True if value is valid

Parameters:

• attr_name – attribute name to check
• attr_value – attribute value to check

Returns:

bool

cookie_attr_value_compliance = {'secure': re.compile('.*'), 'httponly': re.compile('.*'), 'domain': re.compile('[a-zA-Z\\-.0-9]+'), 'path': re.compile('/[a-zA-Z0-9_\\-.~%:/?#\\[\\]@!$&\'()*+,;="]*'), 'expires': re.compile('[a-zA-Z0-9 ,:-]+'), 'max-age': re.compile('[1-9][0-9]*')}

Dictionary of valid attribute names and appropriate values regexp

static cookie_name_check(cookie_name)

Check cookie name for validity. Return True if name is valid

Parameters:cookie_name – name to check Returns:bool

cookie_name_non_compliance_re = re.compile(b'.*[\x00-\x1e\x7f()<>@,;:\\\\"/\\[\\]?={} \t].*')

Check for non-acceptable cookie name

see RFC 6265, Section 4.1.1

static cookie_value_check(cookie_value)

Check cookie value for validity. Return True if value is valid

Parameters:cookie_value – value to check Returns:bool

cookie_value_non_compliance_re = re.compile(b'.*[\x00-\x1e\x7f ",;\\\\].*')

Check for non-acceptable cookie value

see RFC 6265, Section 4.1.1

copy()

Return copy

Returns:WHTTPCookie

name()

Return cookie name

Returns:str

remove_attr(attr_name)

Remove cookie attribute. Cookie attribute couldn’t be removed if cookie is in read-only mode (RuntimeError exception is raised).

Parameters:attr_name – name of attribute to remove Returns:None

ro()

Return read-only copy

Returns:WHTTPCookie

value(new_value=None)

Return cookie value. Cookie value can be updated, when new_value is not None. Cookie value couldn’t be changed if cookie is in read-only mode (RuntimeError exception is raised).

Parameters:new_value – new value to set Returns:str

class wasp_general.network.web.cookies.WHTTPCookieJar

Bases: object

Class represent collection of cookies. Call WHTTPCookieJar.ro() method to create read-only copy (in this state no changes are allowed)

add_cookie(cookie)

Add new cookie (or replace if there is cookie with the same name already)

Parameters:cookie – cookie to add Returns:None

cookies()

Return available cookie names

Returns:tuple of str

classmethod import_header_text(cookie_text)

Create cookie jar from HTTP Header text like ‘Set-Cookie: cookie=value’

Parameters:cookie_text – http header code Returns:WHTTPCookieJar

classmethod import_simple_cookie(simple_cookie)

Create cookie jar from SimpleCookie object

Parameters:simple_cookie – cookies to import Returns:WHTTPCookieJar

remove_cookie(cookie_name)

Remove cookie by its name

Parameters:cookie_name – cookie name Returns:

ro()

Return read-only copy

Returns:WHTTPCookieJar

wasp_general.network.web.debug module

class wasp_general.network.web.debug.WWebDebugInfo

Bases: object

This is API prototype for web-service debugging process

exception(session_id, exc)

Dump raised exception (may be called more then once)

Parameters:

• session_id – session origin
• exc – raised exception

Returns:

None

finalize(session_id)

Client session finalization. This method is called whenever exceptions were risen or not

Parameters:session_id – session origin Returns:None

request(session_id, request, protocol_version, protocol)

Dump client request

Parameters:

• session_id – session origin
• request – client request
• protocol_version – client protocol version (like 0.9/1.0/1.1/2)
• protocol – client protocol (like http/https)

Returns:

None

response(session_id, response)

Dump server response to client

Parameters:

• session_id – session origin
• response – server response

Returns:

None

session_id()

Create new token, that is used for session identification

Returns:any type

target_route(session_id, target_route)

Dump target route

Parameters:

• session_id – session origin
• target_route – target route

Returns:

None

wasp_general.network.web.headers module

class wasp_general.network.web.headers.WHTTPHeaders(**kwargs)

Bases: object

Represent HTTP Headers as they are described in RFC 1945. Call WHTTPHeaders.ro() method to create read-only copy (in this state no changes are allowed)

Cookies that are stored with WHTTPHeaders.set_cookie_jar() method have highest priority than cookies stored within constructor and/or WHTTPHeaders.add_header(). So in the conflict situation cookies saved within WHTTPHeaders.set_cookie_jar() must be used.

Cookies that are stored in WHTTPHeaders.client_cookie_jar() are client cookies (i.e. read-only cookies).

add_headers(header_name, value, *values)

Add new header

Parameters:

• header_name – name of the header to add
• value – header value
• values – additional header values (in a result request/response must be concatenated by the coma or by the separate header string)

Returns:

None

client_cookie_jar()

Return internal cookie jar that must be used as HTTP-request cookies

see WHTTPCookieJar

Returns:WHTTPCookieJar

content_type(value=None)

Set (replace) and or get “Content-Type” header value

Parameters:value – value to set (if specified) Returns:None if header doesn’t exist, otherwise - str

get_headers(header_name)

Return header value by its name

Parameters:header_name – header name Returns:tuple of str

static header_name_check(header_name)

Check header name for validity. Return True if name is valid

Parameters:header_name – name to check Returns:bool

header_name_re = re.compile(b'[^\x00-\x1e\x7f()<>@,;:\\\\"/\\[\\]?={} \t]+')

Regexp is for HTTP header name checking

headers()

Get specified header names

Returns:tuple of str

classmethod import_headers(http_code)

Create WHTTPHeaders by the given code. If code has ‘Set-Cookie’ headers, that headers are parsed, data are stored in internal cookie jar. At the end of parsing ‘Set-Cookie’ headers are removed from the result

Parameters:http_code – HTTP code to parse Returns:WHTTPHeaders

normalize_name(header_name)

Return header name as it is recommended (required) by corresponding http protocol. For protocol switching use WHTTPHeaders.switch_name_style() method.

All current available protocols (0.9-2) compare header names in a case-insensitive fashion. However, previous protocol versions (0.9-1.1) recommends to use camel-case names like Foo or Foo-Bar. But HTTP/2 (RFC 7540) strictly requires lowercase only header names.

Parameters:header_name – name to convert Returns:str

remove_headers(header_name)

Remove header by its name

Parameters:header_name – name of header to remove Returns:None

replace_headers(header_name, value, *values)

Replace header value with specified value and/or values

Parameters:

• header_name – target header
• value – new header value
• values – additional header values (in a result request/response must be concatenated by the coma or by the separate header string)

Returns:

None

ro()

Return read-only copy of this object

Returns:WHTTPHeaders

set_cookie_jar()

Return internal cookie jar that must be used for HTTP-response

see WHTTPCookieJar

Returns:WHTTPCookieJar

switch_name_style(http_protocol_version)

Return object copy with header names saved as it is described in the given protocol version

see WHTTPHeaders.normalize_name()

Parameters:http_protocol_version – target HTTP protocol version Returns:WHTTPHeaders

wasp_general.network.web.proto module

class wasp_general.network.web.proto.WWebErrorPresenter(request)

Bases: wasp_general.network.web.proto.WWebPresenter

Presenter which is used for displaying standard HTTP-errors and internal exceptions

error_code(code)

Return response for the given HTTP-code

Parameters:code – HTTP-code of error Returns:WWebResponseProto

exception_error(exception)

Return response for the given exception

Parameters:exception – raised exception to process and or display Returns:WWebResponseProto

class wasp_general.network.web.proto.WWebPresenter(request)

Bases: object

Class represent worker that generates response over specified request. WWebTargetRouteProto defines what exactly method will be called and with what arguments.

see WWebTargetRouteProto see WWebRouteMapProto

class wasp_general.network.web.proto.WWebPresenterCollectionProto

Bases: object

Represent collection of presenters

see WWebPresenter

has(presenter_name)

Return if there is a presenter with the given name

Parameters:presenter_name – name of presenter Returns:bool

presenter(presenter_name)

Return presenter by its name

Parameters:presenter_name – name of presenter class Returns:type (WWebPresenter sublcass) or None (if there is no such presenter)

class wasp_general.network.web.proto.WWebPresenterFactoryProto

Bases: object

This class is used for presenter object instantiation. Different presenter classes may have different constructor and so may require different arguments, so this class implementation will be possible to instantiate limited presenter classes. Because of that, this class is tightly connected with specific WWebServiceProto implementation, which uses this class for creating presenter

instantiable(presenter_class)

Check if this factory can produce the specified presenter

Parameters:presenter_class – target presenter class Returns:bool

instantiate(presenter_class, *args, **kwargs)

Create new presenter object. Different implementation may have different required arguments

Parameters:

• presenter_class – presenter class to instantiate
• args – instantiation arguments (may vary)
• kwargs – instantiation arguments (may vary)

Returns:

WWebPresenter

class wasp_general.network.web.proto.WWebRequestProto

Bases: object

Class represent client HTTP-request

content_type()

Return request content_type (“Content-Type” header value)

Returns:None or str

get_vars()

Parse request path and return GET-vars

Returns:None or dictionary of names and tuples of values

get_vars_re = re.compile("\\?([a-zA-Z0-9\\-._~%!$&'()*+,;=:@/?]+)(#[a-zA-Z0-9\\-._~%!$&'()*+,;=:@/?]*)?$")

Regular expression that is used for GET-vars parsing

headers()

Return request headers

Returns:None or WHTTPHeaders

method()

Return request method (like POST/GET/…)

Returns:str

path()

Return request path (like /foo/bar/index.html)

Returns:str

post_vars()

Parse request payload and return POST-vars

Returns:None or dictionary of names and tuples of values

post_vars_re = re.compile("([a-zA-Z0-9\\-._~%!$&'()*+,;=:@/?]+)")

Regular expression that is used for POST-vars parsing

request_data()

Return request payload

Returns:None or bytes

session()

Return current session with which request is created

Returns:WWebSessionProto

virtual_host()

Return request virtual host (“Host” header value)

Returns:None or str

class wasp_general.network.web.proto.WWebResponseProto

Bases: object

Class represent server response for client HTTP-request

headers()

Return headers to set in response.

Returns:None if no headers is needed to be written or WHTTPHeaders

response_data()

Return response payload

Returns:None if not required or bytes

status()

Return response status code. Is required for 1.0 protocol and beyond. It must be avoid in HTTP/0.9

Returns:None or int

class wasp_general.network.web.proto.WWebRouteMapProto

Bases: object

Represent collection of routes

error_presenter()

Return presenter that is used for error handling

Returns:WWebErrorPresenter

route(request, service)

Return the first route that matches client request

Parameters:

• request – client request
• service – source service

Returns:

None if no route is found, WWebTargetRouteProto otherwise

target_route_valid(target_route)

Check target route for execution. This method is used for omitting special methods (actions) from being executed

Parameters:target_route – route to check Returns:bool

class wasp_general.network.web.proto.WWebServiceProto

Bases: object

Represent service that unites wasp-general web-functionality

execute(request, target_route)

Execute given target route and return response

Parameters:

• request – client request
• target_route – route to execute

Returns:

WWebResponseProto

presenter_collection()

Return service presenter collection

Returns:WWebPresenterCollection

presenter_factory()

Return current presenter factory

Returns:WWebPresenterFactoryProto

route_map()

Return service route map

Returns:WWebRouteMapProto

class wasp_general.network.web.proto.WWebSessionProto

Bases: object

Represent client session. For HTTP/0.9-1.0 every request creates new session. For HTTP/1.1 request can be joined in a single session if “Connection” header is used. For HTTP/2 protocol there can be single session for every client

client_address()

Return client IP-address and port

Returns:WIPV4SocketInfo

protocol()

Return currently used protocol

Returns:str (one of “http”/”https”)

protocol_version()

Return currently used protocol version

Returns:str (one of “0.9”/”1.0”/”1.1”/”2”)

read_request()

Read next request from session

Returns:WWebRequestProto

server_address()

Return server IP-address and port to which client is connected

Returns:WIPV4SocketInfo

session_close()

Close session

Returns:None

write_response(request, response)

Write response to client

Parameters:

• request – original client request
• response – response to write

Returns:

class wasp_general.network.web.proto.WWebTargetRouteProto

Bases: object

Represent single route that matches client request

presenter_action()

Return method name to be called

Returns:str

presenter_args()

Return arguments to be used with presenter method

Returns:dict, where keys - are argument names and values - argument values (any type)

presenter_name()

Return presenter name to be used

Returns:WWebPresenter

wasp_general.network.web.re_statements module

wasp_general.network.web.re_statements.http_cookie_domain = '[a-zA-Z\\-.0-9]+'

Represent valid Domain attribute value of cookie

see RFC 6265, Section 5.2.3 external usage: WHTTPCookie

wasp_general.network.web.re_statements.http_cookie_expires = '[a-zA-Z0-9 ,:-]+'

Represent valid Expires attribute value of cookie

see RFC 6265, Section 5.2.1 external usage: WHTTPCookie

wasp_general.network.web.re_statements.http_cookie_httponly = '.*'

Represent valid HttpOnly attribute value of cookie

see RFC 6265, Section 5.2.6 external usage: WHTTPCookie

wasp_general.network.web.re_statements.http_cookie_max_age = '[1-9][0-9]*'

Represent valid Max-Age attribute value of cookie

see RFC 6265, Section 5.2.2 external usage: WHTTPCookie

wasp_general.network.web.re_statements.http_cookie_secure = '.*'

Represent valid Secure attribute value of cookie

see RFC 6265, Section 5.2.5 external usage: WHTTPCookie

wasp_general.network.web.re_statements.http_get_vars_selection = "\\?([a-zA-Z0-9\\-._~%!$&'()*+,;=:@/?]+)(#[a-zA-Z0-9\\-._~%!$&'()*+,;=:@/?]*)?$"

Allow to select variables (GET-variables) and fragment code from URI

see RFC 2616, Section 3.4 external usage: WWebRequestProto

wasp_general.network.web.re_statements.http_header_name = b'[^\x00-\x1e\x7f()<>@,;:\\\\"/\\[\\]?={} \t]+'

Represent valid HTTP header name.

see RFC 1945, Section 4.2 external usage: WHTTPHeaders

wasp_general.network.web.re_statements.http_method_name = 'GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE'

Represent valid HTTP method. This regexp has as strict restriction as HTTP/2 (RFC 7231) does.

see RFC 1945, Section 5.1.1. RFC 2616, Section 5.1.1, RFC 7231, Section 4.1

external usage: WWebRequest

wasp_general.network.web.re_statements.http_path = '/[a-zA-Z0-9_\\-.~%:/?#\\[\\]@!$&\'()*+,;="]*'

Represent valid requested URI

for URI see RFC 3986, Section 3 external usage: WWebRequest, WHTTPCookie

wasp_general.network.web.re_statements.http_path_alphabet = 'a-zA-Z0-9_\\-.~%:/?#\\[\\]@!$&\'()*+,;="'

Represent valid set of chars, that URI can have

for URI see RFC 3986, Section 3

wasp_general.network.web.re_statements.http_post_vars_selection = "([a-zA-Z0-9\\-._~%!$&'()*+,;=:@/?]+)"

Allow to select variables that are given as ‘application/x-www-form-urlencoded’.

see RFC 1867 external usage: WWebRequestProto

wasp_general.network.web.re_statements.http_version = '0\\.9|1\\.0|1\\.1'

Represent valid requested HTTP-versions

see RFC 2616, Section 3.1

wasp_general.network.web.re_statements.uri_fragment_alphabet = "a-zA-Z0-9\\-._~%!$&'()*+,;=:@/?"

Represent valid set of chars, that fragment can have it in URI

see RFC 2616, Section 3.1

wasp_general.network.web.re_statements.uri_query_alphabet = "a-zA-Z0-9\\-._~%!$&'()*+,;=:@/?"

Represent valid set of chars, that query can have it in URI

see RFC 2616, Section 3.1

wasp_general.network.web.re_statements.wasp_presenter_name_alphabet = 'a-zA-Z0-9_.\\-'

Represent valid set of chars, that presenter name can have

wasp_general.network.web.re_statements.wasp_presenter_name_selection = '([a-zA-Z][a-zA-Z0-9_.\\-]*)'

Allow to select presenter name

wasp_general.network.web.re_statements.wasp_route_arg_name = '[a-zA-Z][a-zA-Z0-9_]*'

Represent valid name for route argument name

external usage: WWebRouteMap

wasp_general.network.web.re_statements.wasp_route_arg_name_selection = '\\{([a-zA-Z][a-zA-Z0-9_]*)\\}'

Represent simple route argument pattern

external usage: WWebRoute.BasicArgSearch

wasp_general.network.web.re_statements.wasp_route_arg_value_selection = '([a-zA-Z0-9_\\-.~%:\\[\\]@!$&\'()*+;="]+)'

Allow to select route argument from a requested URI

external usage: WWebRoute.BasicArgSearch

wasp_general.network.web.re_statements.wasp_route_custom_arg_selection = '(\\{([a-zA-Z][a-zA-Z0-9_]*) *: *"([^"]+)"\\})'

Allow to select custom route argument name and argument pattern from URI pattern

external usage: WWebRoute.CustomArgSearch

wasp_general.network.web.re_statements.wasp_route_custom_arg_value_pattern = '[^"]'

Represent custom route argument pattern

wasp_general.network.web.re_statements.wasp_route_import_pattern = '^\\s*([a-zA-Z0-9_\\-.~%:/?#\\[\\]@!$&\'()*+,;="\\{\\}\\\\]+) +=> +([a-zA-Z][a-zA-Z0-9_.\\-]*)( +\\((.*)\\))?\\s*$'

Allow to parse custom route from a imported text

external usage: WWebRouteMap

wasp_general.network.web.re_statements.wasp_route_uri_pattern_alphabet = 'a-zA-Z0-9_\\-.~%:/?#\\[\\]@!$&\'()*+,;="\\{\\}\\\\'

Represent valid set of chars, that route URI pattern can have

wasp_general.network.web.request module

class wasp_general.network.web.request.WWebRequest(session, method, path, headers=None, request_data=None)

Bases: wasp_general.network.web.proto.WWebRequestProto

WWebRequestProto implementation. Class represent HTTP-request descriptor. Call WWebRequest.ro() method to create unchangeable copy

headers()

Return request headers

Returns:WHTTPHeaders

method()

Return requested method

Returns:str

parse_headers(http_code)

Parse http-code (like ‘Header-X: foo Header-Y: bar ‘) and retrieve (save) HTTP-headers

param http_code:  code to parse return:None

classmethod parse_request_line(session, request_line)

Parse given request line like ‘GET /foo’ or ‘POST /zzz HTTP/1.0’

Parameters:

• session – origin session
• request_line – line to parse

Returns:

WWebRequest

path()

Return requested path

Returns:str

request_data()

Return request data

Returns:bytes

request_line_re = re.compile('^(GET|HEAD|POST|PUT|DELETE|CONNECT|OPTIONS|TRACE) +(/[a-zA-Z0-9_\\-.~%:/?#\\[\\]@!$&\'()*+,;="]*)( +HTTP/(0\\.9|1\\.0|1\\.1))?$')

Check for HTTP request line. See RFC 2616, Section 5.1

ro()

Create read-only copy

Returns:WWebRequest

session()

Return origin session

Returns:WWebSessionProto

set_headers(headers)

Set headers for request

Parameters:headers – headers to set Returns:None

set_request_data(request_data)

Set payload data for request

Parameters:request_data – data to set Returns:None

wasp_general.network.web.response module

class wasp_general.network.web.response.WWebResponse(status=None, headers=None, response_data=None)

Bases: wasp_general.network.web.proto.WWebResponseProto

Simple WWebResponseProto implementation

headers()

WWebResponseProto.headers() method implementation

response_data()

WWebResponseProto.response_data() method implementation

status()

WWebResponseProto.status() method implementation

wasp_general.network.web.service module

class wasp_general.network.web.service.WSimpleErrorPresenter(request)

Bases: wasp_general.network.web.proto.WWebErrorPresenter

Simple WWebErrorPresenter implementation

error_code(code)

WWebErrorPresenter.error_code() method implementation

exception_error(exception)

WWebErrorPresenter.exception_error() method implementation

class wasp_general.network.web.service.WSimplePresenterCollection

Bases: wasp_general.network.web.proto.WWebPresenterCollectionProto

This is a simple presenter collection

WWebPresenterCollectionProto implementation

add(presenter)

Add presenter to this collection

Parameters:presenter – presenter to add Returns:None

has(presenter_name)

WWebPresenterCollectionProto.has() method implementation

presenter(presenter_name)

WWebPresenterCollectionProto.presenter() method implementation

class wasp_general.network.web.service.WWebEnhancedPresenter(request, target_route, service)

Bases: wasp_general.network.web.proto.WWebPresenter

This is enhanced version of presenter. Besides WWebPresenter class. This class objects could use an origin service instance and an origin target route

class wasp_general.network.web.service.WWebPresenterFactory

Bases: wasp_general.network.web.proto.WWebPresenterFactoryProto

WWebPresenterFactoryProto implementation. Can construct classes that do not have their own constructor and are derived from WWebPresenter or from WWebEnhancedPresenter classes

static enhanced_presenter_constructor(presenter_class, request, target_route, service)

Function that is used for WWebEnhancedPresenter creating

Parameters:

• presenter_class – class to construct
• request – original client request
• target_route – target route to execute
• service – source (parent) service

Returns:

WWebEnhancedPresenter

instantiable(presenter_class)

WWebPresenterFactoryProto.instantiable() method implementation.

Checks if class doesn’t have its own constructor and is derived from WWebPresenter or from WWebEnhancedPresenter

Parameters:presenter_class – class to check Returns:bool

instantiate(presenter_class, request, target_route, service, *args, **kwargs)

WWebPresenterFactoryProto.instantiate() method implementation.

Construct new presenter or raise en exception if it isn’t possible.

Parameters:

• presenter_class – class to construct
• request – original client request
• target_route – target route to execute
• service – source (parent) service
• args – additional parameters (do not used)
• kwargs – additional parameters (do not used)

Returns:

WWebPresenter

static presenter_constructor(presenter_class, request, target_route, service)

Function that is used for WWebPresenter creating

Parameters:

• presenter_class – class to construct
• request – original client request
• target_route – target route to execute
• service – source (parent) service

Returns:

WWebPresenter

class wasp_general.network.web.service.WWebRoute(pattern, presenter, **kwargs)

Bases: object

Class is used for single route description. It helps to match single request to corresponding presenter (WWebPresenter). Every route is described by a single pattern (that later compiles to regular expression). Pattern may define different route arguments. There is a way to define default arguments with default values, this is done by passing arguments in object constructor. Every route argument (except special arguments) will be provided to the related presenter action via WWebTargetRoute class.

Every special argument can be defined in a object constructor, but there is a single special argument (‘action’) that can be defined in pattern also. Special arguments usage: - ‘action’: redefines presenter action. Default value is ‘index’ - ‘virtual_hosts’: is used for request matching. If defined, there must be ‘Host’ header in client request, which equals hostname saved in ‘virtual_hosts’. Hostnames are case-insensitive. Default value is None which is matched to any hostname - ‘protocols’: defines protocol for client request matching. Suitable protocols are ‘http’ or ‘https’. Default value contains both protocols. - ‘ports’: list/tuple/set of ports client is connected to. Default value is None, which is matched to any port - ‘methods’: available client methods like GET, POST, HEAD. Method name is case-sensitive. Default value allow to use GET and POST methods

class ArgSearch

Bases: object

Class for internal usage only. It is used for route argument searching from the given pattern and later pattern preparation

args()

Return arguments, that were found inside the given pattern. Each argument is a tuple of argument name and argument position index inside the origin pattern.

Returns:tuple of (str, int)

reduce_pattern()

Return functor that accept single parameter, which is a pattern to prepare. Pattern preparation is a process which replace argument specification with regular expression substring, regular expression that is used for determine argument value.

Returns:function or lambda

class BasicArgSearch(pattern)

Bases: wasp_general.network.web.service.ArgSearch

This is a simple route argument search, that is looking for simple pattern “{<argument_name>}”. In the prepared patter this argument specification will be replaced with “(w+)” statement

arg_re = re.compile('\\{([a-zA-Z][a-zA-Z0-9_]*)\\}')

Argument name pattern

args()

WWebRoute.ArgSearch.args() implementation

reduce_pattern()

WWebRoute.ArgSearch.reduce_pattern() implementation

class CustomArgSearch(arg_name, arg_pos, arg_spec, arg_custom_re_text)

Bases: wasp_general.network.web.service.ArgSearch

This is more complex argument search than WWebRoute.BasicArgSearch. This class provides an ability to control target argument regular expression. Instead of using simple regexp like WWebRoute.BasicArgSearch does (WWebRoute.BasicArgSearch uses ‘(w+)’), this class will search for a special statements that describe and argument name and corresponding regexp. Statements obey the following format “{<argument_name>:”<regular_expression>”}”.

args()

WWebRoute.ArgSearch.args() implementation

classmethod custom(pattern)

Parse the given pattern for arguments and iterate over results (WWebRoute.CustomArgSearch is yielded)

Parameters:pattern – pattern for search Returns:None

custom_arg_re = re.compile('(\\{([a-zA-Z][a-zA-Z0-9_]*) *: *"([^"]+)"\\})')

Argument name pattern

reduce_pattern()

WWebRoute.ArgSearch.reduce_pattern() implementation

match(request, service)

Check this route for matching the given request. If this route is matched, then target route is returned.

Parameters:

• request – request to match
• service – source service

Returns:

WWebTargetRoute or None

multiple_slashes_re = re.compile('//+')

Regexp for removing extra slashes

classmethod normalize_uri(uri)

Normalize the given URI (removes extra slashes)

Parameters:uri – uri to normalize Returns:str

pattern_parentheses_removing_nested_re = re.compile('(\\([^()]*\\([^()]*\\)[^()]*\\([^()]*\\)[^()]*\\))')

Regexp for removing internal nested parentheses

pattern_parentheses_removing_re = re.compile('(\\([^()]*\\([^()]*\\)[^()]*\\))')

Regexp for removing internal parentheses

pattern_recombination_re = re.compile('(\\([^()]*\\))')

Regexp for source argument compilation

url_for(**kwargs)

Generate url for client with specified route arguments. For the source route ‘/page/{page_index}’ this method must be called with ‘page_index’ parameter (for ‘3’ as ‘page_index’ parameter result will be ‘/page/3’ for ‘foo_bar’ - ‘/page/foo_bar’). If ‘host’, ‘protocol’ and ‘ports’ are set as single element list or they are passed as method parameters, then absolute link is generated as a result.

Every parameter in the source pattern must be defined. They can be defined as this method parameters or in a constructor. If source pattern has more arguments than it can be resolved, then exception will be raised

Parameters:kwargs – route arguments to use Returns:str

class wasp_general.network.web.service.WWebRouteMap

Bases: wasp_general.network.web.proto.WWebRouteMapProto

This class represent collection of routes. It has methods for linking a source pattern to th corresponding presenter. There is WWebRouteMap.route() method that allow to search for a target route by the given client request.

WWebRouteMapProto implementation

append(route)

Append route to collection

Parameters:route – route to add Returns:None

connect(pattern, presenter, **kwargs)

Connect the given pattern with the given presenter

Parameters:

• pattern – URI pattern
• presenter – target presenter name
• kwargs – route arguments (see WWebRoute)

Returns:

None

error_presenter()

WWebRouteMapProto.error_presenter() method implementation

import_route(route_as_txt)

Import route written as a string

Parameters:route_as_txt – single string (single route) to import Returns:None

import_route_arg_re = re.compile('^\\s*([a-zA-Z][a-zA-Z0-9_]*)(\\s*=\\s*(([a-zA-Z0-9_\\-.~%:\\[\\]@!$&\'()*+;="]+)))?\\s*$')

Regexp for attribute parsing of imported text

import_route_re = re.compile('^\\s*([a-zA-Z0-9_\\-.~%:/?#\\[\\]@!$&\'()*+,;="\\{\\}\\\\]+) +=> +([a-zA-Z][a-zA-Z0-9_.\\-]*)( +\\((.*)\\))?\\s*$')

Regexp for text parsing and custom routes importing

route(request, service)

WWebRouteMapProto.route() method implementation

set_error_presenter(presenter)

Set error presenter for this route map

Parameters:presenter – presenter to be used for error handling Returns:None

class wasp_general.network.web.service.WWebService(route_map=None, collection=None, factory=None, debugger=None)

Bases: wasp_general.network.web.proto.WWebServiceProto

This class joins together all web-package functionality.

WWebServiceProto implementation

add_presenter(presenter)

Add presenter to a collection. If the given presenter is a WWebEnhancedPresenter instance then public routes are checked (via WWebEnhancedPresenter.__public_routes__() method) and are added in this route map

Parameters:presenter – presenter to add Returns:None

connect(pattern, presenter, **kwargs)

Shortcut for self.route_map().connect() method. It is possible to pass presenter class instead of its name - in that case such class will be saved in presenter collection and it will be available in route matching.

Parameters:

• pattern – same as pattern in WWebRouteMap.connect() method
• presenter – presenter name or presenter class
• kwargs – same as kwargs in WWebRouteMap.connect() method

Returns:

None

create_presenter(request, target_route)

Create presenter from the given requests and target routes

Parameters:

• request – client request
• target_route – route to use

Returns:

WWebPresenter

debugger()

execute(request, target_route)

WWebServiceProto.execute() method implementation

presenter_collection()

WWebServiceProto.presenter_collection() method implementation

presenter_factory()

WWebServiceProto.presenter_factory() method implementation

process_request(session)

Process single request from the given session

Parameters:session – session for reading requests and writing responses Returns:None

proxy(request, original_target_route, presenter_name, **kwargs)

Execute the given presenter as a target for the given client request

Parameters:

• request – original client request
• original_target_route – previous target route
• presenter_name – target presenter name
• kwargs – presenter arguments

Returns:

WWebResponseProto

route_map()

WWebServiceProto.route_map() method implementation

class wasp_general.network.web.service.WWebTargetRoute(presenter_name, presenter_action, route, route_map, **presenter_args)

Bases: wasp_general.network.web.proto.WWebTargetRouteProto

Simple WWebTargetRouteProto implementation

presenter_action()

WWebTargetRouteProto.presenter_action() method implementation

presenter_args()

WWebTargetRouteProto.presenter_args() method implementation

presenter_name()

WWebTargetRouteProto.presenter_class() method implementation

route()

Return origin route map

Returns:WWebRoute

route_map()

Return origin route map

Returns:WWebRouteMap

wasp_general.network.web.session module

class wasp_general.network.web.session.WWebSessionAdapter

Bases: wasp_general.network.web.proto.WWebSessionProto

accepted_socket()

client_address()

server_address()

class wasp_general.network.web.session.WWebSessionBase(request_cls=<class 'wasp_general.network.web.request.WWebRequest'>)

Bases: wasp_general.network.web.session.WWebSessionAdapter

Basic WWebSessionProto implementation. This class clarifies prototype and appends several methods

read_request_line(request_line)

Read HTTP-request line

Parameters:request_line – line to parse for HTTP/0.9 is GET <Request-URI> for HTTP/1.0 and 1.1 is <METHOD> <Request-URI> HTTP/<HTTP-Version>, where HTTP-Version is 1.0 or 1.1. for HTTP/2: binary headers are used

wasp_general.network.web.template_response module

class wasp_general.network.web.template_response.WWebTemplateResponse(template, context=None, status=None, headers=None)

Bases: wasp_general.template.WTemplateRenderer, wasp_general.network.web.response.WWebResponse

response_data()

wasp_general.network.web.tornado module

class wasp_general.network.web.tornado.WTornadoRequestHandler(wasp_web_service, application, request, **kwargs)

Bases: tornado.web.RequestHandler

According to http://www.tornadoweb.org/en/stable/web.html, requesthandlers are not thread safe

compute_etag()

delete(*args, **kwargs)

get(*args, **kwargs)

head(*args, **kwargs)

options(*args, **kwargs)

patch(*args, **kwargs)

post(*args, **kwargs)

put(*args, **kwargs)

class wasp_general.network.web.tornado.WTornadoSessionAdapter(request_handler, cleanup_handler)

Bases: wasp_general.network.web.session.WWebSessionAdapter

accepted_socket()

protocol()

protocol_version()

read_request()

session_close()

write_response(request, response, *pushed_responses)

Module contents