orionis.hashing.hashers.Argon2Hasher

THE ORIONIS API

Build with clarity.

Explore the building blocks of an async-first Python framework. Every module, class, and method — connected, searchable, and ready to build with.

Explore modules View classes

class documentation

class Argon2Hasher(IHasher): (source)

Constructor: Argon2Hasher(memory, threads, time)

View In Hierarchy

Hash passwords with Argon2id.

Argon2id won the Password Hashing Competition and is the recommended default driver of the framework.

Concurrency

No locks are used. The backend class and the backend instance are cached on first use: a concurrent first use from several threads may build them twice, and the last write wins. Hashing operations only read that cache, and the fluent setters drop it so later calls rebuild the backend with the new cost parameters.

Static Method	`_validate`	Ensure a cost parameter is a strictly positive integer.
Method	`__init__`	Initialize the driver with its default cost parameters.
Method	`_backendClass`	Return the backend class, importing it on first use.
Method	`_build`	Build a backend instance for the given cost parameters.
Method	`_check`	Verify a plain text value against an Argon2id hash.
Method	`_default`	Return the cached backend built from the configured parameters.
Method	`_identify`	Check whether the hash was produced by the Argon2 family.
Method	`_make`	Hash a plain text value with Argon2id.
Async Method	`check`	Verify a plain text value off the event loop.
Method	`getAlgorithm`	Return the algorithm identifier of this driver.
Async Method	`make`	Hash a plain text value off the event loop.
Method	`needsRehash`	Determine whether the hash uses outdated Argon2id parameters.
Method	`setMemory`	Set the default memory cost used by the driver.
Method	`setRounds`	Set the default time cost used by the driver.
Method	`setThreads`	Set the default parallelism used by the driver.
Class Variable	`__slots__`	Undocumented
Instance Variable	`_backend`	Undocumented
Instance Variable	`_backend_class`	Undocumented
Instance Variable	`_memory`	Undocumented
Instance Variable	`_threads`	Undocumented
Instance Variable	`_time`	Undocumented

@staticmethod

def _validate(name: str, value: int) -> int: (source) ¶

Ensure a cost parameter is a strictly positive integer.

Parameters
name:`str`	Name of the parameter, used in the error message.
value:`int`	Value to validate.

Returns
`int`	The validated value.

Raises
`HashConfigurationException`	If the value is not an integer greater than zero.

def __init__(self, *, memory: int = DEFAULT_MEMORY, threads: int = DEFAULT_THREADS, time: int = DEFAULT_TIME): (source) ¶

Initialize the driver with its default cost parameters.

Parameters
memory:`int`	Memory cost in kibibytes.
threads:`int`	Degree of parallelism.
time:`int`	Number of iterations.

Returns
`None`	This method initializes the instance and returns None.

Raises
`HashConfigurationException`	If any cost parameter is not a positive integer.

def _backendClass(self) -> Any: (source) ¶

Return the backend class, importing it on first use.

Returns
`Any`	Backend class provided by the underlying library.

Raises
`MissingHashDependencyException`	If the backend package is not installed.

def _build(self, memory: int, threads: int, time: int) -> Any: (source) ¶

Build a backend instance for the given cost parameters.

Parameters
memory:`int`	Memory cost in kibibytes.
threads:`int`	Degree of parallelism.
time:`int`	Number of iterations.

Returns
`Any`	Configured backend instance.

def _check(self, value: str, hashed: str) -> bool: (source) ¶

Verify a plain text value against an Argon2id hash.

Parameters
value:`str`	Plain text value to verify.
hashed:`str`	Previously generated hash.

Returns
`bool`	`True` when the value matches the hash, `False` otherwise.

def _default(self) -> Any: (source) ¶

Return the cached backend built from the configured parameters.

Returns
`Any`	Backend instance reused across calls.

def _identify(self, hashed: str) -> bool: (source) ¶

Check whether the hash was produced by the Argon2 family.

Parameters
hashed:`str`	Hash to inspect.

Returns
`bool`	`True` when the hash belongs to this driver.

def _make(self, value: str, *, rounds: int | None = None, memory: int | None = None, threads: int | None = None) -> str: (source) ¶

Hash a plain text value with Argon2id.

Parameters
value:`str`	Plain text value to hash.
rounds:`int \| None`	Per-call time cost override.
memory:`int \| None`	Per-call memory cost override, in kibibytes.
threads:`int \| None`	Per-call parallelism override.

Returns
`str`	Encoded Argon2id hash.

Raises
`HashConfigurationException`	If any override is not a positive integer.

async def check(self, value: str, hashed: str) -> bool: (source) ¶

overrides orionis.hashing.contracts.IHasher.check

Verify a plain text value off the event loop.

Parameters
value:`str`	Plain text value to verify.
hashed:`str`	Previously generated hash.

Returns
`bool`	`True` when the value matches the hash, `False` otherwise.

def getAlgorithm(self) -> str: (source) ¶

overrides orionis.hashing.contracts.IHasher.getAlgorithm

Return the algorithm identifier of this driver.

Returns
`str`	Always `'argon2id'`.

async def make(self, value: str, *, rounds: int | None = None, memory: int | None = None, threads: int | None = None) -> str: (source) ¶

overrides orionis.hashing.contracts.IHasher.make

Hash a plain text value off the event loop.

Parameters
value:`str`	Plain text value to hash.
rounds:`int \| None`	Per-call time cost override.
memory:`int \| None`	Per-call memory cost override, in kibibytes.
threads:`int \| None`	Per-call parallelism override.

Returns
`str`	Encoded Argon2id hash.

Raises
`HashConfigurationException`	If any override is not a positive integer.

def needsRehash(self, hashed: str) -> bool: (source) ¶

overrides orionis.hashing.contracts.IHasher.needsRehash

Determine whether the hash uses outdated Argon2id parameters.

Parameters
hashed:`str`	Previously generated hash.

Returns
`bool`	`True` when the hash should be regenerated.

def setMemory(self, memory: int) -> Self: (source) ¶

Set the default memory cost used by the driver.

Parameters
memory:`int`	New memory cost in kibibytes.

Returns
`Self`	The same instance, allowing fluent configuration.

Raises
`HashConfigurationException`	If the value is not a positive integer.

def setRounds(self, rounds: int) -> Self: (source) ¶

overrides orionis.hashing.contracts.IHasher.setRounds

Set the default time cost used by the driver.

Parameters
rounds:`int`	New number of iterations.

Returns
`Self`	The same instance, allowing fluent configuration.

Raises
`HashConfigurationException`	If the value is not a positive integer.

def setThreads(self, threads: int) -> Self: (source) ¶

Set the default parallelism used by the driver.

Parameters
threads:`int`	New degree of parallelism.

Returns
`Self`	The same instance, allowing fluent configuration.

Raises
`HashConfigurationException`	If the value is not a positive integer.

__slots__: tuple[str, ...] = (source) ¶

overrides orionis.hashing.contracts.IHasher.__slots__

Undocumented

_backend: Any = (source) ¶

Undocumented

_backend_class: Any = (source) ¶

Undocumented

_memory = (source) ¶

Undocumented

_threads = (source) ¶

Undocumented

_time = (source) ¶

Undocumented