`guillotina.utils`¶

guillotina.utils.get_current_request()¶

Return the current request by heuristically looking it up from stack

Return type:: InterfaceClass

guillotina.utils.get_content_path(content)¶

Generate path of resource object from the container

Parameters:: content (InterfaceClass) -- object to get path from
Return type:: str

guillotina.utils.get_full_content_path(ob)¶

Generate full path of resource object from root

Parameters:: content -- object to get path from
Return type:: str

guillotina.utils.iter_parents(content)¶

Iterate through all the parents of a content object

Parameters:: content (InterfaceClass) -- object to get path from
Return type:: Iterator[InterfaceClass]

async guillotina.utils.navigate_to(obj, path)¶

Get a sub-object.

Parameters:

obj (InterfaceClass) -- object to get path from
path (str) -- relative path to object you want to retrieve

guillotina.utils.get_owners(obj)¶

Return owners of an object

Parameters:: obj (InterfaceClass) -- object to get path from
Return type:: list

guillotina.utils.get_object_url(ob, request=None, **kwargs)¶

Generate full url of object.

Parameters:

ob (InterfaceClass) -- object to get url for
request (Optional[InterfaceClass]) -- relative path to object you want to retrieve

Return type:

Optional[str]

async guillotina.utils.get_object_by_uid(uid, txn=None)¶

Get an object from an uid

Parameters:

uid (str) -- Object id of object you need to retreive
txn -- Database transaction object. Will get current transaction is not provided

Return type:

InterfaceClass

async guillotina.utils.get_behavior(ob, iface, create=False)¶

Generate behavior of object.

Parameters:

ob -- object to get behavior for
interface -- interface registered for behavior
create -- if behavior data empty, should we create it?

async guillotina.utils.get_database(db_id, root=None)¶

Get configured database

Parameters:: db_id -- configured database id
Return type:: InterfaceClass

guillotina.utils.get_current_db()¶

Return the current db by heuristically looking it up from stack

Return type:: InterfaceClass

guillotina.utils.get_current_container()¶

Return the current container by heuristically looking it up from stack

Return type:: InterfaceClass

guillotina.utils.find_container(context=None)¶

Find container based on contextvar or by looking up the container from the provided context parameter

Return type:: Optional[InterfaceClass]

guillotina.utils.get_current_transaction()¶

Return the current request by heuristically looking it up from stack

Return type:: InterfaceClass

guillotina.utils.get_url(req, path)¶: Return calculated url from a request object taking into account X-VirtualHost-Monster header and X-Forwarded header

guillotina.utils.get_schema_validator(schema_name)¶

Get a json schema validator by the definition name

Parameters:: schema_name (str) -- Name of the json schema type

async guillotina.utils.get_registry(context=None)¶

Return type:: Optional[InterfaceClass]

guillotina.utils.get_authenticated_user()¶

Get the currently authenticated user

Return type:: Optional[InterfaceClass]

guillotina.utils.get_authenticated_user_id()¶

Get the currently authenticated user id

Return type:: Optional[str]

guillotina.utils.get_security_policy(user=None)¶

Get the current security policy

Parameters:: user (Optional[InterfaceClass]) -- user to use for security policy
Return type:: InterfaceClass

guillotina.utils.strings_differ(string1, string2)¶

Check whether two strings differ while avoiding timing attacks.

This function returns True if the given strings differ and False if they are equal. It's careful not to leak information about where they differ as a result of its running time, which can be very important to avoid certain timing-related crypto attacks:

http://seb.dbzteam.org/crypto/python-oauth-timing-hmac.pdf

>>> strings_differ('one', 'one')
False
>>> strings_differ('one', 'two')
True

Parameters:

string1 (str)
string2 (str)

Return type:

bool

guillotina.utils.get_random_string(length=30, allowed_chars='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')¶

Heavily inspired by Plone/Django Returns a securely generated random string.

>>> get_random_string(length=10)

Parameters:

length (int)
allowed_chars (str)

Return type:

str

guillotina.utils.resolve_dotted_name(name)¶

import the provided dotted name

>>> resolve_dotted_name('guillotina.interfaces.IRequest')
<InterfaceClass guillotina.interfaces.IRequest>

Parameters:: name (str) -- dotted name
Return type:: Any

guillotina.utils.get_caller_module(level=2, sys=<module 'sys' (built-in)>)¶

Pulled out of pyramid

Return type:: Optional[ModuleType]

guillotina.utils.resolve_module_path(path)¶

Return type:: Optional[str]

guillotina.utils.get_module_dotted_name(ob)¶

Return type:: Optional[Any]

guillotina.utils.get_dotted_name(ob)¶

Convert a module/class/function to dotted path string

Parameters:: ob (TypeVar(ResolvableType, ModuleType, FunctionType, type)) -- the object you'd like to convert
Return type:: str

guillotina.utils.import_class(import_string)¶

Import class from string

Parameters:: import_string (str) -- dotted class name
Return type:: Optional[ModuleType]

guillotina.utils.resolve_path(file_path)¶

Resolve path to file inside python module

>>> resolve_path('guillotina:__init__.py')
PosixPath('/Users/user/guillotina/guillotina/__init__.py')

Parameters:: file_path (str) -- module:path string
Return type:: Path

guillotina.utils.merge_dicts(d1, d2)¶

Update two dicts of dicts recursively, if either mapping has leaves that are non-dicts, the second's leaf overwrites the first's.

Return type:: dict

async guillotina.utils.apply_coroutine(func, *args, **kwargs)¶

Call a function with the supplied arguments. If the result is a coroutine, await it.

>>> async def foobar(): return 'hi'
>>> async def async_foobar(): return 'hi'
>>> await apply_coroutine(foobar)
'hi'
>>> await apply_coroutine(async_foobar)
'hi'

Parameters:

func (FunctionType) -- function to run as coroutiune if one
*args -- args to call function with
**kwargs -- kwargs to call function with

Return type:

object

guillotina.utils.lazy_apply(func, *call_args, **call_kwargs)¶

apply arguments in the order that they come in the function signature and do not apply if argument not provided

call_args will be applied in order if func signature has args. otherwise, call_kwargs is the magic here...

guillotina.utils.safe_unidecode(val)¶

Convert bytes to a string in a safe way

>>> safe_unidecode(b'foobar')
'foobar'

Parameters:: val (Union[str, bytes]) -- bytes to convert
Return type:: str

async guillotina.utils.run_async(func, *args, **kwargs)¶

Run a non-async function in an executor

>>> async def foobar(): return 'hi'
>>> await run_async(foobar)
'hi'

Parameters:

func -- function to run as coroutiune if one
*args --
args to call function with
**kwargs --
kwargs to call function with

Return type:

object

class guillotina.utils.Navigator(txn, container)¶

Provides a consistent view of the loaded objects, ensuring that only a single instance of each resource path is loaded.

It is particularly useful when objects that may have been modified or added have to be found by path (something that the content api cannot do).

To keep the Navigator index consistent, all object loadings must be done through its API, meaning the content api should not be used anymore. In case it cannot be avoided, make sure to use the sync() function before re-using the Navigator.

Parameters:

txn (Transaction) -- A Transaction instance
container (Container) -- A Container

delete(obj)¶

Delete an object from the tree

When using Navigator, this method should be used so that the Navigator can update its index and not return it anymore.

async get(path)¶

Returns an object from its path.

If this path was already modified or loaded by Navigator, the same object instance will be returned.

sync()¶

Resync the index with the transaction

If some operations may have added, modified or deleted objects that the Navigator does not know, sync() should be called so that the index is up-to-date with the transaction.

`guillotina.utils.execute`¶

guillotina.utils.execute.after_request(func, *args, _name=None, _scope='', **kwargs)¶

Execute after the request has successfully finished.

Parameters:

func (Callable[..., Coroutine[Any, Any, Any]]) -- function to be queued
_name -- unique identifier to give in case you want to prevent duplicates
_scope -- customize scope of after commit to run for instead of default(successful request)
*args -- arguments to call the func with
**kwargs -- keyword arguments to call the func with

guillotina.utils.execute.after_request_failed(func, *args, _name=None, **kwargs)¶

Execute after the request has failed or errored.

Parameters:

func (Callable[..., Coroutine[Any, Any, Any]]) -- function to be queued
*args -- arguments to call the func with
**kwargs -- keyword arguments to call the func with

guillotina.utils.execute.after_commit(func, *args, **kwargs)¶

Execute a commit to the database.

Parameters:

func (Callable) -- function to be queued
*args -- arguments to call the func with
**kwargs -- keyword arguments to call the func with

guillotina.utils.execute.before_commit(func, *args, **kwargs)¶

Execute before a commit to the database.

Parameters:

func (Callable[..., Coroutine[Any, Any, Any]]) -- function to be queued
_request -- provide request object to prevent request lookup
*args -- arguments to call the func with
**kwargs -- keyword arguments to call the func with

guillotina.utils.execute.in_pool(func, *args, **kwargs)¶

Execute function in the async pool.

Parameters:

func (Callable[..., Coroutine[Any, Any, Any]]) -- function to be queued
*args -- arguments to call the func with
**kwargs -- keyword arguments to call the func with

Return type:

ExecuteContext

guillotina.utils.execute.in_queue(func, *args, **kwargs)¶

Execute view-type object(context, request) in the async queue.

Parameters:: view -- view to be queued
Return type:: ExecuteContext

guillotina.utils.execute.in_queue_with_func(func, *args, **kwargs)¶

Execute view-type object(context, request) in the async queue.

Parameters:: view -- view to be queued
Return type:: ExecuteContext

class guillotina.utils.execute.ExecuteContext(func, *args, **kwargs)¶

Execution context object to allow you to run the function in different contexts.

after_commit()¶: Execute after we commit to the database.

after_request(_name=None)¶

Execute after the request has successfully finished.

Parameters:: _name -- unique identifier to give in case you want to prevent duplicates

after_request_failed(_name=None)¶

Execute after the request has failed or errored.

Parameters:: _name -- unique identifier to give in case you want to prevent duplicates

before_commit()¶: Execute just before we commit to the database.

On this page

Next topic

Previous topic

`guillotina.utils`¶

`guillotina.utils.execute`¶

guillotina.utils¶

guillotina.utils.execute¶

`guillotina.utils`¶

`guillotina.utils.execute`¶