AveyTense

Version	Upload Date	Yanked Date
0.3.81	24th Sep 2026 *	-
0.3.80	12th Sep 2026 *	-
0.3.79	24th Aug 2026 *	-
0.3.78	12th Aug 2026 *	-
0.3.77	24th Jul 2026 *	-
0.3.76	12th Jul 2026 *	-
0.3.75	24th Jun 2026 *	-
0.3.74	12th Jun 2026 *	-
0.3.73	24th May 2026	-
0.3.72	12th May 2026	-
0.3.71	24th Apr 2026	-
0.3.70	12th Apr 2026	-
0.3.69	2nd Apr 2026	-
0.3.68	24th Mar 2026	-
0.3.67	12th Mar 2026	-
0.3.66	24th Feb 2026	-
0.3.65	12th Feb 2026	-
0.3.64	24th Jan 2026	-
0.3.63	12th Jan 2026	-
0.3.62	24th Dec 2025	-
0.3.61	12th Dec 2025	-
0.3.60	30th Nov 2025	-
0.3.59	12th Nov 2025	-
0.3.58	30th Oct 2025	-
0.3.57	18th Oct 2025	-
0.3.56	6th Oct 2025	-
0.3.55	24th Sep 2025	-
0.3.55b1	21st Sep 2025	-
0.3.55a2	18th Sep 2025	-
0.3.55a1	15th Sep 2025	-
0.3.54	12th Sep 2025	-
0.3.53	30th Aug 2025	-
0.3.52	18th Aug 2025	-
0.3.51	3rd Aug 2025	-
0.3.50	12th Jul 2025	-
0.3.49	3rd Jul 2025	-
0.3.48	24th Jun 2025	-
0.3.47	12th Jun 2025	-
0.3.46	30th May 2025	-
0.3.45	16th May 2025	-
0.3.44	3rd May 2025	-
0.3.43	18th Apr 2025	-
0.3.42	2nd Apr 2025	-
0.3.41	14th Mar 2025	-
0.3.40	27th Feb 2025	-
0.3.39	14th Feb 2025	-
0.3.38	11th Feb 2025	-
0.3.37	9th Feb 2025	-
0.3.37a1	3rd Feb 2025	-
0.3.36	2nd Feb 2025	-
0.3.35	23rd Jan 2025	-
0.3.34	15th Jan 2025	-
0.3.33	25th Dec 2024	-
0.3.32	16th Dec 2024	-
0.3.31	8th Dec 2024	-
0.3.30	29th Nov 2024	-
0.3.29	27th Nov 2024	2nd Apr 2026
0.3.28	23rd Nov 2024	2nd Apr 2026
0.3.27	22nd Nov 2024	2nd Apr 2026
0.3.27rc2	27th Oct 2024	2nd Apr 2026
0.3.27rc1	20th Oct 2024	2nd Apr 2026
0.3.27b3	13th Oct 2024	2nd Apr 2026
0.3.27b2	26th Sep 2024	2nd Apr 2026
0.3.27b1	23rd Sep 2024	2nd Apr 2026
0.3.27a5	13th Sep 2024	2nd Apr 2026
0.3.27a4	9th Sep 2024	2nd Apr 2026
0.3.27a3	3rd Sep 2024	2nd Apr 2026
0.3.27a2	29th Aug 2024	2nd Apr 2026
0.3.27a1	27th Aug 2024	2nd Apr 2026
0.3.26	26th Aug 2024	2nd Apr 2026
0.3.26rc3	21st Aug 2024	2nd Apr 2026
0.3.26rc2	16th Aug 2024	2nd Apr 2026
0.3.26rc1	7th Aug 2024	2nd Apr 2026

Version	Upload Date	End-of-Life (PyPi: Yanked Date)
0.3.29	archive: 27th Nov 2024 pypi: 27th Nov 2024	2nd April 2026
0.3.28	archive: 23rd Nov 2024 pypi: 23rd Nov 2024	2nd April 2026
0.3.27	archive: 11th Nov 2024 pypi: 22nd Nov 2024	2nd April 2026
0.3.27rc2	archive: 27th Oct 2024 pypi: 27th Oct 2024	2nd April 2026
0.3.27rc1	archive: 19th Oct 2024 pypi: 20th Oct 2024	2nd April 2026
0.3.27b3	archive: 13th Oct 2024 pypi: 13th Oct 2024	2nd April 2026
0.3.27b2	archive: 26th Sep 2024 pypi: 26th Sep 2024	2nd April 2026
0.3.27b1	archive: 23rd Sep 2024 pypi: 23rd Sep 2024	archive: 1st Jan 2026 pypi: 2nd April 2026
0.3.27a5	archive: 13th Sep 2024 pypi: 13th Sep 2024	archive: 1st Jan 2026 pypi: 2nd April 2026
0.3.27a4	archive: 9th Sep 2024 pypi: 9th Sep 2024	archive: 1st Jan 2026 pypi: 2nd April 2026
0.3.27a3	archive: 2nd Sep 2024 pypi: 3rd Sep 2024	archive: 1st Jan 2026 pypi: 2nd April 2026
0.3.27a2	archive: 28th Aug 2024 pypi: 29th Aug 2024	archive: 1st Jan 2026 pypi: 2nd April 2026
0.3.27a1	archive: 27th Aug 2024 pypi: 27th Aug 2024	archive: 1st Jan 2026 pypi: 2nd April 2026
0.3.26	archive: 24th Aug 2024 pypi: 26th Aug 2024	archive: 1st Jan 2026 pypi: 2nd April 2026
0.3.26rc3	archive: 21st Aug 2024 pypi: 21st Aug 2024	archive: 1st Jan 2026 pypi: 2nd April 2026

Version	Upload Date	End-of-Life	Languages
0.3.26rc2	archive: 15th Aug 2024 pypi: 16th Aug 2024	archive: 1st Jan 2026 pypi: 2nd April 2026	Python, Java
0.3.26rc1	archive: 7th Aug 2024 pypi: 7th Aug 2024	archive: 1st Jan 2026 pypi: 2nd April 2026	Python, Java
0.3.26b3	29th Jul 2024	12th Sep 2025	Python, Java
0.3.26b2	25th Jul 2024	12th Sep 2025	Python, Java
0.3.26a4	24th Jul 2024	12th Sep 2025	Python, Java
0.3.26b1	23rd Jul 2024	12th Sep 2025	Python, Java
0.3.26a3	22nd Jul 2024	12th Sep 2025	Python, Java
0.3.26a2	21st Jul 2024	12th Sep 2025	Python, Java
0.3.26a1	20th Jul 2024	12th Sep 2025	Python, Java
0.3.25	19th Jul 2024	29th Jun 2025	Sass (CSS), TS, JS, C++, C#, Java, Python, PHP, Lua
0.3.24	29th Jun 2024	29th Jun 2025	Sass (CSS), TS, JS, C++, C#, Java, Python, PHP, Lua
0.3.23	18th Mar 2024	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.22	28th Jan 2024	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.21	10th Dec 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.20	16th Nov 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.19	21st Oct 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.18	27th Sep 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.17	13th Sep 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.16	2nd Sep 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.15	13th Aug 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.14	31st Jul 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.13	12th Jun 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.12	29th May 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.11	14th May 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.10	10th May 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.9	1st May 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.8	14th Apr 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.7	2nd Apr 2023	27th Nov 2024	Sass (CSS), JS + TS, C++, C#, Java, Python, PHP, Lua
0.3.6	26th Mar 2023	27th Nov 2024	Sass, TypeScript, C++, C#, Java, Python, PHP, Lua
0.3.5	5th Mar 2023	27th Nov 2024	Sass, TypeScript, C++, C#, Java, Python, PHP, Lua
0.3.4	23th Feb 2023	20th Jul 2024	Sass, TypeScript, C++, C#, Java, Python, PHP, Lua
0.3.3	14th Feb 2023	20th Jul 2024	Sass, TypeScript, C++, C#, Java, Python, PHP, Lua
0.3.2	5th Feb 2023	20th Jul 2024	Sass, TypeScript, C++, C#, Java, Python, PHP, Lua
0.3.1	30th Jan 2023	20th Jul 2024	Sass, TypeScript, C++, C#, Java, Python, PHP, Lua
0.3.0	18th Jan 2023	20th Jul 2024	Sass, TypeScript, C++, C#, Java, Python, PHP, Lua
0.2.16	15th Jan 2023	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.15	13th Jan 2023	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.14	9th Jan 2023	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.13	8th Jan 2023	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.12	6th Jan 2023	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.11	31st Dec 2022	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.10	28th Dec 2022	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.9	25th Dec 2022	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.8	23rd Dec 2022	19th Jul 2024	Sass, TypeScript, C++, C#, Java, PHP, Lua
0.2.7	18th Dec 2022	19th Jul 2024	TypeScript, C#, Java, PHP, Lua
0.2.6	13th Dec 2022	19th Jul 2024	TypeScript, C++, Java, PHP, Lua
0.2.5	9th Dec 2022	19th Jul 2024	TypeScript, C++, Java, PHP, Lua
0.2.4	3rd Dec 2022	2nd Sep 2023	TypeScript, C++, Java, PHP, Lua
0.2.3	29th Nov 2022	2nd Sep 2023	TypeScript, C++, Java, PHP, Lua
0.2.2	23th Nov 2022	2nd Sep 2023	TypeScript, C++, PHP, Lua
0.2.1	19th Nov 2022	5th Feb 2023	TypeScript, C++, PHP

`i` value	`iters` values	Return value
mapping object	mapping objects	dict
generator object	universal iterable objects	Generator
asynchronous generator object	universal iterable objects	AsyncGenerator
iterable object	universal iterable objects	list

Value of `bits`	Allowed values	Interpretation
3	n ∈ ⟨0; 7⟩	n + 30
4	n ∈ ⟨0; 15⟩	n + 30 if n ∈ ⟨0; 7⟩ n + 82 if n ∈ ⟨8; 15⟩
8	n ∈ ⟨0; 255⟩	n
24	n ∈ ⟨0; 16777215⟩

Value of `bits`	Allowed values	Interpretation
3	n ∈ ⟨0; 7⟩	n + 40
4	n ∈ ⟨0; 15⟩	n + 40 if n ∈ ⟨0; 7⟩ n + 92 if n ∈ ⟨8; 15⟩
8	n ∈ ⟨0; 255⟩	n
24	n ∈ ⟨0; 16777215⟩

Constant	Lifetime	Description	Value
Single styles
`NORMAL`	≥ 0.3.26rc1	Provides normal text. Nothing changes with this constant	0
`BOLD`	Text becomes bold	1
`ITALIC`	Text becomes oblique	3
`UNDERLINE`	Adds a line under the text	4
`SLOW_BLINK`	Sets blinking to less than 150 times per minute	5
`RAPID_BLINK`	Sets blinking to more than 150 times per minute	6
`REVERSE`	Swap foreground and background colors	7
`HIDE`	Text isn't visible on the output	8
`STRIKE`	Text becomes crossed out	9
`DOUBLE_UNDERLINE`	Adds 2 lines under the text	21
`PROPORTIONAL`	≥ 0.3.26rc1; < 0.3.26rc2	Proportional spacing, consider using str.rjust() instead 0.3.26rc2	26
`FRAME`	≥ 0.3.26rc1	?	51
`ENCIRCLE`	It is probably border encasing entire text.	52
`OVERLINE`	Adds a line over the text	53
`SUPERSCRIPT`	Superscripts the text	73
`SUBSCRIPT`	Subscripts the text	74
Advanced styles
`BOLD_ITALIC`	≥ 0.3.26rc2	Text becomes bold and oblique	1000
`BOLD_UNDERLINE`	Text becomes bold and underlined	1001
`BOLD_STRIKE`	Text becomes bold and crossed out	1002
`BOLD_OVERLINE`	Text becomes bold and overlined	1003
`ITALIC_UNDERLINE`	Text becomes oblique and underlined	1004
`ITALIC_STRIKE`	Text becomes oblique and crossed out	1005
`ITALIC_OVERLINE`	Text becomes oblique and overlined	1006
`UNDERLINE_STRIKE`	Text becomes underlined and crossed out	1007
`UOLINE`	Adds lines under and over the text	1008
`STRIKE_OVERLINE`	Text becomes crossed out and overlined	1009
`BOLD_ITALIC_UNDERLINE`	Text becomes bold, oblique and underlined	1100
`BOLD_ITALIC_STRIKE`	Text becomes bold, oblique and crossed out	1101
`BOLD_ITALIC_OVERLINE`	Text becomes bold, oblique and overlined	1102
`BOLD_UNDERLINE_STRIKE`	Text becomes bold, underlined and crossed out	1103
`BOLD_UOLINE`	Text becomes bold, underlined and overlined	1104
`ITALIC_UNDERLINE_STRIKE`	Text becomes italic, underlined and crossed out	1105
`ITALIC_UOLINE`	Text becomes italic, underlined and overlined	1106
`ITALIC_STRIKE_OVERLINE`	Text becomes bold, crossed out and overlined	1107
`STRIKE_UOLINE`	Text becomes crossed out, underlined and overlined	1108

Type alias details
Referred class/type	Python versions
array.array	≥ 3.12
Defined as a class	< 3.12

Type alias details
Referred class/type	Python versions
contextlib.AbstractAsyncContextManager	≥ 3.9
typing.AsyncContextManager	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.AsyncGenerator	≥ 3.9
typing.AsyncGenerator	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.AsyncIterable	≥ 3.9
typing.AsyncIterable	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.AsyncIterator	≥ 3.9
typing.AsyncIterator	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Awaitable	≥ 3.9
typing.Awaitable	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Callable	≥ 3.9
typing.Callable	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.ChainMap	≥ 3.9
typing.ChainMap	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Collection	≥ 3.9
typing.Collection	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Container	≥ 3.9
typing.Container	< 3.9

Type alias details
Referred class/type	Python versions
contextlib.AbstractContextManager	≥ 3.9
typing.ContextManager	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Coroutine	≥ 3.9
typing.Coroutine	< 3.9

Type alias details
Referred class/type	Python versions
collections.Counter	≥ 3.9
typing.Counter	< 3.9

Type alias details
Referred class/type	Python versions
collections.defaultdict	≥ 3.9
typing.DefaultDict	< 3.9

Type alias details
Referred class/type	Python versions
collections.deque	≥ 3.9
typing.Deque	< 3.9

Type alias details
Referred class/type	Python versions
dict	≥ 3.9
typing.Dict	< 3.9

Type alias details
Referred class/type	Python versions
enumerate	≥ 3.9
Defined as a class	< 3.9

Type alias details
Referred class/type	Python versions
frozenset	≥ 3.9
typing.FrozenSet	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Generator	≥ 3.9
typing.Generator	< 3.9

Type alias details
Referred class/type	Python versions
types.GenericAlias	≥ 3.9
aveytense.extensions.TypingGenericType	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.ItemsView	≥ 3.9
typing.ItemsView	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Iterable	≥ 3.9
typing.Iterable	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Iterator	≥ 3.9
typing.Iterator	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.KeysView	≥ 3.9
typing.KeysView	< 3.9

Type alias details
Referred class/type	Python versions
list	≥ 3.9
typing.List	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Mapping	≥ 3.9
typing.Mapping	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.MappingView	≥ 3.9
typing.MappingView	< 3.9

Type alias details
Referred class/type	Python versions
re.Match	≥ 3.9
typing.Match	< 3.9

Type alias details
Referred class/type	Python versions
memoryview	≥ 3.14
Defined as a class	< 3.14

Type alias details
Referred class/type	Python versions
collections.abc.MutableMapping	≥ 3.9
typing.MutableMapping	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.MutableSequence	≥ 3.9
typing.MutableSequence	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.MutableSet	≥ 3.9
typing.MutableSet	< 3.9

Type alias details
Referred class/type	Python versions
collections.OrderedDict	≥ 3.9
typing.OrderedDict	< 3.9

Type alias details
Referred class/type	Python versions
os.PathLike	≥ 3.9
Defined as a class	< 3.9

Type alias details
Referred class/type	Python versions
re.Pattern	≥ 3.9
typing.Pattern	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Reversible	≥ 3.9
typing.Reversible	< 3.9

Type alias details
Referred class/type	Python versions
collections.abc.Sequence	≥ 3.9
typing.Sequence	< 3.9

Type alias details
Referred class/type	Python versions
set	≥ 3.9
typing.Set	< 3.9

Type alias details
Referred class/type	Python versions
tuple	≥ 3.9
typing.Tuple	< 3.9

Type alias details
Referred class/type	Python versions
type	≥ 3.9
typing.Type	< 3.9

Type alias details
Referred class/type	Python versions
types.UnionType	≥ 3.10
aveytense.extensions.TypingUnionType	< 3.10

Type alias details
Referred class/type	Python versions
collections.abc.Set	≥ 3.9
typing.AbstractSet	< 3.9

aveytense.constants
≥ 0.3.26rc3

aveytense.exceptions
≥ 0.3.44

Provides custom exception classes. Previously, this module was private (aveytense._exceptions), since 0.3.44 it is public.

aveytense.extensions
≥ 0.3.24; < 0.3.26rc1; ≥ 0.3.57

Extensions of AveyTense. It contains types and other definitions in majority adjusted for every Python version supported by the project. Also, the code of this module inspects currently used version of PyPi project typing_extensions, so there won't be any import errors impacting the project.

It was the module where tests on ANSIColor occurred, before class aveytense.Color replaced that class utterly on 0.3.26rc1. On 0.3.57, module has been reinstated by renaming from aveytense.types.

Definitions derive mostly from the following modules:

Backward-compatibility is included, up to Python 3.8. Type subscription since 0.3.52 is restricted to type aliases starting with prefix AVT.

aveytense.games
≥ 0.3.31; < 0.3.47

Module for entertainment. Most declarations were affiliated with class Games that was featured in this submodule. Removed to be in separate, projected PyPi project aveytense_games.

aveytense.operators
≥ 0.3.27a3

Little extension of operator Python standard library, enhancing definitions with CamelCase names.

aveytense.primary
≥ 0.3.24; < 0.3.26rc3

The module where abroad() and reckon() functions were defined in early versions of AveyTense after mass rewrite back in versions 0.3.24 and 0.3.25.

Today this module exists as an internal module that shouldn't be imported, and that module not only has abroad() and reckon() functions, but also classes Math and Time. All of these can be simply imported with aveytense module, like aveytense.Math or aveytense.abroad().

aveytense.tcs
≥ 0.3.25?; < 0.3.26rc3

This submodule featured constants and types collection (also the meaning of this alias). It has been replaced by 2 different submodules: aveytense.constants and aveytense.types_collection (currently as aveytense.extensions).

aveytense.types (≥ 0.3.27a4; < 0.3.57)

See aveytense.extensions

0.3.52: Renamed from aveytense.types_collection to current name.

0.3.57: Renamed to aveytense.extensions.

0.3.57

aveytense.util
≥ 0.3.34

Contains utility classes to create abstract, final and frozen classes, abstract and final methods, as well as final variables. This module also provides class ParamVar for callable objects' signatureintrospection

Available definitions

Constants

Most constants since 0.3.35 are located in submodule aveytense.constants.

aveytense.constants.INT8_MIN
aveytense.constants.INT8_MAX
aveytense.constants.INT16_MIN
aveytense.constants.INT16_MAX
aveytense.constants.INT32_MIN
aveytense.constants.INT32_MAX
aveytense.constants.INT64_MIN
aveytense.constants.INT64_MAX
aveytense.constants.INT128_MIN
aveytense.constants.INT128_MAX
aveytense.constants.INT256_MIN
aveytense.constants.INT256_MAX
aveytense.constants.INT512_MIN
aveytense.constants.INT512_MAX
aveytense.constants.INT1024_MIN
aveytense.constants.INT1024_MAX
aveytense.constants.INT2048_MIN
aveytense.constants.INT2048_MAX
aveytense.constants.INT4096_MIN
aveytense.constants.INT4096_MAX
aveytense.constants.INT8192_MIN
aveytense.constants.INT8192_MAX
aveytense.constants.SSIZE_MAX
→ int

≥ 0.3.57

aveytense.constants.JS_MAX_SAFE_INTEGER
→ int

≥ 0.3.26b3; < 0.3.53; ≥ 0.3.57

Returns the greatest safe integer in JavaScript, thats 2⁵³ - 1 or 9007199254740991. See also Number.MAX_SAFE_INTEGER. 0.3.50: this constant may occur as ~.Math.JS_MAX_SAFE_INTEGER rather than in current form.

0.3.53: Instead use aveytense.Math.JS_MAX_SAFE_INTEGER

0.3.57: Reinstated this constant in old form before 0.3.53 and removed it from class aveytense.Math.

aveytense.constants.JS_MAX_VALUE
→ int

≥ 0.3.26b3; < 0.3.53; ≥ 0.3.57

Returns the greatest number value that can be represented in JavaScript without value loss (2¹⁰²⁴ - 2⁹⁷¹). If a numeric value is greater than this number, factual value is lost and coerced to Infinity.

Exact value of 2¹⁰²⁴ - 2⁹⁷¹ is:

179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368

Approximate (10 digit precision): 1.7976931349e+308 (1.7976931349 ∙ 10³⁰⁸).

See also Number.MAX_VALUE. 0.3.50: this constant may occur as ~.Math.JS_MAX_VALUE rather than in current form.

0.3.53: Instead use aveytense.Math.JS_MAX_VALUE

0.3.57: Reinstated this constant in old form before 0.3.53 and removed it from class aveytense.Math.

aveytense.constants.JS_MIN_SAFE_INTEGER
→ int

≥ 0.3.26b3; < 0.3.53; ≥ 0.3.57

Returns the least safe integer in JavaScript, thats -(2⁵³ - 1) or -9007199254740991. See also Number.MIN_SAFE_INTEGER. 0.3.50: this constant may occur as ~.Math.JS_MIN_SAFE_INTEGER rather than in current form.

0.3.53: Instead use aveytense.Math.JS_MIN_SAFE_INTEGER

0.3.57: Reinstated this constant in old form before 0.3.53 and removed it from class aveytense.Math.

aveytense.constants.JS_MIN_VALUE
→ decimal.Decimal

≥ 0.3.26b3; < 0.3.53; ≥ 0.3.57

Returns the smallest number value that can be represented in JavaScript without value loss (2^-1074). If a numeric value is least than this number, factual value is lost and coerced to 0.

Exact value of 2^-1074 is:

4.940656458412465441765687928682213723650598026143247644255856825006755072702087518652998363616359923797965646954457177309266567103559397963987747960107818781263007131903114045278458171678489821036887186360569987307230500063874091535649843873124733972731696151400317153853980741262385655911710266585566867681870395603106249319452715914924553293054565444011274801297099995419319894090804165633245247571478690147267801593552386115501348035264934720193790268107107491703332226844753335720832431936092382893458368060106011506169809753078342277318329247904982524730776375927247874656084778203734469699533647017972677717585125660551199131504891101451037862738167250955837389733598993664809941164205702637090279242767544565229087538682506419718265533447265625e-324

Approximate (10 digit precision): 4.9406564584e-324 (4.9406564584 ∙ 10^-324).

See also Number.MIN_VALUE. JavaScript will start using scientific notation with dozen digit precision when there are at least 6 zeros leading fractional part of the numeric value. Precision starts being truncated when going for 2^-1025 or least, ultimately leading to one digit precision.

2^-1074 is evaluated to 5e-324 in JavaScript, so will it normally in Python, if this constant wasn't an object of decimal.Decimal.

0.3.50: this constant may occur as ~.Math.JS_MIN_VALUE rather than in current form.

0.3.53: Instead use aveytense.Math.JS_MIN_VALUE

0.3.57: Reinstated this constant in old form before 0.3.53 and removed it from class aveytense.Math, but this time the constant is an instance of decimal.Decimal (instead of float) due to its value rounding to 5e-324, as in JavaScript.

aveytense.constants.MC_DURABILITY
→ <dict-like object>

≥ 0.3.26b3; < 0.3.41

Returns duralibility of all tools in Minecraft as for version 1.21.5.

0.3.37: this constant is now instance of local class holding final properties representing items.
Earlier, it was a string-key-integer-value dictionary. 0.3.41: renamed this constant to ~.games.Minecraft.durability. aveytense.games submodule has been revoked in 0.3.47 to be used in separate project aveytense_games. 0.3.41

aveytense.constants.MC_ENCHANTS
→ int

≥ 0.3.26b3; < 0.3.41

Returns 42 (amount of enchantments in Minecraft as for version 1.21.5). 0.3.41: renamed this constant to ~.games.Minecraft.enchantments. aveytense.games submodule has been revoked in 0.3.47 to be used in separate project aveytense_games. 0.3.41

aveytense.constants.MODE_AND
→ <enumerator>

≥ 0.3.36

Equivalent to aveytense.Tense.AND

aveytense.constants.MODE_OR
→ <enumerator>

≥ 0.3.36

Equivalent to aveytense.Tense.OR

aveytense.constants.RGB_MIN
→ int

≥ 0.3.37

Represents minimal possible value in RGB color picker, there 0

aveytense.constants.RGB_MAX
→ int

≥ 0.3.37

Represents maximal possible value in RGB color picker, there 2²⁴ - 1 or 16777215

aveytense.constants.SMASH_HIT_CHECKPOINTS
→ int

≥ 0.3.26b3; < 0.3.47

Returns 13 (Smash Hit has 12 checkpoints + 1 endless). 0.3.47: To be used in separate project aveytense_games.

aveytense.constants.STRING_BINARY
→ str

≥ 0.3.36

Returns 0-1 in a string.

aveytense.constants.STRING_DIGITS
→ str

≥ 0.3.36

Returns 0-9 in a string.

aveytense.constants.STRING_HEXADECIMAL
→ str

≥ 0.3.36

Returns 0-9a-fA-F in a string.

aveytense.constants.STRING_LETTERS
→ str

≥ 0.3.36

Returns a-zA-Z in a string.

aveytense.constants.STRING_LOWER
→ str

≥ 0.3.36

Returns a-z in a string.

aveytense.constants.STRING_OCTAL
→ str

≥ 0.3.36

Returns 0-7 in a string.

aveytense.constants.STRING_SPECIAL
→ str

≥ 0.3.36

Returns all ASCII characters (excluding code ones) not being a letter nor digit, in a string.

aveytense.constants.STRING_UPPER
→ str

≥ 0.3.36

Returns A-Z in a string.

aveytense.constants.UINT8_MIN
aveytense.constants.UINT8_MAX
aveytense.constants.UINT16_MIN
aveytense.constants.UINT16_MAX
aveytense.constants.UINT32_MIN
aveytense.constants.UINT32_MAX
aveytense.constants.UINT64_MIN
aveytense.constants.UINT64_MAX
aveytense.constants.UINT128_MIN
aveytense.constants.UINT128_MAX
aveytense.constants.UINT256_MIN
aveytense.constants.UINT256_MAX
aveytense.constants.UINT512_MIN
aveytense.constants.UINT512_MAX
aveytense.constants.UINT1024_MIN
aveytense.constants.UINT1024_MAX
aveytense.constants.UINT2048_MIN
aveytense.constants.UINT2048_MAX
aveytense.constants.UINT4096_MIN
aveytense.constants.UINT4096_MAX
aveytense.constants.UINT8192_MIN
aveytense.constants.UINT8192_MAX
aveytense.constants.SIZE_MAX
→ int

≥ 0.3.57

Unsigned integer constants borrowed from C/C++.

For constants with deducing minimal values 0 is always returned, for maximal - result from formula 2^bits - 1. Exception is SIZE_MAX: 2³² - 1 for systems with 32-bit architecture and 2⁶⁴ - 1 for systems with 64-bit architecture (same as sys.maxsize)

aveytense.constants.VERSION
→ str

≥ 0.3.26b3; < 0.3.47

Returns currently used version of AveyTense in a string. E.g. for 0.3.34 it will be "0.3.34". It is identical value as from PyPi. 0.3.47: Instead use aveytense.Tense.version.

aveytense.constants.VERSION_ID
→ int

≥ 0.3.26b3?; < 0.3.36

Returns integer value being identifier of current version (counted via length of VERSION_LIST minus 1). This is helper constant along with VERSION_INFO; easier to inspect with if statements. For 0.3.34 it returns 70.

0.3.35: consider using VERSION_INFO instead. This constant is weak even, if it based on length of VERSION_LIST tuple.

0.3.36

aveytense.constants.VERSION_LIST
→ tuple[str, ...]

≥ 0.3.26b3; < 0.3.36

Returns tuple of versions uploaded since version 0.2.1 (19th November 2022), including this version itself.

0.3.35: consider using VERSION_INFO instead. This constant seems to be enforced since not all versions are required to be included in a sequence, because they all appear on this page. It is also more difficult to inspect these versions via this constant anyway.

0.3.36

aveytense.constants.VERSION_INFO
→ <version info object>

≥ 0.3.26b3; < 0.3.47

Returns tuple containing all version components concerning current version of AveyTense. This sequence consists of following segments: major, minor, micro, release level. If release level doesn't have value "final", then additional integer item known as serial is added. Sometimes, even if release is final, it may have value 0. E.g. for 0.3.34 it will be (0, 3, 34, "final"), meanwhile for 0.3.27rc1 it would be (0, 3, 27, "candidate", 1). Purpose of this constant is the same as inspection of sys.version_info with if statements.

0.3.35: renamed from VERSION_TUPLE to VERSION_INFO.

0.3.40: this constant is now instance of local class, which features more detailed information concerning currently used version of AveyTense. 0.3.47: Instead use aveytense.Tense.versionInfo.

aveytense.constants.VERSION_INFO_TYPE
= <type(aveytense.constants.VERSION_INFO)

≥ 0.3.36; < 0.3.47

Type of aveytense.constants.VERSION_INFO. Probable intend of this type was inspecting ~.constants.VERSION_INFO with isinstance() inbuilt function. It is worth noticing ~.constants.VERSION_INFO_TYPE refers to internal abstract class (~.constants._VERSION_INFO), and the class itself is abstract to disallow custom versioning via its constructor. 0.3.47: Instead use type(~.constants.VERSION_INFO)

Content of `aveytense.Tense`

class aveytense.Tense
≥ 0.3.24

Heart of AveyTense project. Contains many methods, including for math, time, checking types and utility. It was called Tense08 before code reconstruction in 0.3.24.

All methods, except dunder ones, are class methods. If used via reference, dunder methods aren't
accessible, and will require the class instance. Instead, it is required to create an instance of this class
in order to access them.

0.3.26b3: this class is no longer final (can be subclassed).

aveytense.Tense.abroadImmutable(value1, /, value2 = None, modifier = None)
→ tuple[int, ...]

≥ 0.3.25; < 0.3.34

Variation of abroad() function, which returns immutable version of the sequence (in this case tuple). Alias to tuple(abroad()).

0.3.34 due to shortened notation with unary -: -abroad().

aveytense.Tense.abroadLive(*values)
→ ?

≥ 0.3.25; < 0.3.60

Variation of abroad() function referring to graph; every next value is next endpoint.

0.3.34: due to removal of class NennaiAbroads, method was moved to Tense class. 0.3.50

0.3.60

aveytense.Tense.abroadVivid(*values)
→ list[list[int]]

≥ 0.3.25; < 0.3.60

0.3.34: due to removal of class NennaiAbroads, method was moved to Tense class. 0.3.50

0.3.60

aveytense.Tense.all(i, /, condition = ...)
→ bool

≥ 0.3.26rc2

Roughly the same as all() inbuilt function. Returned is True, if all items satisfied condition. If it is an ellipsis, returned is True if conversion of all items to boolean returns True. This class method is paired with ~.Tense.any() class method.


              from aveytense import 

              .print(.all([3, 9, 6, 12], lambda x: x30)) True

              .print(.all([3, 9, 6, 12], lambda x: x20)) False

0.3.27a4: removed parameter default.

0.3.34: the method now returns boolean value instead of copy of the sequence.

0.3.36: if condition was a callable, it must return boolean value, otherwise will always return False.

0.3.39 0.3.40: condition now has default value ellipsis, support for None has been excised. Fixed internal code, as it was liable for errors

aveytense.Tense.any(i, /, condition = ...)
→ bool

≥ 0.3.26rc2

Roughly the same as any() inbuilt function. Returned is True, if at least one item satisfied condition. If it is an ellipsis, returned is True if conversion of at least one item to boolean returns True. This class method is paired with ~.Tense.all() class method.


              from aveytense import 

              .print(.any([3, 9, 6, 12], lambda x: x20)) True

              .print(.any([3, 9, 6, 12], lambda x: x70)) False

0.3.27a4: removed parameter default.

0.3.34: the method now returns boolean value instead of copy of the sequence.

0.3.39 0.3.40: condition now has default value ellipsis, support for None has been excised. Fixed internal code, as it was liable for errors

aveytense.Tense.append(i, /, *items)
→ list | dict | Generator | AsyncGenerator

≥ 0.3.27a4

Extension of list.append() method. Appends items from parameter items (in order as they appear) to a new list formalized from first parameter, and return this list. This class method is pure and paired with ~.Tense.extend() class method.

0.3.34: because code normally converts sequence to a list builtin, the method now accepts any iterables.

0.3.39 0.3.46: added support for mappings. In order as 2-item tuples appear in parameter items, these and the mapping will be returned in a new dictionary. If key (1st tuple item) already exists in a mapping or appear more times in provided tuples, its value is value from the key's last occurrence

0.3.55a1: Added support for asynchronous generators, and if first argument was a generator, then a generator is returned (earlier, generators returned a list).

aveytense.Tense.asyncGenerator(i: Iterable[T], /, condition: ((T) -> bool) = ...)
→ AsyncGenerator[T, Any] aveytense.Tense.asyncGenerator(i, /, condition = ...)
→ AsyncGenerator

≥ 0.3.53

Returns an asynchronous generator object using an iterable. Example:

$k[from] $m[aveytense] $k[import] $t[Tense] $v[asyncgen1] $o[=] $t[Tense].$tm[asyncGenerator]([$s[63], $s[96]]) <async_generator object <aveytense_async_generator> at 0x0000017AB790BF10> $v[asyncgen2] $o[=] $t[Tense].$tm[asyncGenerator]([$s[63], $s[96]], $k[lambda] $p[x]: $p[x] $o[%] $n[3] $o[==] $n[0]) <async_generator object <aveytense_async_generator> at 0x0000017AB790BF10>

Excluding type checking, this is roughly equivalent to:

$k[async] $k[def] $f[asyncgen_]($p[iterable], /, $p[condition]): $k[for] $v[e] $k[in] $p[iterable]: $k[if] $p[condition]($v[e]): $k[yield] $v[e] $v[asyncgen1] $o[=] $f[asyncgen_]([$s[63], $s[96]]) <async_generator object asyncgen1 at 0x0000017AB790BF10> $v[asyncgen2] $o[=] $f[asyncgen_]([$s[63], $s[96]], $k[lambda] $p[x]: $p[x] $o[%] $n[3] $o[==] $n[0]) <async_generator object asyncgen2 at 0x0000017AB790BF10>

aveytense.Tense.bisect(a, x, /, l = 0, h = None, dir = BISECT_RIGHT, *, key = None)
→ int

≥ 0.3.26rc2

Same as bisect.bisect() / bisect.bisect_left(), just dir parameter determines, which bisect function to invoke. Possible values:

Constant	Lifetime	Description
`~.Tense.BISECT_LEFT` / `~.constants.BISECT_LEFT`	≥ 0.3.26rc2; < 0.3.61 ≥ 0.3.35; < 0.3.61	Invokes `bisect.bisect_left()`.
`~.Tense.BISECT_RIGHT` / `~.constants.BISECT_RIGHT`	≥ 0.3.26rc2; < 0.3.61 ≥ 0.3.35; < 0.3.61	Invokes `bisect.bisect_right()`.

0.3.60

aveytense.Tense.cast(v, t, /)
= ("v" of type "t")

≥ 0.3.36

Same as typing.cast(), just parameters being in inverted places.

Passed value remains unchanged; this class method should be used to correct type hints. from import from typing import cast abhello! cast(str, a) .cast(a, str)

aveytense.Tense.clear(*v)
→ None

≥ 0.3.27a4

An impure class method that allows to clear many mutable sequences/sets/mappings at once. This method doesn't return anything, just like all of these methods: list.clear(), set.clear() and dict.clear().

0.3.27b1: strings are now allowed.

0.3.36: mutable sets are now allowed.

0.3.37: mutable mappings are now allowed, as well as instances of class aveytense.Color. In case of aveytense.Color class instances invoked is their instance method aveytense.Color.clear().

0.3.39

0.3.40: instances of types.FrameType are now allowed. Since this version strings are factually cleared; earlier, it was an unhandled issue despite it is normally supported. 0.3.50: added support for instances of typing.IO (more specifically, every object returned from function open()). In general, objects of classes extending classes from collections.abc: MutableSequence, MutableSet or MutableMapping are allowed, so not only inbuilt solutions such as lists, sets or dictionaries. Tests on clearing strings took some time to configure. To 0.3.40 it was an unhandled problem, because there was certainty it actually worked. Reason it didn't comes from fact that strings are practically immutable, just like tuples.

aveytense.Tense.copy(x) (≥ 0.3.34)

Same as copy.copy().

aveytense.Tense.count(...)
→ None

≥ 0.3.34; < 0.3.55

Equivalent to itertools.count.

Removed on 0.3.55; consider importing it from aveytense.extensions module instead.

aveytense.Tense.cycle(i, /)
→ None

≥ 0.3.34; < 0.3.55

Equivalent to itertools.cycle.

Removed on 0.3.55; consider importing it from aveytense.extensions module instead.

aveytense.Tense.deepcopy(x, memo = None, _nil = []) (≥ 0.3.34)

Same as copy.deepcopy().

aveytense.Tense.difference(v1, v2, /, invert = False, value_check = True) (≥ 0.3.32)

Extension of set.difference() instance method.
Returns items of first sequence that don't belong to second sequence, or vice versa, if invert is set to True.

0.3.34: the method now also accepts types, mappings and instances of abroad() function.

aveytense.Tense.endsWith(target, suffix, /, mode = Tense.OR, start = ..., end = ...)
→ bool

≥ 0.3.42

Currently experimental more developed mix of str.endswith() and bytes.endswith()

aveytense.Tense.equal(*v)
→ bool

≥ 0.3.41

Same as v[0] == v[1] and v[1] == v[2] and ... and v[n - 1] == v[n], where n is index for last item in v.

Difference between this class method and aveytense.Math.isConstant() (undocumented, but documented in code) is that it can be used for all types, and arbitrary amount of values can be passed (compared to isConstant() only one). Every value and their types must match to return True.

This class method is paired with aveytense.Tense.inequal().

aveytense.Tense.error(handler, message)
≥ 0.3.24; < 0.3.31

Defines an error to throw.

0.3.25

0.3.31

aveytense.Tense.eval(source, /)
aveytense.Tense.eval(source, /, globals = None, locals = None)
aveytense.Tense.eval(source, /, globals = None, locals = None,
flags = 0, dont_inherit = False, optimize = -1)
≥ 0.3.26rc2

Extension of eval() inbuilt Python function.

aveytense.Tense.exclude(i, /, *items, filter = "keys")
≥ 0.3.34

Inversion of ~.Tense.append(); this pure class method returns a new list without items specified in items. First parameter can be any iterable. This method is the same as [e for e in i if e not in items], omitting the fact there is no type checking. That means type of every element is ignored - code just hints type from iterable's type. from import .exclude([opened, ajar, closed], opened, closed) ['ajar'] 0.3.46: added support for mappings. In this case added optional parameter filter to indicate, what to exclude from pairs (keys or values). If target in a pair was found, this pair is excluded from returned dictionary. .exclude({ 12: 78, 15: 23, 12: 23 }, 12, filterkeys) {15: 23} .exclude({ 12: 78, 15: 23, 12: 23 }, 23, filtervalues) {12: 78}

aveytense.Tense.expect(i, m = ">= 1", /, condition = ...) aveytense.Tense.expect(i: Iterable[T], m: str | range | AbroadInitializer | AbstractSet[int] = ">= 1", /, condition: ((T) -> bool) = ...) -> bool ≥ 0.3.40

A class method working similarly as ~.any() and ~.all(), however, it is possible to enforce amount of items to satisfy condition in order to return True.

Parameter m (alias to matches) has the main role there. It has to be a special string literal, which will feature an integer (or keyword len) and comparison operator (from following: ==, !=, >=, <=, > and <), no matter in which order. len is shorthand keyword allowing to get literal iterables' sizes (not variables necessarily). This string determines about how many item matches need to be done to return True.

Default value for m is what it is. It equals following sentence: "equal or more than one item match", which is the same as invocation of ~.any(). Below table with example values for m:

`m` value	`~.expect()`	`not ~.expect()`
`">= 3" "3 <="`	item_matches ≥ 3	item_matches < 3
`"< 19" "19 >"`	item_matches < 19	item_matches ≥ 19
`"== 14" "14 =="`	item_matches = 14	item_matches ≠ 14
`"!= 23" "23 !="`	item_matches ≠ 23	item_matches = 23
`"<= len" "len >="`	item_matches ≤ iterable_length	item_matches > iterable_length

from import .expect([76, 66, 56, 46], >= 3, lambda x: Math.isComposite(x)) True; 4 matches satisfy ≥ 3 .expect([76, 66, 56, 46], < 2, lambda x: Math.isComposite(x)) False; 4 matches don't satisfy < 2 .expect([76, 66, 56, 46], > 3, lambda x: Math.isComposite(x)) TypeError: expected 'm' parameter to be a valid string literal, like "> 3" or 'None'; only integer + comparison operator (or vice versa) are permitted in the string .expect([76, 66, 56, 46], > 7, lambda x: Math.isComposite(x)) TypeError: expected an integer in range ⟨1; iterable_length⟩; passed 7 so it is bigger than iterable's length

If you want to append larger numbers, e.g. with scientific notation, you should modify it in following ways: .expect([76, 66, 56, 46], <= {}.format(int(2e+12)), lambda x: Math.isComposite(x)) .expect([76, 66, 56, 46], <= str(int(2e+12)), lambda x: Math.isComposite(x)) The len keyword allows to create ~.all() method using the following signature:

.expect(i, == len, condition) same as ~.all()

But for ~.any() method, signature doesn't use len keyword. Reason it doesn't is because "<= len" will be satisfied also for no matches overall.

.expect(i, >= 1, condition) same as ~.any()

Case for m is sensitive, so e.g. LEN will be invalid and will throw TypeError. 0.3.45: added support for integer set, abroad and range objects in parameter m. Support was predicted for version 0.3.48.

aveytense.Tense.explode(s, /, separator = None, max = -1, noEmpty = False) aveytense.Tense.explode(s: str, /, separator: str | None = None, max: int = -1,
noEmpty: bool = False) -> list[str] ≥ 0.3.34

Name reference to PHP inbuilt function explode() and equivalent to inbuilt string method str.split().

0.3.34

0.3.51: renamed parameter no_empty to noEmpty.

aveytense.Tense.extend(i, /, *iters) aveytense.Tense.extend(i: Mapping[KT1, VT1], /,
*iters: Mapping[KT2, VT2]) -> dict[KT1|KT2, VT1|VT2]
aveytense.Tense.extend(i: Iterable[T1], /,
*iters: Iterable[T2]) -> list[T1|T2]
≥ 0.3.27a4

Appends items from all iterables (in order as they appear) to a new list formalized from first parameter, and return this list. This class method is pure and paired with ~.Tense.append() class method. Typically this class method is extension of inbuilt list method list.extend(). $k[from] $m[aveytense] $k[import] $t[Tense] $t[Tense].$tm[extend]([$s[e]], {$s[f], $s[g]}, ($s[h],)) # ['e', 'f', 'g', 'h']

0.3.27a4

0.3.34: because code normally converts sequence to a list builtin, the method now accepts any iterables.

0.3.39 0.3.46: added support for mappings. In order as they appear in both parameters, these will be returned in a new dictionary. If key in 2 or more mappings are the same, its value is value from the key's last occurrence. Example: $t[Tense].$tm[extend]({$n[1]: $n[87]}, {$n[2]: $n[70], $n[3]: $n[112]}, {$n[1], $n[96]}) # {1: 96, 2: 70, 3: 112}

aveytense.Tense.first(i: Sequence[T] | AbstractSet[T], /, condition: ((T) -> bool) | None = None,
default: S = None) -> T|S aveytense.Tense.first(i, /, condition = None, default = None)

≥ 0.3.26rc2

Returns first item from sequence, which satisfied condition or default, if none satisfied condition. This class method is paired with ~.Tense.last() class method.

0.3.26rc2

0.3.27a4: removed parameter default.

0.3.34: restored parameter default.

0.3.39

aveytense.Tense.getAttr(o: object, names: str | Sequence[str] | Set[str], default: T = None )
→ Any | T aveytense.Tense.getAttr(o, names, default = None)
→ Any

≥ 0.3.58

More developed version of inbuilt function getattr(). Allows to use multiple attribute names at once, and returns value of the first accessible one. Roughly equivalent to:

$k[def] $f[getAttr]($p[o], $p[names], $p[default] = None): $k[if] $f[isinstance]($p[names], $c[str]): $v[seq] $o[=] $p[names].$f[strip]().$f[split]( ]) $k[else]: $v[seq] $o[=] $c[list]($p[names]) $v[seq] $o[=] $c[list]($c[filter]($k[lambda] $p[x]: $f[len]($p[x]) > $n[0], $v[seq])) $k[for] $v[attr] $k[in] $v[names]: $k[if] $f[hasattr]($p[o], $v[attr]): $k[return] $f[getattr]($p[o], $v[attr]) $k[return] $p[default]

0.3.58

0.3.59: added support for multiple names in a string separated by spaces in parameter names

aveytense.Tense.getGeneric(v, /, tupleEllipsis = False) aveytense.Tense.getGeneric(v: typing.Any, /, tupleEllipsis: bool = False) -> (types.GenericAlias | None) ≥ 0.3.52

Returns types.GenericAlias instance from a target value or None if it is not possible. Can be referred as better equivalent of typing.reveal_type()

In case of objects of classes being subclasses of ABCs from collections.abc, Sequence, AbstractSet and Mapping are doing pretty well:

$k[from] $m[aveytense] $k[import] $t[Tense] $k[from] $m[aveytense].$msu[extensions] $k[import] $o[*] $k[assert] $t[Tense].$tm[getGeneric]([$n[72]]) $o[==] $c[AVT_List][$c[int]] $k[assert] $t[Tense].$tm[getGeneric]({$n[72]}) $o[==] $c[AVT_Set][$c[int]] $k[assert] $t[Tense].$tm[getGeneric]([$n[72], $s[78]]) $o[==] $c[AVT_List][$c[Union][$c[int], $c[str]]] $k[assert] $t[Tense].$tm[getGeneric]({$n[72]: $s[78]}) $o[==] $c[AVT_Dict][$c[int], $c[str]]

About types starting with prefix AVT_ visit this page. These are shown in the example to accord every Python version (since 3.8). For example: list[int] will be invalid in Python versions before 3.9.

Support for Awaitable, Generator and Coroutine is partial. Perhaps generators are iterable, and to get generator from a coroutine there is __await__() method from Awaitable, generic alias from both are addicted to origin and first type parameter known as yield (in Awaitable class there is only one type parameter), and the rest parameters (known as send and return) have value typing.Any (unlike normally these have value None):

# clarification: # - Generator[YieldType, SendType, ReturnType] # - Coroutine[YieldType, SendType, ReturnType] # - Awaitable[ReturnType] $k[assert] $t[Tense].$tm[getGeneric]($t[Tense].$tm[generator]([$v[i] $k[for] $v[i] $k[in] ($n[1], $n[2], $n[3])])) $o[==] $c[AVT_Generator][$c[int], $c[Any], $c[Any]] $k[assert] $t[Tense].$tm[getGeneric]($t[Tense].$tm[generator]([$v[i] $k[for] $v[i] $k[in] ($n[1], $s[2])])) $o[==] $c[AVT_Generator][$c[Union][$c[int], $c[str]], $c[Any], $c[Any]]

It is better to use generator objects over Coroutine and Awaitable instances. Since Python 3.13, the close() generator method can return the return type parameter after closing the generator. This subject will be under thoughts. Intention would be copying generator's content before closing procedure. However, this will be only for Python 3.13 and later.

Same goes with Callable. When an annotation is not defined in a parameter, including the return annotation, then typing.Any is used. Every parameter also lose their parameter category (positional, universal, keyword) and their default values:

$k[assert] $t[Tense].$tm[getGeneric]($k[lambda] $p[x]: $con[None]) $o[==] $c[AVT_Callable][[$c[Any]], $c[Any]] $tv[_T] $o[=] $c[TypeVar]($s[_T]) # for context, 'aveytense.Tense.expect()' has same annotations as on the right of == operator, # the Callable's arguments. the return type is boolean, but there is no return type annotation, # hence 'typing.Any' $k[assert] $t[Tense].$tm[getGeneric]($t[Tense].$tm[expect]) $o[==] $c[AVT_Callable][[$c[AVT_Iterable][$tv[_T]], $c[Union][$c[str], $c[range], $c[AbroadType], $c[AVT_Uniqual][$c[int]]], $c[AVT_Callable][[$tv[_T]], $c[bool]]], $c[Any]] # AssertionError $k[assert] $c[str]($t[Tense].$tm[getGeneric]($t[Tense].$tm[expect])) $o[==] $c[str]($c[Callable][[$c[AVT_Iterable][$tv[_T]], $c[Union][$c[str], $c[range], $c[AbroadType], $c[AVT_Uniqual][$c[int]]], $c[AVT_Callable][[$tv[_T]], $c[bool]]], $c[Any]]) # no AssertionError

If generic alias returned from aveytense.Tense.getGeneric() class method can't match another generic alias built using generic alias syntax, however, are nearly identical, it is good to inspect both with the str class constructor. When value is already a generic alias, it is returned.

0.3.52

0.3.53: Abstract base classes AsyncIterable, AsyncIterator, AsyncGenerator, ItemsView, KeysView and ValuesView are now supported, enhanced segment with Iterator and added optional parameter tupleEllipsis for returned generic version of tuple. Fixed tuples at all (generic alias always had only one, no matter if union, type argument). For mapping views, to prevent name inaccuracy, there are 3 new classes in aveytense.types:

aveytense.types.DictItems
aveytense.types.DictKeys
aveytense.types.DictValues

Denomination reference for mapping views are classes in _collections_abc internal Python module: dict_items, dict_keys and dict_values, meanwhile creating asynchronous generators is much easier with the new class method aveytense.Tense.asyncGenerator().

Examples:

### iterators $k[assert] $t[Tense].$tm[getGeneric]($f[iter]($c[list]())) $o[==] $c[AVT_Iterator][$c[list][$c[Any]]] $k[assert] $t[Tense].$tm[getGeneric]($f[iter]([$n[72]])) $o[==] $c[AVT_Iterator][$c[list][$c[int]]] $k[assert] $t[Tense].$tm[getGeneric]($f[iter]($c[bytes]())) $o[==] $c[AVT_Iterator][$c[bytes]] ### tuples $k[assert] $t[Tense].$tm[getGeneric](($n[72], $n[720])) $o[==] $c[AVT_Tuple][$c[int], $c[int]] $k[assert] $t[Tense].$tm[getGeneric](($n[72], $n[720]), $p[tupleEllipsis] $o[=] $con[True]) $o[==] $c[AVT_Tuple][$c[int], $o[...]] $k[assert] $t[Tense].$tm[getGeneric](($n[72], $s[720])) $o[==] $c[AVT_Tuple][$c[int], $c[str]] $k[assert] $t[Tense].$tm[getGeneric](($n[72], $s[720]), $p[tupleEllipsis] $o[=] $con[True]) $o[==] $c[AVT_Tuple][$c[Union][$c[int], $c[str]], $o[...]] ### asynchronous generator $k[assert] $t[Tense].$tm[getGeneric]($t[Tense].$tm[asyncGenerator]([$v[i] $k[for] $v[i] $k[in] ($n[1], $n[2], $n[3])])) $o[==] $c[AVT_AsyncGenerator][$c[int], $c[Any]] $k[assert] $t[Tense].$tm[getGeneric]($t[Tense].$tm[asyncGenerator]([$v[i] $k[for] $v[i] $k[in] ($n[1], $n[2], $s[3])])) $o[==] $c[AVT_AsyncGenerator][$c[Union][$c[int], $c[str]], $c[Any]] ### mapping views # ≥ 3.10 $k[assert] $t[Tense].$tm[getGeneric]({$n[78]: $n[96]}.$f[keys]()) $o[==] $c[DictKeys][$c[int], $c[int]] $k[assert] $t[Tense].$tm[getGeneric]({$n[78]: $n[96]}.$f[values]()) $o[==] $c[DictValues][$c[int], $c[int]] $k[assert] $t[Tense].$tm[getGeneric]({$n[78]: $n[96]}.$f[items]()) $o[==] $c[DictItems][$c[int], $c[int]] # < 3.10 $k[assert] $t[Tense].$tm[getGeneric]({$n[78]: $n[96]}.$f[keys]()) $o[==] $c[DictKeys][$c[int], $c[Any]] $k[assert] $t[Tense].$tm[getGeneric]({$n[78]: $n[96]}.$f[values]()) $o[==] $c[DictValues][$c[Any], $c[int]] $k[assert] $t[Tense].$tm[getGeneric]({$n[78]: $n[96]}.$f[items]()) $o[==] $c[DictItems][$c[int], $c[int]]

0.3.54: Instances of array.array and memoryview are now supported.

# footnote: 'array.array' can be imported from 'aveytense.extensions' too $k[assert] $t[Tense].$tm[getGeneric]($c[array]($s[i], [$n[72], $n[96]])) $o[==] $c[AVT_Array][$c[int]] $k[assert] $t[Tense].$tm[getGeneric]($c[memoryview]($k[b]$s[63bac])) $o[==] $c[AVT_MemoryView][$c[int]]

If aveytense.Tense.getGeneric() gets an instance of array.array, type parameter value for aveytense.extensions.AVT_Array will hinge on property array.array.typecode. There are 3 distinct results:

return AVT_Array[int] for array.array.typecode equal 'b', 'B', 'h', 'H', 'i', 'I', 'l', 'L', 'q' or 'Q'

return AVT_Array[float] for array.array.typecode equal 'f' or 'd'

return AVT_Array[str] for array.array.typecode equal 'u' or 'w'

If aveytense.Tense.getGeneric() gets an instance of memoryview, type parameter value for aveytense.extensions.AVT_MemoryView will depend on property memoryview.format. There are 4 distinct results:

return AVT_MemoryView[int] for memoryview.format equal 'b', 'B', 'h', 'H', 'i', 'I', 'l', 'L', 'q', 'Q', 'P', '@b', '@B', '@h', '@H', '@i', '@I', '@l', '@L', '@q', '@Q' or '@P'

return AVT_MemoryView[float] for memoryview.format equal 'f', 'd', '@f' or '@d'

return AVT_MemoryView[bytes] for memoryview.format equal 'c' or '@c'

return AVT_MemoryView[bool] for memoryview.format equal '?'

It is worth noticing that returned generic alias of a dict class can be a lot more complex if e.g. vars() or frame object property such as f_locals or f_globals is passed. Value types will be gleaned in the second type parameter (aka the value type parameter) and their count will be huge. This complexity is not good for comparing 2 generic aliases returned from aveytense.Tense.getGeneric(). It is recommended to use their __args__ attribute in this case (value types - __args__[1].__args__).

aveytense.Tense.group(*statements, mode = "and-or") aveytense.Tense.group(*statements: Sequence[bool] | AbstractSet[bool], mode: str = "and-or") -> bool ≥ 0.3.34

Returns one boolean value combining all statements into one boolean value.
Parameter mode determines about used logical operators inside and outside provided sequences.
Those are, respectively: before and after the - sign. Every sequence must contain boolean values.

Allowed are following modes:

"and-and"
"and-or"
"and-nand" (since 0.3.40)
"and-nor"
"or-and"
"or-or"
"or-nand"
"or-nor" (since 0.3.40)
"nand-and" (since 0.3.40)
"nand-or"
"nand-nand"
"nand-nor"
"nor-and"
"nor-nand"
"nor-or" (since 0.3.40)
"nor-nor"

If you aren't familiar with nor and nand, those are actually equal to, respectively: not OR and not AND. This variation of mode parameter isn't the same as in there.

0.3.40: Case for mode parameter is now insensitive, and added lacking modes: and-nand, nand-and, or-nor and nor-or.

aveytense.Tense.groupby
≥ 0.3.35

Type alias for iterools.groupby

aveytense.Tense.hasAttr(o, attr, /, mode = "or")
≥ 0.3.34

Extension of inbuilt function hasattr(), used to detect many attributes at once via parameter attr.
Parameter mode only takes place whether attr is a string tuple.


                from aveytense import 

                a{3: 3}

                .print(.hasattr(a, values)) True

                .print(.hasattr(a, (values, keys))) True

                .print(.hasattr(a, (values, abroad))) True

                .print(.hasattr(a, (values, abroad), modeand)) False

0.3.39 0.3.49: many objects can be inspected. In this case o parameter must be a tuple of objects to take place. However, class method permits check only one attribute at once.

aveytense.Tense.improvedBogoSort(i, /, key = ...)
→ tuple[int, list[Any]]

≥ 0.3.42

Returns accesses as an integer and sorted iterable as a list in a 2-item tuple. Bogosort uses constant shuffling until the sequence is sorted.

aveytense.Tense.inequal(*v)
≥ 0.3.41

Same as v[0] != v[1] and v[1] != v[2] and ... and v[n - 1] != v[n], where n is index for last item in v.

This class method can be used to detect, if a sequence has only unique items by using unpacking operator *. If at least one value repeats, or has different type than all other values, then False is returned.

This class method is paired with aveytense.Tense.equal().

aveytense.Tense.insort(a, x, /, l = 0, h = None,
dir = INSORT_LEFT, *, key = None)
≥ 0.3.26rc2; < 0.3.60

Same as bisect.insort() / bisect.insort_left(), just dir parameter determines, which insort function to invoke. Possible values:

Constant	Lifetime	Description
`~.Tense.INSORT_LEFT` / `~.constants.INSORT_LEFT`	≥ 0.3.26rc2; < 0.3.61 ≥ 0.3.35; < 0.3.61	Invokes `bisect.insort_left()`.
`~.Tense.INSORT_RIGHT` / `~.constants.INSORT_RIGHT`	≥ 0.3.26rc2; < 0.3.61 ≥ 0.3.35; < 0.3.61	Invokes `bisect.insort_right()`.

0.3.60

aveytense.Tense.intersection(v, /, *_)
≥ 0.3.34

Returns boolean, integer or iterables intersection, depending, which one is passed to the first parameter.
For integers, returned is bitwise AND of all integers (v & _[0] & _[1] & ...).
For boolean values, returned is logical AND (v and _[0] and _[1] and ...).
For iterables, used is set(v).intersection(*_).

This class method is paired with ~.Tense.union().

aveytense.Tense.isAbroad(v, /, *_, mode = MODE_AND)
≥ 0.3.50

Used to inspect abroad objects.

aveytense.Tense.isBool(v, /, *_, mode = MODE_AND)
aveytense.Tense.isBoolean(v, /, *_, mode = MODE_AND)
1. ≥ 0.3.26b3
2. ≥ 0.3.26rc1

Determine whether passed object is a bool object.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isByteArray(v, /, *_, mode = MODE_AND)
≥ 0.3.35

Determine whether passed object is a bytearray object.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isBytes(v, /, *_, mode = MODE_AND)
≥ 0.3.35

Determine whether passed object is a bytes object.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isComplex(v, /, *_, mode = MODE_AND)
≥ 0.3.26b3

Determine whether passed object is a complex object.


                from aveytense import 

                a6572j

                b68

                .print(.isComplex(a)) True

                .print(.isComplex(b)) False

                
                since 0.3.36, see change note below

                .print(.isComplex(a, b)) False

                .print(.isComplex(a, b, modeand)) False

                .print(.isComplex(a, b, modeor)) True

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isDict(v, /, ktype = Any, vtype = Any)
≥ 0.3.31

Determine whether passed object is a dict object.

$k[from] $m[aveytense] $k[import] $o[*] $k[from] $m[aveytense].$msu[extensions] $k[import] $c[Union] $v[a] $o[=] {$n[3]: $s[3]} $t[Tense].$tm[print]($t[Tense].$tm[isDict]($v[a])) # True ### ≥ 0.3.34 $t[Tense].$tm[print]($t[Tense].$tm[isDict]($v[a], $c[int])) # True $t[Tense].$tm[print]($t[Tense].$tm[isDict]($v[a], $c[int], $c[str])) # True $t[Tense].$tm[print]($t[Tense].$tm[isDict]($v[a], $c[str], $c[int])) # False ### ≥ 0.3.35 $t[Tense].$tm[print]($t[Tense].$tm[isDict]($v[a], ($c[int], $c[str]), $c[int])) # False $t[Tense].$tm[print]($t[Tense].$tm[isDict]($v[a], ($c[int], $c[str]), ($c[int], $c[str]))) # True

0.3.34: added parameters ktype and vtype to enhance dict type checking.
ktype is demanded type for keys and vtype is demanded type for values.

0.3.35: ktype and vtype now support union types. In this case it is required to wrap these in a tuple. Examples:

isDict(v, ()) and isDict(v, (), ()) are the same as isDict(v)
isDict(v, (int, str)) is the same as isDict(v, int) or isDict(v, str) (key must be of type either int or str)
isDict(v, (int, str), str) means key must be of type either int or str, and value must be of type str
isDict(v, (int, str), (int, str)) means key and value must be of types either int or str

0.3.36: type now supports union types with typing.Union and since Python 3.10: X | Y | .... This also patched an error when using these for version 0.3.35; instead of type(int | str) it is now freely possible to use int | str. In the same version provided initial support for generic types, which may be extended in further versions.

It is recommended to use bool(~.Tense.isDict(...)) if type hinting doesn't work as intended.

aveytense.Tense.isEllipsis(v, /, *_, mode = MODE_AND)
≥ 0.3.26

Determine whether passed object is an Ellipsis object.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isFinalClass(v, /, *_, mode = MODE_AND)
≥ 0.3.41

Returns True, if value is a final class.

aveytense.Tense.isFinalProperty(v, /, *_, mode = MODE_AND)
≥ 0.3.41

Returns True, if value is instance of aveytense.util.finalproperty class.

aveytense.Tense.isFinalVar(v, /, *_, mode = MODE_AND)
≥ 0.3.38

Determine whether passed object is an instance of class aveytense.util.FinalVar.

aveytense.Tense.isFloat(v, /, *_, mode = MODE_AND)
≥ 0.3.26b3

Determine whether passed object is a float object.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isFrozenSet(v, /, type = Any)
≥ 0.3.35

Determine whether passed object is a frozenset object.
Parameter type allows to enhance frozenset type checking. For union types, wrap types in a tuple. Examples:

isFrozenSet(v, ()) is the same as isFrozenSet(v)
isFrozenSet(v, (int, str)) is the same as isFrozenSet(v, int) or isFrozenSet(v, str) (either int or str)

It is recommended to use bool(~.Tense.isFrozenSet(...)) if type hinting doesn't work as intended.

aveytense.Tense.isGeneric(v, /, *_, mode = MODE_AND)
≥ 0.3.53

Determine whether a value is a generic class. First code checks if it is a subclass of typing.Generic, then it looks for the __class_getitem__() method, which is supposed to return instance of types.GenericAlias (available since Python 3.9). The second statement is ignored when using Python 3.8.

aveytense.Tense.isInt(v, /, *_, mode = MODE_AND)
aveytense.Tense.isInteger(v, /, *_, mode = MODE_AND)
1. ≥ 0.3.26b3
2. ≥ 0.3.26rc1

Determine whether passed object is an int object.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isMemoryView(v, /, *_, mode = MODE_AND)
≥ 0.3.35

Determine whether passed object is memoryview object.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isNone(v, /, *_, mode = MODE_AND)
≥ 0.3.26b3

Determine whether passed object is None.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isSet(v, /, type = Any)
≥ 0.3.35

Determine whether passed object is a set object. Parameter type allows to enhance set type checking. For union types, wrap types in a tuple. Examples: $k[from] $m[aveytense] $k[import] $o[*] $k[from] $m[aveytense].$msu[extensions] $k[import] $c[Union] $t[Tense].$tm[print]($t[Tense].$tm[isSet]({$n[54]})) # True $t[Tense].$tm[print]($t[Tense].$tm[isSet]([$n[54]])) # False $t[Tense].$tm[print]($t[Tense].$tm[isSet]({$n[54]}, ())) # True $t[Tense].$tm[print]($t[Tense].$tm[isSet]({$n[54]}, $c[int])) # True $t[Tense].$tm[print]($t[Tense].$tm[isSet]({$n[54]}, $c[str])) # False $t[Tense].$tm[print]($t[Tense].$tm[isSet]({$n[54]}, ($c[int], $c[str]))) # True $t[Tense].$tm[print]($t[Tense].$tm[isSet]({$n[54]}, ($c[float], $c[str]))) # False ### ≥ 0.3.36 $t[Tense].$tm[print]($t[Tense].$tm[isSet]({$n[54]}, $c[Union][$c[int], $c[str]])) # True $t[Tense].$tm[print]($t[Tense].$tm[isSet]({$n[54]}, $c[Union][$c[float], $c[str]])) # False

It is recommended to use bool(~.Tense.isSet(...)) if type hinting doesn't work as intended.

aveytense.Tense.isStr(v: Any, /, *_: Any, mode: _Mode = MODE_AND) -> bool
aveytense.Tense.isString(v: Any, /, *_: Any, mode: _Mode = MODE_AND) -> bool (where _Mode = Literal["and", "or", MODE_AND, MODE_OR]) aveytense.Tense.isStr(v, /, *_, mode = MODE_AND)
aveytense.Tense.isString(v, /, *_, mode = MODE_AND) 1. ≥ 0.3.26b3
2. ≥ 0.3.26rc1

Determine whether passed object is a str object.

0.3.36: many values may be now inspected. Previous signature (v, /) is now an overload.

aveytense.Tense.isTuple(v: Any, /, type: type = Any) -> bool aveytense.Tense.isTuple(v, /, type = Any) ≥ 0.3.26rc1

Determine whether passed object is a tuple object.

$k[from] $m[aveytense] $k[import] $o[*] $k[from] $m[aveytense].$msu[extensions] $k[import] $c[Union] $t[Tense].$tm[print]($t[Tense].$tm[isTuple](($n[72],))) # True $t[Tense].$tm[print]($t[Tense].$tm[isTuple]([$n[72],])) # False ### ≥ 0.3.34 $t[Tense].$tm[print]($t[Tense].$tm[isTuple](($n[72],), ())) # True $t[Tense].$tm[print]($t[Tense].$tm[isTuple](($n[72],), $c[int])) # True $t[Tense].$tm[print]($t[Tense].$tm[isTuple](($n[72],), $c[str])) # False ### ≥ 0.3.35 $t[Tense].$tm[print]($t[Tense].$tm[isTuple](($n[72],), ($c[int], $c[str]))) # True $t[Tense].$tm[print]($t[Tense].$tm[isTuple](($n[72],), ($c[float], $c[str]))) # False ### ≥ 0.3.36 $t[Tense].$tm[print]($t[Tense].$tm[isTuple](($n[72],), $c[Union][$c[int], $c[str]])) # True $t[Tense].$tm[print]($t[Tense].$tm[isTuple](($n[72],), $c[Union][$c[float], $c[str]])) # False

0.3.34: added parameter type to enhance tuple type checking.

0.3.35: parameter type now supports union types. In this case it is required to wrap these in a tuple. Examples:

isTuple(v, ()) is the same as isTuple(v)
isTuple(v, (int, str)) is the same as isTuple(v, int) or isTuple(v, str) (either int or str)

It is recommended to use bool(~.Tense.isTuple(...)) if type hinting doesn't work as intended.

aveytense.Tense.isTuple2(v1: tuple, v2: tuple[type, ...], /) -> bool aveytense.Tense.isTuple2(v1, v2, /) ≥ 0.3.43

Extension of ~.Tense.isTuple() class method and inbuilt function isinstance(). Returns True, if type requirement for all items in first parameter from second parameter are satisfied. This class method is the experimental concept with types parameter in method ~.Tense.isTuple(), which was finally revoked in version 0.3.34, to decrease strictness of this method and after conclusion it didn't work as intended. Both v1 and v2 must be tuples; in case of v2 a tuple of types only. Value assignment in v2 parameter is similar to type parameter in ~.Tense.isTuple() class method, however, types themselves must be encased in a tuple, as in examples below. Returned boolean value is addicted to both parameters v1 and v2. This class method uses the following rules:

If v2 tuple has size least than v1 tuple, then v2 tuple last item has to satisfy the remaining items in v1 tuple.
If v2 tuple has the same size as v1 tuple, each item in v1 tuple has its type requirement with same indexes as in v2 tuple.
If v2 tuple has size greater than v1 tuple, then TypeError is thrown.

Examples: $k[from] $m[aveytense] $k[import] $o[*] $t[Tense].$m[print]($t[Tense].$tm[isTuple2]((), ())) # True $t[Tense].$m[print]($t[Tense].$tm[isTuple2]((), ($msu[util].$v[Any],))) # True $t[Tense].$m[print]($t[Tense].$tm[isTuple2]((), ($msu[util].$v[Any], $msu[util].$v[Any]))) # False $t[Tense].$m[print]($t[Tense].$tm[isTuple2]((), ($msu[util].$v[Any], $msu[util].$v[Any], $msu[util].$v[Any]))) # False $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), ($c[int],))) # True; same as ~.Tense.isTuple((132, 432), int) $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), ($c[int], $c[int]))) # True $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), ($c[int], $c[int], $c[int]))) # throws TypeError $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), (($c[int], $c[str]),))) # True; same as ~.Tense.isTuple((132, 432), (int, str)) $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), ($c[int], $c[str]))) # False; NOT same as ~.Tense.isTuple((132, 432), (int, str)) $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), ($c[str],))) # False; same as ~.Tense.isTuple((132, 432), str) $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), (($c[int], $c[str]), int))) # True $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), (($c[int], $c[str]), str))) # False $t[Tense].$m[print]($t[Tense].$tm[isTuple2](($n[132], $n[432]), (($c[int], $c[str]), ($c[int], $c[str])))) # True

It is recommended to use bool(~.Tense.isTuple2(...)) if type hinting doesn't work as intended.

aveytense.Tense.last(i: Sequence[T] | AbstractSet[T], /, condition: ((T) -> bool) | None = None,
default: S = None) -> T|S aveytense.Tense.last(i, /, condition = None, default = None) ≥ 0.3.26rc2

Returns the last item from sequence, which satisfied condition or default, if none satisfied condition. This class method is paired with ~.Tense.first() class method.

0.3.27a4: removed parameter default.

0.3.34: restored parameter default.

aveytense.Tense.occurrences(v: <mixed>, *items: <mixed>, mode: <mixed> = ...) -> int aveytense.Tense.occurrences(v, *items, mode = ...) ≥ 0.3.32

Returns amount of times whether item or items appear in specified sequence. This is like how str.count() string method works, just it applies to de facto every type of sequences.

aveytense.Tense.pick(i: Sequence[T] | AbstractSet[T] | Mapping[T, Any], /) -> T aveytense.Tense.pick(i, /) ≥ 0.3.8

Returns a random item from a sequence. This class method is more developed version of random.choice().

0.3.34: added support for mappings and new parameter secure to generate cryptographically safe result. The secure parameter was actually a reference of re-implemented pseudo-random functions in inbuilt Python module secrets, especially words cryptographically secure. This parameter has been removed on 0.3.51, because both secrets.choice() and random.choice() seem to be the same to each other. 0.3.51: removed parameter secure (see note above).

aveytense.Tense.random(x: Sequence[T] | AbstractSet[T], /) -> T
aveytense.Tense.random(x: int, /) -> int
aveytense.Tense.random(x: int, y: int, /) -> int aveytense.Tense.random(x, y = None, /) ≥ 0.3.24

If y is None, returns random item from sequence or integer from range [0, x], otherwise returns integer from range [x, y], depending which one is greater.

0.3.34: support for sequences and single integer.

aveytense.Tense.repeat(value: T, times: Optional[int] = None, /) -> Generator[T, Any, None] aveytense.Tense.repeat(value, times = None, /) ≥ 0.3.25

Re-implementation of itertools.repeat().

Repeats value specified amount of times and returns a generator. In previous versions this class method can return a list.

aveytense.Tense.reverse(v: str) -> str
aveytense.Tense.reverse(v: ~.util.MutableString) -> ~.util.MutableString
aveytense.Tense.reverse(v: AbroadInitializer) -> list[int]
aveytense.Tense.reverse(v: Sequence[T] | AbstractSet[T]) -> list[T]
aveytense.Tense.reverse(v: Generator[Yield, Send, Return]) -> Generator[Yield, Send, Return]
aveytense.Tense.reverse(v: AsyncGenerator[Yield, Send]) -> AsyncGenerator[Yield, Send]
aveytense.Tense.reverse(v: Mapping[KT, VT]) -> dict[KT, VT]
aveytense.Tense.reverse(v: Reversible[T]) -> Iterator[T]
aveytense.Tense.reverse(v) ≥ 0.3.26rc2

A pure class method returning reversed version of an iterable passed to the parameter. It is bound with use of slicing [::-1] and the reversed class. See changes below for type support. Primal supported types are sequences, including strings. This class method is paired with ~.Tense.shuffle() class method. $k[from] $m[aveytense] $k[import] $t[Tense] $v[a] $o[=] $s[hello!] $t[Tense].$tm[print]($t[Tense].$tm[reverse]($v[a]), $v[a]) # "!olleh" "hello!"

0.3.34: added support for mappings and abroad objects. 0.3.42: instances of classes inheriting collections.abc.AbstractSet (including set class) now return a shuffled set inbuilt class instance. Earlier, these returned shuffled list. Added support for generators (these return list). 0.3.43: added support for ~.util.MutableString instances. 0.3.45: sets return list (sets are always placed ascendingly) 0.3.53: generators now return generators, added support for asynchronous generators

aveytense.Tense.shuffle(v: str) -> str
aveytense.Tense.shuffle(v: ~.util.MutableString) -> ~.util.MutableString
aveytense.Tense.shuffle(v: AbroadInitializer) -> list[int]
aveytense.Tense.shuffle(v: Sequence[T] | AbstractSet[T]) -> list[T]
aveytense.Tense.shuffle(v: Generator[Yield, Send, Return]) -> Generator[Yield, Send, Return]
aveytense.Tense.shuffle(v: AsyncGenerator[Yield, Send]) -> AsyncGenerator[Yield, Send]
aveytense.Tense.shuffle(v: Mapping[KT, VT]) -> dict[KT, VT]
aveytense.Tense.shuffle(v) ≥ 0.3.26rc2

A pure class method returning shuffled version of an iterable passed to the parameter. It is bound with use of random.shuffle() impure function. See changes below for types support. Primal supported types are sequences, including strings. This class method is paired with ~.Tense.reverse() class method. $k[from] $m[aveytense] $k[import] $t[Tense] $v[a] $o[=] $s[hello!] $t[Tense].$tm[print]($t[Tense].$tm[shuffle]($v[a]), $v[a]) # "ohl!el" "hello!"

0.3.34: added support for mappings and abroad objects. 0.3.42: instances of classes inheriting collections.abc.AbstractSet (including set class) now return a reversed set inbuilt class instance. Earlier, these returned reversed list. Added support for generators (these return list) and instances of classes inheriting collections.abc.Reversible. 0.3.43: added support for ~.util.MutableString instances. 0.3.45: sets return list (sets are always placed ascendingly) 0.3.53: generators now return generators, added support for asynchronous generators

aveytense.Tense.sleep(seconds: float, /) -> ~.Tense (≥ 0.3.46) aveytense.Tense.sleep(seconds, /) ≥ 0.3.25

Equivalent to time.sleep(), just returns reference to ~.Tense instead of None. AveyTense owner's footnote: This might be equal to passing value of time.time() function to an internal variable, and using the while loop with statement while time.time() - <var> ≥ seconds: <var> = time.time().

aveytense.Tense.starmap(f, i, /)
≥ 0.3.35

Equivalent to itertools.starmap.

aveytense.Tense.startswith(target, prefix, /, mode = constants.MODE_OR, start = ..., end = ...)
≥ 0.3.42

Blend of str.startwith() and bytes.startwith() that allows to inspect many values at once.

aveytense.Tense.test(target, pattern, flags = 0)
≥ 0.3.42

Equivalent to re.match(pattern, target, flags) is not None. Noteworthy that target and pattern parameters, unlike in re.match() function, have inverted positions. Name of this class method is reference to JavaScript method RegExp.test().

aveytense.Tense.timeit(statement: () -> Any, /) -> float aveytense.Tense.timeit(statement, /) ≥ 0.3.26rc3

Returns invocation time of specified statement. This class method is simplified version of timeit.timeit() function. To invoke callable with arguments, use lambda: <func-name>(...).

$k[from] $m[aveytense] $k[import] $o[*] $t[Tense].$tm[print]($t[Tense].$tm[timeit]($k[lambda]: $t[Tense].$tm[generator]([$n[66]]))) # 1.52587890625e-05 $t[Tense].$tm[print]($t[Tense].$tm[timeit]($k[lambda]: $c[Math].$f[fact]($n[66]))) # 4.76837158203125e-06 $t[Tense].$tm[print]($t[Tense].$tm[timeit]($k[lambda]: $a[d]($n[66]))) # 5.91278076171875e-05 $t[Tense].$tm[print]($t[Tense].$tm[timeit]($k[lambda]: $n[66])) # 9.5367431640625e-07

aveytense.Tense.union(v, /, *_)
≥ 0.3.34

Returns boolean, integer or iterables union, depending, which one is passed to the first parameter.

aveytense.Tense.until(desiredString, /, message = None, caseInsensitive = True)
≥ 0.3.25

Console-specific method, creates a while loop and it ends until user writes desired string, or any from specified, if first parameter is a string sequence. message will be written as an argument of inbuilt input() function. caseInsensitive makes string matching less strict; allows any-cased string.

0.3.35: extended gamut of sequences that can be passed to parameter desiredString, and added string type hint.

aveytense.Tense.upgrade(aveytense = True)
≥ 0.3.36; < 0.3.48

Console-specific class method for installing libraries from PyPi.

0.3.39: added parameter aveytense.

0.3.46

0.3.48

aveytense.Tense.uuidMd5(namespace, name)
≥ 0.3.26a1

Return an UUID from the MD5 (Message Digest) hash of a namespace UUID and a name

0.3.31: cancelled support for tkinter.StringVar

aveytense.Tense.uuidPrimary(node, clockSeq)
≥ 0.3.26a1

Return an UUID from host ID, sequence number and the current time.

0.3.31: cancelled support for tkinter.IntVar

aveytense.Tense.uuidRandom()
≥ 0.3.26a1

Return a random UUID

aveytense.Tense.uuidSha1(namespace, name)
≥ 0.3.26a1

Return an UUID from the SHA-1 (Secure Hash Algorithm) hash of a namespace UUID and a name

0.3.31: cancelled support for tkinter.StringVar

aveytense.Tense.version
≥ 0.3.26?

Returns current version of AveyTense in a string. Equivalent to removed constant aveytense.constants.VERSION. For example: for version 0.3.48 returned is string "0.3.48". 0.3.50

aveytense.Tense.versionId
≥ 0.3.26?; < 0.3.36

This attribute was equivalent to ~.constants.VERSION_ID. Marked as deprecated and removed in favor of ~.Tense.versionInfo.

0.3.35

0.3.36

aveytense.Tense.versionInfo
≥ 0.3.26?

Equivalent to removed constant ~.constants.VERSION_INFO.

Returns useful information about the AveyTense version on the terminal output, and behaves like sys.version_info variable when it comes to introspection. ~.Tense.versionInfo, like sys.version_info, is instance of a non-instantiable class. To get a tuple version of the version components, use ~.Tense.version.tuple. It is also possible to receive specific version components via following final properties (example for version 0.3.48):

~.Tense.versionInfo.major returns major version component; there 0

~.Tense.versionInfo.minor returns minor version component; there 3

~.Tense.versionInfo.micro returns micro version component; there 48

~.Tense.versionInfo.releaselevel returns release level component as a string; there "final"

~.Tense.versionInfo.serial returns serial version component. It only gets non-zero value when ~.Tense.versionInfo.releaselevel is equal "alpha", "beta" or "candidate". In case of final releases 0 is always returned.

The following code prints detailed information about AveyTense version and its components:

$k[from] $m[aveytense] $k[import] $t[Tense] $t[Tense].$tm[print]($t[Tense].$v[versionInfo]) 0.3.50

class _{aveytense.util.}Abstract
≥ 0.3.26b3

Creates an abstract class via inheritance.

This class is different to abc.ABC. abc.ABC class marks subclass abstract only when there are methods decorated with decorator @abc.abstractmethod. In case of ~.Abstract, class is always marked abstract, no matter if there are abstract methods or not (reference to abstract classes in TypeScript and PHP with abstract class keywords). The class doesn't inherit and isn't the same as abc.ABC, what means issubclass(~.Abstract, abc.ABC) returns False. Example how to create an abstract class:

$k[from] $m[aveytense].$msu[util] $k[import] $cut[Abstract] $k[class] $c[Test]($cut[Abstract]): $o[...] $v[test] $o[=] $c[Test]() # InitializedError: attempt to initialize an abstract class 'Test'

If you want to do the same, but with abstract methods, you would want to use abc.ABC class with @abc.abstractmethod decorator instead.

$k[from] $m[abc] $k[import] $c[ABC], $f[abstractmethod] $k[class] $c[Test]($cex[ABC]): @$f[abstractmethod] $k[def] $f[method]($p[self]): $o[...] 0.3.27rc1: the class is no longer experimental. Earlier, this class required following notation: class Test(~.Abstract, abstract = True). That notation came from local class typing._Final, and it isn't supported now. 0.3.34: moved this class from aveytense.types_collection to aveytense.util submodule. 0.3.40: this class is no longer a protocol class

class _{aveytense.util.}AbstractFinal
≥ 0.3.27rc1

Blend of classes ~.Abstract and ~.Final defined in the same submodule. This class creates abstract-final class via inheritance.

Abstract-final classes are only restricted to modify fields. Errors thrown by subclassing and initializing class object are the same as in ~.Abstract and ~.Final. ~.AbstractFinal is the same as: $k[from] $m[aveytense].$msu[util] $k[import] $cut[Abstract], $cut[Final], $cut[AbstractFinal] $k[class] $c[Test]($cut[Abstract], $cut[Final]): $o[...] # create abstract-final class

However, keep in mind checking the subclass of both ~.Abstract and ~.Final classes via issubclass() function returns False:

$f[issubclass]($c[Test], $cut[AbstractFinal]) # False $f[issubclass]($c[Test], ($cut[Abstract], $cut[Final])) # True 0.3.34: moved this class from aveytense.types_collection to aveytense.util submodule.

class _{aveytense.extensions.}ANSIColor
≥ 0.3.24; < 0.3.26rc1

This class was based on ANSI escape code for colorizing purposes, and was the primal sketch of currently available class aveytense.Color, which replaced this class, because this class wasn't developed further. Backward-compatiblity would require using different import, but it is not advised, especially in case of third import statement below, because aveytense.Color is much developed now.

$k[from] $m[aveytense] $k[import] $c[Color] # ≥ 0.3.40 $k[from] $m[tense] $k[import] $c[Color] # ≥ 0.3.26rc1 < 0.3.40 $k[from] $m[tense] $k[import] $c[ANSIColor] $k[as] $c[Color] # ≥ 0.3.24 < 0.3.26rc1

0.3.26rc1: Instead use aveytense.Color.

class _aveytense.ChangeVar
≥ 0.3.26rc1

Auxiliary class for creating sentinels inside loops, especially while. Overall, this class means to be a reference to incrementation and decrementation operators, which aren't available on Python (++ and --) and for loop in many popular languages such as JavaScript, PHP, C/C++, Java, of the form for(initialValue; statement; modifier). This class isn't well-documented there, but it has documentation strings on the AveyTense code - can be easily used with the help() inbuilt function, as help(~.ChangeVar).

_{aveytense.ChangeVar.}__init__(initialValue = 0)

_{aveytense.ChangeVar.}__neg__()

Decreases sentinel's value by 1. That's mere decrementation operation known from several programming languages as --. Behavior can be changed with method ~.setModifier(). Method itself doesn't return anything.

_{aveytense.ChangeVar.}__pos__()

Increases sentinel's value by 1. That's mere incrementation operation known from several programming languages as ++. Behavior can be changed with method ~.setModifier(). Method itself doesn't return anything.

class _aveytense.CMYK
≥ 0.3.28

Inversion of ~.RGB. Upon constructor invocation, returned is new ~.RGB class instance with inverted colors.

$k[from] $m[aveytense] $k[import] $c[CMYK] $c[CMYK]($n[0], $n[202], $n[255]) # RGB(255, 53, 0)

In contrast to ~.RGB class, this class does not feature any members. To invert a value (not RGB tuple necessarily), it is possible to use the following:

$k[from] $m[aveytense] $k[import] $o[*] $v[rgb] $o[=] $c[RGB].$f[fromValue]($n[0x00caff]) $c[CMYK]($v[rgb].$fp[r], $v[rgb].$fp[g], $v[rgb].$fp[b]) # RGB(255, 53, 0)

This class is final, what means it cannot be inherited by other classes.

class aveytense.Color
≥ 0.3.26rc1
type-alias aveytense.Colour = aveytense.Color
≥ 0.3.37

Deputy of the class ~.extensions.ANSIColor; allows to change color and modify style for desired text (string) on the output.

aveytense.Color.__all__ (≥ 0.3.26rc2)

Returns list of all non-underscored members of the class.

aveytense.Color.__constants__ (≥ 0.3.26rc2)

Returns list of all constants being variables of the class. They are sorted in ANSI ascending order, see here to learn more.

aveytense.Color.__init__(text, /, bits = 8, foregroundColor = None, backgroundColor = None) (≥ 0.3.26rc1)

Creates a new ~.Color class instance.
text will be a string, which will be colorized, bits represents bits for colors as in ANSI (possible values: 3, 4, 8, 24), foregroundColor is color for text, which may be a string (if it has hexadecimal, decimal, octal or binary integer), integer and ~.RGB class instances (if value for bits is 24). Finally, backgroundColor is color for background, which will encase the text. Accepted values same as in foregroundColor. These values can be greater than desired amount of bits (3 - 10, 4 - 20, 8 - 255, 24 - 16777215). Check this page for more information.

0.3.27: Removed last parameter underlineColor due to no effect (signature __init__(text, /, bits = 8, foregroundColor = None, backgroundColor = None, underlineColor = None)).

aveytense.Color.__mod__(other)
→ str

≥ 0.3.26rc1

Allows to include styles to colored text, and returns styled, colored version of text. This method equals self % other, where other must be an appriopriate constant value from this table:

Constant	Lifetime	Description
Single styles
`~.Color.NORMAL`	≥ 0.3.26rc1	Provides normal text. Nothing changes with this constant
`~.Color.BOLD`	≥ 0.3.26rc1	Text becomes bold
`~.Color.ITALIC`	≥ 0.3.26rc1	Text becomes oblique
`~.Color.UNDERLINE`	≥ 0.3.26rc1	Adds a line under the text
`~.Color.SLOW_BLINK`	≥ 0.3.26rc1	Sets blinking to less than 150 times per minute
`~.Color.RAPID_BLINK`	≥ 0.3.26rc1	Sets blinking to more than 150 times per minute
`~.Color.REVERSE`	≥ 0.3.26rc1	Swap foreground and background colors
`~.Color.HIDE`	≥ 0.3.26rc1	Text isn't visible on the output
`~.Color.STRIKE`	≥ 0.3.26rc1	Text becomes crossed out
`~.Color.DOUBLE_UNDERLINE`	≥ 0.3.26rc1	Adds 2 lines under the text
`~.Color.PROPORTIONAL`	≥ 0.3.26rc1; < 0.3.26rc2	Proportional spacing, consider using `str.rpartition()` instead 0.3.26rc2
`~.Color.FRAME`	≥ 0.3.26rc1	?
`~.Color.ENCIRCLE`	≥ 0.3.26rc1	It is probably border encasing entire text.
`~.Color.OVERLINE`	≥ 0.3.26rc1	Adds a line over the text
`~.Color.SUPERSCRIPT`	≥ 0.3.26rc1	Superscripts the text
`~.Color.SUBSCRIPT`	≥ 0.3.26rc1	Subscripts the text
Advanced styles
`~.Color.BOLD_ITALIC`	≥ 0.3.26rc2	Text becomes bold and oblique
`~.Color.BOLD_UNDERLINE`	≥ 0.3.26rc2	Text becomes bold and underlined
`~.Color.BOLD_STRIKE`	≥ 0.3.26rc2	Text becomes bold and crossed out
`~.Color.BOLD_OVERLINE`	≥ 0.3.26rc2	Text becomes bold and overlined
`~.Color.ITALIC_UNDERLINE`	≥ 0.3.26rc2	Text becomes oblique and underlined
`~.Color.ITALIC_STRIKE`	≥ 0.3.26rc2	Text becomes oblique and crossed out
`~.Color.ITALIC_OVERLINE`	≥ 0.3.26rc2	Text becomes oblique and overlined
`~.Color.UNDERLINE_STRIKE`	≥ 0.3.26rc2	Text becomes underlined and crossed out
`~.Color.UOLINE`	≥ 0.3.26rc2	Adds lines under and over the text
`~.Color.STRIKE_OVERLINE`	≥ 0.3.26rc2	Text becomes crossed out and overlined
`~.Color.BOLD_ITALIC_UNDERLINE`	≥ 0.3.26rc2	Text becomes bold, oblique and underlined
`~.Color.BOLD_ITALIC_STRIKE`	≥ 0.3.26rc2	Text becomes bold, oblique and crossed out
`~.Color.BOLD_ITALIC_OVERLINE`	≥ 0.3.26rc2	Text becomes bold, oblique and overlined
`~.Color.BOLD_UNDERLINE_STRIKE`	≥ 0.3.26rc2	Text becomes bold, underlined and crossed out
`~.Color.BOLD_UOLINE`	≥ 0.3.26rc2	Text becomes bold, underlined and overlined
`~.Color.ITALIC_UNDERLINE_STRIKE`	≥ 0.3.26rc2	Text becomes italic, underlined and crossed out
`~.Color.ITALIC_UOLINE`	≥ 0.3.26rc2	Text becomes italic, underlined and overlined
`~.Color.ITALIC_STRIKE_OVERLINE`	≥ 0.3.26rc2	Text becomes bold, crossed out and overlined
`~.Color.STRIKE_UOLINE`	≥ 0.3.26rc2	Text becomes crossed out, underlined and overlined

All of these constants are actually enum members. These categorized as single styles have their enum values the same as in this article (there n), e.g. for ~.Color.BOLD it is 0. Styles 2 in 1, which start category advanced styles, start with value 1000. For styles 3 in 1 beginning is 1100. Not all of these styles are guaranteed to work. For some terminals these may have different meaning, so be cautious when using these. Superscript, subscript, overline, encircle and frame are only implemented in mintty, but e.g. Visual Studio Code supports overline on the terminal. Bold can also mean increased intensity, faint - decreased intensity or dim, double underline - not bold. The following example prints text I will be blue and italic colored blue and oblique: from import .print(Color(I will be blue and italic, 8, 69) Color.ITALIC)

aveytense.Color.__pos__()(≥ 0.3.26rc1; < 0.3.48)
aveytense.Color.__neg__()(≥ 0.3.26rc1; < 0.3.48)
aveytense.Color.__invert__()(≥ 0.3.26rc1; < 0.3.48)
aveytense.Color.__str__() (≥ 0.3.34)

All of these equal the notations, respectively: with unary + and -, binary inversion ~ operators, and invocation of str(). All of these return colored text.

from import .print(Color(I will be blue, 8, 69)) .print(Color(I will be blue, 8, 69)) .print(Color(I will be blue, 8, 69))

.print(str(Color(I will be blue, 8, 69))) .print({!s}.format(Color(I will be blue, 8, 69))) .print(Color(I will be blue, 8, 69)) print() will convert the instance to string 0.3.47: Methods __pos__(), __neg__() and __invert__() are deprecated and will be removed in 0.3.48. Use str(self) instead. 0.3.48: Methods __pos__(), __neg__() and __invert__() have been removed.

aveytense.Color.__repr__() (≥ 0.3.35)

Equals invocation of repr(), and returns more representative version about object.

from aveytense import .print(repr(Color(Hello))) <aveytense.Color object: Color("Hello")> .print({!r}.format(Color(Hello))) <aveytense.Color object: Color("Hello")>

aveytense.Color.clear() (≥ 0.3.26rc1)

Resets all values (except text), those are: bits to 8, foreground and background color to None.
This method since 0.3.37 is also invoked when used with ~.Tense.clear().

static aveytense.Color.mix(text, /, bits, colorIds, style = None, ituFormat = False, reverse = True)
→ str

≥ 0.3.58

Generates a gradient with given colors in iterable object in colorIds parameter. The style parameter (defaults to None) must an enumerator - same use as with the % operator. It takes place when the string is about to be returned. The ituFormat parameter indicates whether use : instead of ; in ANSI escape code (defaults to False).

The reverse parameter takes place when colorIds iterable object (in code converted to list builtin) is exhausted and not all characters are colorized. In this case internal code of this static method colorizes every character by duplicating the content of colorIds, and the reverse parameter reverses every even duplicate. Defaults to True. For example: colorIds have tuple value (196, 160, 124, 88, 52, 16). Every even duplicates (second, fourth, sixth etc.) receive version with (52, 88, 124, 160) (reversed and without first and last item), meaning the pattern is (196, 160, 124, 88, 52, 16, 52, 88, 124, 160), followed per 2 duplicates (one normal and one reversed).

aveytense.Color.setBackgroundColor(color, /) (≥ 0.3.26rc1)

Sets color for background. Make sure value is least than desired amount of bits (3 - 10, 4 - 20, 8 - 255, 24 - 16777215), otherwise you can meet an error.

aveytense.Color.setBits(bits, /) (≥ 0.3.26rc1)

Sets bits amount. Make sure decreasing the amount won't catch an error. Possible values: 3, 4, 8, 24.

from aveytense import coloredColor(I will be blue, 3, 4) colored.setBits(8) colored.setForegroundColor(69) .print(Color(I will be blue, 8, 69))

aveytense.Color.setForegroundColor(color, /) (≥ 0.3.26rc1)

Sets color for text. Make sure value is least than desired amount of bits (3 - 10, 4 - 20, 8 - 255, 24 - 16777215), otherwise you can meet an error.

aveytense.Color.setUnderlineColor(color, /) (≥ 0.3.26rc1; < 0.3.27)

Sets color for underline. Make sure value is least than desired amount of bits (3 - 10, 4 - 20, 8 - 255, 24 - 16777215), otherwise you can meet an error.

0.3.27: No effect.

abstract-final class _aveytense.Colors (≥ 0.3.41)
type-alias _aveytense.Colours = _aveytense.Colors (≥ 0.3.41)

Provides color palette from HTML. All members of this class are objects of class ~.RGB. All names are from this page. Attributes prefixed with mode256_ refer to 8-bit colors table from ANSI escape code article.

class _{aveytense.util.}Final
≥ 0.3.26b3

Creates a final class via inheritance. Once a class extends this class, subclass cannot be further subclassed. This class is a reference to local class typing._Final, which is used to forbid the inheritance in special types in typing, however, doesn't work the same way.

Example how to create a final class: $k[from] $m[aveytense].$msu[util] $k[import] $cut[Final] $k[class] $c[Test]($cut[Final]): $o[...] $k[class] $c[Test2]($cex[Test]): $o[...] # SubclassedError: attempt to subclass a final class 'Test' 0.3.27rc1: the class is no longer experimental.

0.3.34: moved this class from aveytense.types_collection to aveytense.util submodule.

class _{aveytense.util.}FinalVar (≥ 0.3.26rc1)

Creates a final variable. It's main job is to supersede typing.Final class, since it doesn't work as intended.

0.3.34: moved this class from aveytense.types_collection to aveytense.util submodule.

0.3.35: the class is no longer experimental.

0.3.38: objects of this class can now be inspected via aveytense.Tense.isFinalVar().

class _{aveytense.util.}Flags
≥ 0.3.53

Returns buffer, code and type flags.

Flags.buffer (or util.BufferFlags) gets buffer flags. Content is almost the same as in inspect.BufferFlags, just every member uses CamelCase naming convention. inspect.BufferFlags in AveyTense features support before Python 3.12 - when it was added. It is defined here as aveytense.types.BufferFlags.
- Flags.buffer.contiguousAny
- Flags.buffer.contiguousC
- Flags.buffer.contiguousF
- Flags.buffer.contiguousReadOnly
- Flags.buffer.format
- Flags.buffer.full
- Flags.buffer.fullReadOnly
- Flags.buffer.indirect
- Flags.buffer.nd
- Flags.buffer.read
- Flags.buffer.records
- Flags.buffer.recordsReadOnly
- Flags.buffer.simple
- Flags.buffer.strided
- Flags.buffer.stridedReadOnly
- Flags.buffer.strides
- Flags.buffer.writable
- Flags.buffer.write
Flags.code (or util.CodeFlags) gets code flags. Content:
- Flags.code.asyncGenerator
- Flags.code.coroutine
- Flags.code.generator
- Flags.code.iterableCoroutine
- Flags.code.nested
- Flags.code.newLocals
- Flags.code.noFree
- Flags.code.optimized
- Flags.code.varargs
- Flags.code.varkeywords
Flags.type (or util.TypeFlags) gets type flags. Content:
- Flags.type.abstract
- Flags.type.baseExcSubclass
- Flags.type.baseType
- Flags.type.bytesSubclass
- Flags.type.default
- Flags.type.dictSubclass
- Flags.type.haveGc
- Flags.type.haveStacklessExtension
- Flags.type.haveVersionTag
- Flags.type.heapType
- Flags.type.listSubclass
- Flags.type.longSubclass
- Flags.type.ready
- Flags.type.readying
- Flags.type.tupleSubclass
- Flags.type.typeSubclass
- Flags.type.unicodeSubclass
- Flags.type.validVersionTag

Usage:

buffer flags: ?
code flags: <callable_object>.__code__.co_flags & ...
type flags: <type>.__flags__ & ...

type _{aveytense.util.}FinalVarType (≥ 0.3.38)

Type of aveytense.util.FinalVar; used in aveytense.Tense.isFinalVar() for type hinting.
Once instantiated, it will behave as initializing aveytense.util.FinalVar, what means example expression
FinalVar(2) == FinalVarType(2) returns True.

class _aveytense.Math (≥ 0.3.25)

A class containing math methods and constants. Inherited by class aveytense.Tense.

Comparing to math module in Python, this class features polygonal number counting,
more trigonometrical methods, number verification methods and sequence checking.
In overall, this class is its extension.

All methods in the class are class methods.

aveytense.Math.__all__ (≥ 0.3.26rc2)

Returns sorted list of all non-underscored members of the class.

Math constants

Constant	Exact or approximate value	Lifetime
`~.Math.NAN`	-	≥ 0.3.25 (5th July 2024)
`~.Math.INF`	-	≥ 0.3.25 (5th July 2024)
`~.Math.SQRT2`	1.41421...	≥ 0.3.25 (5th July 2024)
`~.Math.E`	2.71828...	≥ 0.3.25 (4th July 2024)
`~.Math.PI`	3.14159...	≥ 0.3.25 (4th July 2024)
`~.Math.TAU`	6.28318...	≥ 0.3.25 (5th July 2024)
`~.Math.THOUSAND`	10³	≥ 0.3.47 (7th June 2025)
`~.Math.MILLION`	10⁶	≥ 0.3.47 (7th June 2025)
`~.Math.BILLION`	10⁹	≥ 0.3.47 (7th June 2025)
`~.Math.TRILLION`	10¹²	≥ 0.3.47 (7th June 2025)
`~.Math.QUADRILLION`	10¹⁵	≥ 0.3.47 (7th June 2025)
`~.Math.QUINTILLION`	10¹⁸	≥ 0.3.47 (7th June 2025)
`~.Math.SEXTILLION`	10²¹	≥ 0.3.47 (7th June 2025)
`~.Math.SEPTILLION`	10²⁴	≥ 0.3.47 (7th June 2025)
`~.Math.OCTILLION`	10²⁷	≥ 0.3.47 (7th June 2025)
`~.Math.NONILLION`	10³⁰	≥ 0.3.47 (7th June 2025)
`~.Math.DECILLION`	10³³	≥ 0.3.47 (7th June 2025)
`~.Math.UNDECILLION`	10³⁶	≥ 0.3.47 (7th June 2025)
`~.Math.DUODECILLION`	10³⁹	≥ 0.3.47 (7th June 2025)
`~.Math.TREDEDECILLION`	10⁴²	≥ 0.3.47 (7th June 2025)
`~.Math.QUATTUOR_DECILLION`	10⁴⁵	≥ 0.3.47 (7th June 2025)
`~.Math.QUINDECILLION`	10⁴⁸	≥ 0.3.47 (7th June 2025)
`~.Math.SEXDECILLION`	10⁵¹	≥ 0.3.47 (7th June 2025)
`~.Math.SEPTEN_DECILLION`	10⁵⁴	≥ 0.3.47 (7th June 2025)
`~.Math.OCTODECILLION`	10⁵⁷	≥ 0.3.47 (7th June 2025)
`~.Math.NOVEMDECILLION`	10⁶⁰	≥ 0.3.47 (7th June 2025)
`~.Math.VIGINTILLION`	10⁶³	≥ 0.3.25 (7th June 2025)
`~.Math.GOOGOL`	10¹⁰⁰	≥ 0.3.25 (19th July 2024)
`~.Math.CENTILLION`	10³⁰³	≥ 0.3.25 (19th July 2024)

Trigonemetric functions

Normal
Class method name	Equivalent to	Lifetime	Domain	Possible values
`~.Math.sin(x, /)`	-	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨-1; 1⟩
`~.Math.cos(x, /)`	-	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨-1; 1⟩
`~.Math.tan(x, /)`	sin xcos x	≥ 0.3.25 (4th July 2024)	x ∈ R \ {k: k + 90 ∤ 90n} (where n ∈ N \ {0})	R
`~.Math.cot(x, /)`	1tan x	≥ 0.3.25 (4th July 2024)	x ∈ R \ {k: k ∤ 90}	R
`~.Math.sec(x, /)`	1cos x	≥ 0.3.25 (4th July 2024)	x ∈ R \ {k: k + 90 ∤ 90n} (where n ∈ N \ {0})	R \ (-1; 1)
`~.Math.cosec(x, /)`	1sin x	≥ 0.3.25 (4th July 2024)	x ∈ R \ {k: k ∤ 180}	R \ (-1; 1)

Extended
Class method name	Equivalent to	Lifetime	Domain	Possible values
`~.Math.versin(x, /)`	1 - cos x	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨0; 2⟩
`~.Math.vercos(x, /)`	1 + cos x	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨0; 2⟩
`~.Math.coversin(x, /)`	1 - sin x	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨0; 2⟩
`~.Math.covercos(x, /)`	1 + sin x	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨0; 2⟩
`~.Math.haversin(x, /)`	1 - cos x2	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨0; 1⟩
`~.Math.havercos(x, /)`	1 - sin x2	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨0; 1⟩
`~.Math.hacoversin(x, /)`	1 + cos x2	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨0; 1⟩
`~.Math.hacovercos(x, /)`	1 + sin x2	≥ 0.3.25 (4th July 2024)	x ∈ R	⟨0; 1⟩
`~.Math.exsec(x, /)`	sec x - 1	≥ 0.3.25 (5th July 2024)	x ∈ R \ {k: k + 90 ∤ 90n} (where n ∈ N \ {0})	⟨-2; 0⟩
`~.Math.excosec(x, /)`	cosec x - 1	≥ 0.3.25 (5th July 2024)	x ∈ R \ {k: k ∤ 180}	⟨-2; 0⟩

Hyperbolic
Class method name	Equivalent to	Lifetime	Domain	Possible values
`~.Math.sinh(x, /)`	e^x - e^-x2	≥ 0.3.25 (4th July 2024)	x ∈ R	R
`~.Math.cosh(x, /)`	e^x + e^-x2	≥ 0.3.25 (4th July 2024)	x ∈ R	R
`~.Math.tanh(x, /)`	sinh xcosh x	≥ 0.3.25 (4th July 2024)	x ∈ R	R
`~.Math.coth(x, /)`	1tanh x	≥ 0.3.46 (23rd May 2025)	x ≠ 0	R
`~.Math.sech(x, /)`	1cosh x	≥ 0.3.46 (23rd May 2025)	x ∈ R	R
`~.Math.cosech(x, /)`	1sinh x	≥ 0.3.46 (23rd May 2025)	x ≠ 0	R

Inverse
Class method name	Equivalent to	Lifetime	Domain	Possible values
`~.Math.asin(x, /)`	sin^-1 x	≥ 0.3.25 (4th July 2024)	\|x\| ≤ 1
`~.Math.asinh(x, /)`	ln (x + (x² + 1)^1/2)	≥ 0.3.25 (4th July 2024)	x ∈ R
`~.Math.acos(x, /)`	cos^-1 x	≥ 0.3.25 (4th July 2024)	\|x\| ≤ 1
`~.Math.acosh(x, /)`	ln (x + (x² - 1)^1/2)	≥ 0.3.25 (4th July 2024)	x ≥ 1
`~.Math.atan(x, /)`	tan^-1 x	≥ 0.3.25 (4th July 2024)	x ∈ R
`~.Math.atanh(x, /)`	12 ln 1 + x1 - x	≥ 0.3.25 (4th July 2024)	x ∈ (-1; 1)
`~.Math.acot(x, /)`	cot^-1 x	≥ 0.3.46 (23rd May 2025)	x ∈ R
`~.Math.acoth(x, /)`	*	≥ 0.3.51	x ∉ ⟨-1; 1⟩
`~.Math.asec(x, /)`	acos(1 ÷ x)	≥ 0.3.25 (4th July 2024)	\|x\| > 1
`~.Math.asech(x, /)`	*	≥ 0.3.51	x ∈ (0; 1⟩
`~.Math.acosec(x, /)`	asin(1 ÷ x)	≥ 0.3.25 (4th July 2024)	\|x\| > 1
`~.Math.acosech(x, /)`	*	≥ 0.3.51	x ∈ R \ {0}
`~.Math.aversin(x, /)`	acos(1 - x)	≥ 0.3.25 (4th July 2024)	x ∈ ⟨0; 2⟩
`~.Math.avercos(x, /)`	asin(1 - x)	≥ 0.3.25 (4th July 2024)	x ∈ ⟨0; 2⟩
`~.Math.acoversin(x, /)`	acos(x - 1)	≥ 0.3.25 (4th July 2024)	x ∈ ⟨0; 2⟩
`~.Math.acovercos(x, /)`	acos(x - 1)	≥ 0.3.25 (4th July 2024)	x ∈ ⟨0; 2⟩
`~.Math.ahaversin(x, /)`	acos(1 - 2x)	≥ 0.3.25 (4th July 2024)	x ∈ ⟨0; 1⟩
`~.Math.ahavercos(x, /)`	acos(2x - 1)	≥ 0.3.25 (4th July 2024)	x ∈ ⟨0; 1⟩
`~.Math.ahacoversin(x, /)`	asin(1 - 2x)	≥ 0.3.25 (4th July 2024)	x ∈ ⟨0; 1⟩
`~.Math.ahacovercos(x, /)`	asin(2x - 1)	≥ 0.3.25 (4th July 2024)	x ∈ ⟨0; 1⟩
`~.Math.aexsec(x, /)`	asec(x + 1)	≥ 0.3.25 (5th July 2024)	x ∉ (-2; 0)
`~.Math.aexcosec(x, /)`	acosec(x + 1)	≥ 0.3.25 (5th July 2024)	x ∉ (-2; 0)

Figurate number functions

0.3.39: all figurate number functions are now providing support for 0 for parameter n. In ~.Math.polygonal() change also occurred in parameter s - it must now comply with s ≥ 3.

Class method name	Equivalent to	Lifetime	Returned value
Two-parameter functions
`~.Math.polygonal(n, s, /)`	(s - 2)n² - (s - 4)n2	≥ 0.3.27a4	polygonal number at index `n` with `s` sides
`~.Math.polygonalCentered(n, s, /)`	sn(n + 1)2+ 1	≥ 0.3.51	centered polygonal number at index `n` with `s` sides
`~.Math.pyramidal(n, s, /)`	3n² + n³(s - 2) - n(s - 5)6	≥ 0.3.51	pyramidal number at index `n` with `s` sides
One-parameter functions
2-polytopes (polygons)
`~.Math.triangular(n, /)`	n² + n2	≥ 0.3.27a4	triangular number at index `n`
`~.Math.triangularCentered(n, /)`		≥ 0.3.51	centered triangular number at index `n`
`~.Math.square(n, /)`	n²	≥ 0.3.51	square number at index `n` (or n to the power 2)
`~.Math.squareCentered(n, /)`	n² + (n - 1)²	≥ 0.3.51	centered square number at index `n`
`~.Math.pentagonal(n, /)`	3n² - n2	≥ 0.3.27a4	pentagonal number at index `n`
`~.Math.pentagonalCentered(n, /)`		≥ 0.3.51	centered pentagonal number at index `n`
`~.Math.hexagonal(n, /)`	2n² - n	≥ 0.3.27a4	hexagonal number at index `n`
`~.Math.hexagonalCentered(n, /)`		≥ 0.3.51	centered hexagonal number at index `n`
`~.Math.heptagonal(n, /)`	5n² - 3n2	≥ 0.3.27a4	heptagonal number at index `n`
`~.Math.heptagonalCentered(n, /)`		≥ 0.3.51	centered heptagonal number at index `n`
`~.Math.octagonal(n, /)`	3n² - 2n	≥ 0.3.27a4	octagonal number at index `n`
`~.Math.octagonalCentered(n, /)`	(2n - 1)²	≥ 0.3.51	centered octagonal number at index `n`
`~.Math.nonagonal(n, /)`	7n² - 5n2	≥ 0.3.27a4	nonagonal number at index `n`
`~.Math.nonagonalCentered(n, /)`	(3n - 2)(3n - 1)2	≥ 0.3.51	centered nonagonal number at index `n`
`~.Math.decagonal(n, /)`	4n² - 3n	≥ 0.3.27a4	decagonal number at index `n`
`~.Math.decagonalCentered(n, /)`	5n² - 5n + 1	≥ 0.3.51	centered decagonal number at index `n`
`~.Math.hendecagonal(n, /)`	n(9n - 7)2	≥ 0.3.51	hendecagonal number at index `n`
`~.Math.hendecagonalCentered(n, /)`	11n(n - 1) + 22	≥ 0.3.51	centered hendecagonal number at index `n`
`~.Math.dodecagonal(n, /)`	n(5n - 4)	≥ 0.3.51	dodecagonal number at index `n`
`~.Math.dodecagonalCentered(n, /)`	6n(n - 1) + 1	≥ 0.3.51	centered dodecagonal number at index `n`
`~.Math.tridecagonal(n, /)`	n(11n - 9)2	≥ 0.3.51	tridecagonal number at index `n`
`~.Math.tridecagonalCentered(n, /)`	13n(n - 1) + 22	≥ 0.3.51	centered tridecagonal number at index `n`
`~.Math.pronic(n, /)`	n(n + 1)	≥ 0.3.51	pronic number at index `n`
`~.Math.star(n, /)`	6n(n - 1) + 1	≥ 0.3.51	star number at index `n`
3-polytopes (polyhedra)
`~.Math.tetrahedral(n, /)`	n^3̅3!	≥ 0.3.51	tetrahedral number at index `n`
`~.Math.tetrahedralCentered(n, /)`	(2n + 1) ∙ (n² + n + 33)	≥ 0.3.51	centered tetrahedral number at index `n`
`~.Math.cube(n, /)`	n³	≥ 0.3.51	cube number at index `n` (or n to the power 3)
`~.Math.cubeCentered(n, /)`	n³ + (n + 1)³	≥ 0.3.51	centered cube number at index `n`
`~.Math.octahedral(n, /)`	n(2n² + 1)3	≥ 0.3.51	octahedral number at index `n`
`~.Math.octahedralCentered(n, /)`	(2n + 1)(2n² + 2n + 3)3	≥ 0.3.51	centered octahedral number at index `n`
`~.Math.stellaOctangula(n, /)`	n(2n² - 1)	≥ 0.3.51	stella octangula number at index `n`
`~.Math.dodecahedral(n, /)`	n(3n - 1)(3n - 2)2	≥ 0.3.51	dodecahedral number at index `n`
`~.Math.dodecahedralCentered(n, /)`	(2n + 1)(5² + 5n + 1)	≥ 0.3.51	centered dodecahedral number at index `n`
`~.Math.icosahedral(n, /)`	n(5n² - 5n + 2)2	≥ 0.3.51	icosahedral number at index `n`
`~.Math.icosahedralCentered(n, /)`	(2n + 1)(5² + 5n + 3)3	≥ 0.3.51	centered icosahedral number at index `n`
4-polytopes
`~.Math.pentatope(n, /)`	n^4̅ / 4!	≥ 0.3.51	pentatope number at index `n`

Miscellaneous functions

Class method name	Equivalent to	Lifetime	Returned value
`~.Math.abs(x, /)`	\|x\|	≥ ? (< 0.3.24)	absolute value of `x`
`~.Math.fact(n, /)`	n!	≥ 0.3.26rc3	factorial of `n`
`~.Math.factFalling(x, n, /)`	(x)_n	≥ 0.3.51	falling factorial of `x` at index `n`
`~.Math.factRising(x, n, /)`	x^n̅	≥ 0.3.51	rising factorial of `x` at index `n`
`~.Math.ln(x, /)`	ln x	≥ 0.3.25 (5th July 2024)	natural logarithm of `x`
`~.Math.log(x, /, base = ...)`	log_base x	≥ 0.3.25 (5th July 2024)	logarithm of `x` with specific `base`
`~.Math.log2(x, /)`	log₂ x	≥ 0.3.25 (5th July 2024)	logarithm of `x` with base 2
`~.Math.log3(x, /)`	log₃ x	≥ 0.3.25 (5th July 2024)	logarithm of `x` with base 3
`~.Math.log5(x, /)`	log₅ x	≥ 0.3.25 (5th July 2024)	logarithm of `x` with base 5
`~.Math.log7(x, /)`	log₇ x	≥ 0.3.25 (5th July 2024)	logarithm of `x` with base 7
`~.Math.log10(x, /)`	log₁₀ x	≥ 0.3.25 (5th July 2024)	logarithm of `x` with base 10

aveytense.Math.abs(x, /)

Returns absolute value of a number. Equals math notation |x| defined as:

return -x, if x < 0
return x, if x ≥ 0

This class method was defined before 0.3.24, but it remains hard to assume since when it was defined on old Tense08 class. It is believed that it was defined when Tense08 class was defined (0.2.16) or between 0.3.6 - 0.3.8. There was lacking docstring in this class method. Currently, Aveyzan has archives since version 0.2.1 (up to 0.3.29; last version with zip archive version).

0.3.39: Added type checking. To not catch TypeError, integer, floating-point number or object of class implementing __abs__() method must be passed. In the last one, method __abs__() must return either integer or floating-point number. Unfortunately, for negative numbers it doesn't seem logical, when using the inbuilt function abs():


              from aveytense import 
              
              class r:

              def __abs__(self):

              return -76
              
              .print(abs(r())) -76

So on this version correction has been applied:


              .print(Math.abs(r())) 76

This first example comes from fact that method __abs__() can return anything, so its also seen in function abs(), as self.__abs__() method
is the same as invocation of abs(self).

aveytense.Math.acos(x, /) (≥ 0.3.25)

Returns arc cosine of x.

Domain equals x ∈ ⟨-1; 1⟩. Result will be in range ⟨0; π⟩.

0.3.38: Improved domain checking

0.3.39: Improved type checking

aveytense.Math.acosec(x, /) (≥ 0.3.25)

Returns arc cosecant of x.

Domain equals x ∈ (-∞ -1⟩ ∪ ⟨1; ∞), or, simplier: |x| ≥ 1.

0.3.38: Improved domain checking

0.3.39: Improved type checking

aveytense.Math.acosh(x, /) (≥ 0.3.25)

Returns inverse hyperbolic cosine of x.

Domain equals x ≥ 1.

0.3.39: Improved domain and type checking

aveytense.Math.acovercos(x, /) (≥ 0.3.25)

Returns inverse coversed cosine of x. Equals ~.asin(x - 1).

Domain equals x ∈ ⟨0; 2⟩ (basing on arc sine domain).

0.3.39: Renamed from ~.acovercosin(); improved domain and type checking

aveytense.Math.acoversin(x, /) (≥ 0.3.25)

Returns inverse coversed sine of x. Equals ~.asin(1 - x).

Domain equals x ∈ ⟨0; 2⟩ (basing on arc sine domain).

0.3.39: Improved domain and type checking

aveytense.Math.aexcosec(x, /) (≥ 0.3.25)

Returns inverse excosecant of x. Equals ~.acosec(x + 1).

Domain equals x ∈ (-∞ -2⟩ ∪ ⟨0; ∞) (basing on arc cosecant domain).

0.3.39: Renamed from aveytense.Math.aexcsc(); improved domain and type checking

aveytense.Math.aexsec(x, /) (≥ 0.3.25)

Returns inverse exsecant of x. Equals ~.asec(x + 1).

Domain equals x ∈ (-∞ -2⟩ ∪ ⟨0; ∞) (basing on arc secant domain).

0.3.39: Improved domain and type checking

aveytense.Math.ahacovercos(x, /) (≥ 0.3.25)

Returns inverse hacoversed cosine of x. Equals ~.asin(2x - 1).

Domain equals x ∈ ⟨0; 1⟩ (basing on arc sine domain).

0.3.39: Renamed from aveytense.Math.ahacovercosin(); improved domain and type checking

aveytense.Math.ahacoversin(x, /) (≥ 0.3.25)

Returns inverse hacoversed sine of x. Equals ~.asin(1 - 2x).

Domain equals x ∈ ⟨0; 1⟩ (basing on arc sine domain).

0.3.39: Improved domain and type checking

aveytense.Math.ahavercos(x, /) (≥ 0.3.25)

Returns inverse haversed cosine of x. Equals ~.acos(2x - 1).

Domain equals x ∈ ⟨0; 1⟩ (basing on arc cosine domain).

0.3.39: Renamed from ~.ahavercosin(); improved domain and type checking

aveytense.Math.ahaversin(x, /) (≥ 0.3.25)

Returns inverse haversed cosine of x. Equals ~.acos(1 - 2x).

Domain equals x ∈ ⟨0; 1⟩ (basing on arc cosine domain).

0.3.39: Improved domain and type checking

aveytense.Math.asec(x, /) (≥ 0.3.25)

Returns arc secant of x.

Domain equals x ∈ (-∞ -1⟩ ∪ ⟨1; ∞), or, simplier: |x| ≥ 1.

0.3.38: Improved domain checking

0.3.39: Improved type checking

aveytense.Math.asin(x, /) (≥ 0.3.25)

Returns arc sine of x.

Domain equals x ∈ ⟨-1; 1⟩. Result will be in range ⟨-^π/₂; ^π/₂⟩.

0.3.38: Improved domain checking

0.3.39: Improved type checking

aveytense.Math.asinh(x, /) (≥ 0.3.25)

Returns inverse hyperbolic sine of x.

Domain equals x ∈ R.

0.3.39: Improved type checking

aveytense.Math.atan(x, /) (≥ 0.3.25)

Returns arc tangent of x.

Domain equals x ∈ R.

0.3.39: Improved type checking

aveytense.Math.atanh(x, /) (≥ 0.3.25)

Returns inverse hyperbolic tangent of x.

Domain equals x ∈ ⟨-1; 1⟩.

0.3.39: Improved domain and type checking

aveytense.Math.avercos(x, /) (≥ 0.3.25)

Returns inverse versed cosine of x. Equals ~.acos(x - 1).

Domain equals x ∈ ⟨0; 2⟩ (basing on arc cosine domain).

0.3.39: Renamed from ~.avercosin(); improved domain and type checking

aveytense.Math.aversin(x, /) (≥ 0.3.25)

Returns inverse versed cosine of x. Equals ~.acos(1 - x).

Domain equals x ∈ ⟨0; 2⟩ (basing on arc cosine domain).

0.3.39: Improved domain and type checking

aveytense.Math.cbrt(x, /) (≥ 0.3.25)

Returns ³√x (cube root of x)

0.3.26rc2: provided support before Python 3.11 (function math.cbrt() didn't exist to this version).

0.3.39: Improved type checking

aveytense.Math.cos(x, /) (≥ 0.3.25)

Returns cosine of x.

Domain equals x ∈ R.

0.3.39: Improved type checking

aveytense.Math.cosec(x, /) (≥ 0.3.25)

Returns cosecant of x.

Domain equals x ∈ R.

0.3.39: Improved type checking

aveytense.Math.cosh(x, /) (≥ 0.3.25)

Returns hyperbolic cosine of x.

Domain equals x ∈ R.

0.3.39: Improved type checking

aveytense.Math.cot(x, /) (≥ 0.3.25)

Returns cotangent of x (inverse of tangent).

Domain equals x ∈ R.

0.3.39: Improved type checking

aveytense.Math.covercos(x, /) (≥ 0.3.25)

Returns coversed cosine of x. Equals 1 + ~.sin(x).

Domain equals x ∈ R.

0.3.39: Renamed from ~.covercosin(); improved type checking

aveytense.Math.coversin(x, /) (≥ 0.3.25)

Returns coversed sine of x. Equals 1 - ~.sin(x).

Domain equals x ∈ R.

0.3.39: Improved type checking

aveytense.Math.decagonal(n, /) (≥ 0.3.27a4)

Returns decagonal number from following formula: 4n² - 3n. This method is the same as ~.polygonal(n, 10). Example results:

for n = 0 returned is 0
for n = 1 returned is 1
for n = 2 returned is 10
for n = 3 returned is 27
for n = 4 returned is 52

See this article to see more results.

0.3.39: Number 0 is now allowed. Earlier, numbers from 1 above were able to be passed.

aveytense.Math.excosec(x, /) (≥ 0.3.25)

Returns excosecent of x. Equals ~.cosec(x) - 1.

Domain equals x ∈ R.

0.3.39: improved type checking

0.3.40: renamed from ~.excsc()

aveytense.Math.exsec(x, /) (≥ 0.3.25)

Returns excosecent of x. Equals ~.sec(x) - 1.

Domain equals x ∈ R.

0.3.39: Improved type checking

aveytense.Math.fact(n, /) (≥ 0.3.26rc3)

Returns factorial of n, given by formula: n! = n ∙ (n - 1) ∙ (n - 2) ∙ ... ∙ 3 ∙ 2 ∙ 1. For n ∈ {0; 1} (n is equal 0 or 1) returned is 1.

0.3.39: Improved type checking. In case there wasn't math.factorial() function, implementation is since now included.

aveytense.Math.gcd(*i) (≥ 0.3.31)

Returns greatest common divisor of all integers given. Unlike for common notation with 2 values gcd(a, b), this
method supports variable amount of integers.

Before Python 3.9, math.gcd() function operated on 2 values only.

0.3.39: Improved type checking. Added support for variable amount of values before Python 3.9.

aveytense.Math.heptagonal(n, /) (≥ 0.3.27a4)

Returns heptagonal number from following formula: 5n² - 3n2. This method is the same as ~.polygonal(n, 7). Example results:

for n = 0 returned is 0
for n = 1 returned is 1
for n = 2 returned is 7
for n = 3 returned is 18
for n = 4 returned is 34

See this article to see more results.

0.3.39: Number 0 is now allowed. Earlier, numbers from 1 above were able to be passed.

aveytense.Math.hexagonal(n, /) (≥ 0.3.27a4)

Returns hexagonal number from following formula: 2n² - n. This method is the same as ~.polygonal(n, 6). Example results:

for n = 0 returned is 0
for n = 1 returned is 1
for n = 2 returned is 6
for n = 3 returned is 15
for n = 4 returned is 28

See this article to see more results.

0.3.39: Number 0 is now allowed. Earlier, numbers from 1 above were able to be passed.

aveytense.Math.isInRange(x, a, b, /, mode = "c") (≥ 0.3.36)

Returns True, if x ∈ ⟨a; b⟩. If a is greater than b, then range will occur as ⟨b; a⟩.

If x is a sequence of numbers, then all numbers from that sequence must be in range created by a and b. In case of empty sequences False is returned.

0.3.39: added parameter mode to modify the range. c means closed and o means open bracket:

`~.isInRange()`
`mode` value	Equivalent to
`"c" "cc"`	x ∈ ⟨a; b⟩ a ≤ x ≤ b
`"co"`	x ∈ ⟨a; b) a ≤ x < b
`"o" "oo"`	x ∈ (a; b) a < x < b
`"oc"`	x ∈ (a; b⟩ a < x ≤ b

`not ~.isInRange()`
`mode` value	Equivalent to
`"c" "cc"`	x ∈ (-∞; a) ∪ (b; ∞) x < a \|\| x > b
`"co"`	x ∈ (-∞; a) ∪ ⟨b; ∞) x < a \|\| x ≥ b
`"o" "oo"`	x ∈ (-∞; a⟩ ∪ ⟨b; ∞) x ≤ a \|\| x ≥ b
`"oc"`	x ∈ (-∞; a⟩ ∪ (b; ∞) x ≤ a \|\| x > b

Case for mode is insensitive.

In case of maths, ranges are also called intervals, as visible in this article.

aveytense.Math.lcm(*i) (≥ 0.3.31)

Returns least common multiple of all integers given. Math interpretation: lcm(i₁, i₂, i₃, ..., i_n). This can be also achieved with functools.reduce() function used along with math.gcd(), as the following piece of code:

from import from functools import reduce ≥ 2.6 from math import gcd ≥ 3.5 math.gcd(): before Python 3.9, this function operated on 2 parameters, but we can manually implement it def lcm(i): return reduce(lambda a, b: (a b)gcd(a, b), i) The ~.lcm() class method provides support before Python 3.9. Before Python 3.9, math.lcm() wasn't defined yet.

0.3.39: Improved type checking and added support before Python 3.9.

aveytense.Math.log(x, /, base = aveytense.constants.MATH_E) (≥ 0.3.25)

Returns log_b x (where b = base).

0.3.39: x is now positional-only parameter

aveytense.Math.lwdp(n, /) (≥ 0.3.39)

Returns number least with digit product of n. Multiply operation on certain digits need to have the same result as n, and first smallest one will be returned. If there are no digits that multiplied together equal n, method will return -1. Examples: for n = 18 returned is 29, for n = 36 returned is 49, and for n = 120 returned is 358. Notice results are greater than n.

This class method was defined on 0.3.31 as aveytense.Math.ltp() (least to product). However, it was never handed over, mainly due to issue of generating the result too long. It still existed in code, just wasn't available publicly due to if False statement preceding the method definition as an alternative for inspecting sys.version_info.

This method was defined back during IT trial mature exams on 22nd November 2024, and since then that method had this issue.

The issue was patched on 12th February 2025.

aveytense.Math.maxDigit(n, /) (≥ 0.3.39)

Returns largest digit in an integer. Sign isn't counted.

aveytense.Math.mean(*a, mode = "a") (≥ 0.3.40)

Returns arithmetic, geometric or quadratic mean of given integers. Result may be either float or integer. Throws TypeError whether there were no integer values passed or not all values are integers.

The type of mean is addicted to parameter mode:

"a" - returns arithmetic mean. Formula: a₁ + a₂ + ... + a_nn
"g" - returns geometric mean. Formula: (a₁ ∙ a₂ ∙ ... ∙ a_n)^{n^-1} = ⁿ√(a₁ ∙ a₂ ∙ ... ∙ a_n)
"q" - returns quadratic mean (root mean square). Formula: √(a₁² + a₂² + ... + a_n²n)

Case for mode is insenstive.

In case geometric mean is deduced, ValueError is raised when there is at least one negative integer passed.

aveytense.Math.minDigit(n, /) (≥ 0.3.39)

Returns smallest digit in an integer. Sign isn't counted.

aveytense.Math.nonagonal(n, /) (≥ 0.3.27a4)

Returns nonagonal number from following formula: 7n² - 5n2.
This method is the same as aveytense.Math.polygonal(n, 9). Example results:

for n = 0 returned is 0
for n = 1 returned is 1
for n = 2 returned is 9
for n = 3 returned is 24
for n = 4 returned is 46

See this article to see more results.

0.3.39: Number 0 is now allowed. Earlier, numbers from 1 above were able to be passed.

aveytense.Math.octagonal(n, /) (≥ 0.3.27a4)

Returns octagonal number from following formula: 3n² - 2n.
This method is the same as aveytense.Math.polygonal(n, 8). Example results:

for n = 0 returned is 0
for n = 1 returned is 1
for n = 2 returned is 8
for n = 3 returned is 21
for n = 4 returned is 40

See this article to see more results.

0.3.39: Number 0 is now allowed. Earlier, numbers from 1 above were able to be passed.

aveytense.Math.pentagonal(n, /) (≥ 0.3.27a4)

Returns pentagonal number from following formula: 3n² - n2.
This method is the same as aveytense.Math.polygonal(n, 5). Example results:

for n = 0 returned is 0
for n = 1 returned is 1
for n = 2 returned is 5
for n = 3 returned is 12
for n = 4 returned is 22

See this article to see more results.

0.3.39: Number 0 is now allowed. Earlier, numbers from 1 above were able to be passed.

aveytense.Math.perm(n, k = ..., /) (≥ 0.3.39)

Returns variation without repetitions given by formula n!(n - k)!. In binomial coefficent notation it would look like

(\binom{n}{k})

∙ k!

If k is ellipsis, returns n! (variation with repetitions or permutations).

Scheme for variation without repetitions is took from this PDF file.

0.3.40: fixed to current scheme, earlier it was n!(n - k)! ∙ k!. Removed support for None.

aveytense.Math.polygonal(n, s, /) (≥ 0.3.27a4)

Returns s-gonal number from following formula: (s - 2)n² - (s - 4)n2.
s is amount of sides in a polygon, and it cannot be negative, not even equal 0 (see note below for update).

0.3.39: Number 0 in first parameter is now allowed. Earlier, numbers from 1 above
were able to be passed to that parameter. However, second parameter must now comply with s ≥ 3,
because at least 3 sides can create a polygon (starting from triangle).

aveytense.Math.sin(x, /) (≥ 0.3.25)

Returns sine of x. Formula is sin x =

Σ_{n = 0}^{\infty} \frac{{(-1)}^{n}}{(2n + 1)!} x^{2n + 1}

(note n is sentinel in a loop, which will never end due to ∞).

0.3.39: Improved type checking

aveytense.Math.sqrt(x, /) (≥ 0.3.25)

Returns √x (square root of x)

0.3.39: Improved type checking

aveytense.Math.toDigits(n, /) (≥ 0.3.39)

Splits an integer into a list of digits building the integer. Sign isn't counted.

aveytense.Math.triangular(n, /) (≥ 0.3.27a4)

Returns triangular number from following formula: .
This method is the same as aveytense.Math.polygonal(n, 3). Example results:

for n = 0 returned is 0
for n = 1 returned is 1
for n = 2 returned is 3
for n = 3 returned is 6
for n = 4 returned is 10

See this article to see more results.

0.3.39: Number 0 is now allowed. Earlier, numbers from 1 above were able to be passed.

class aveytense.games.Minesweeper (≥ 0.3.41; < 0.3.47)

Provides components for minesweeper game. Referred from Windows 7 Minesweeper. These components can be used with tkinter, from which AveyTense project resigned back on 0.3.36. 0.3.47: To be used in separate project aveytense_games.

aveytense.games.Minesweeper.__init__(height = 16, width = 30, mines = 99) (≥ 0.3.41; < 0.3.47)

Creates a new ~.Minesweeper class object. height is amount of rows for the board. Allowed values for 9 to 24.
width is amount of columns for the board. Allowed values for 9 to 30.
mines is amount of mines scattered on the board. Allowed values for 10 to 668. As values, you can use consecutive items in following tuples:

Variable	Lifetime	Tuple content	Usage
`~.Minesweeper.ADVANCED`	≥ 0.3.41; < 0.3.47	`(16, 30, 99)`	`~.Minesweeper(~[0], ~[1], ~[2])`
`~.Minesweeper.BEGINNER`	≥ 0.3.41; < 0.3.47	`(9, 9, 10)`
`~.Minesweeper.INTERMEDIATE`	≥ 0.3.41; < 0.3.47	`(16, 16, 40)`

0.3.47: To be used in separate project aveytense_games.

final-property aveytense.games.Minesweeper.board (≥ 0.3.41; < 0.3.47)

Returns the board as a nested string list. Possible values are for "0" to "8", or "X", which is a mine indicator. It is also possible to occur as parameter-less ~.getBoard() method. 0.3.47: To be used in separate project aveytense_games.

aveytense.games.Minesweeper.displayBoard(colorize = False) (≥ 0.3.41; < 0.3.47)

Prints the minesweeper board, and returns reference to the class object. Normally, board isn't colored. If colorize is set to True, board will be colored, but it will take longer to print. It usually takes 2-3 seconds. 0.3.47: To be used in separate project aveytense_games.

final-property aveytense.games.Minesweeper.height (≥ 0.3.41; < 0.3.47)

Returns amount of rows specified in the constructor. It is also possible to occur as parameter-less ~.getHeight() method. 0.3.47: To be used in separate project aveytense_games.

final-property aveytense.games.Minesweeper.mines (≥ 0.3.41; < 0.3.47)

Returns amount of mines specified in the constructor. It is also possible to occur as parameter-less ~.getMines() method. 0.3.47: To be used in separate project aveytense_games.

final-property aveytense.games.Minesweeper.width (≥ 0.3.41; < 0.3.47)

Returns amount of columns specified in the constructor. It is also possible to occur as parameter-less ~.getWidth() method. 0.3.47: To be used in separate project aveytense_games.

class aveytense.util.MutableString (≥ 0.3.42)

A mutable version of inbuilt class str; represents a string that can be changed.

class aveytense.util.ParamVar (≥ 0.3.42)

Blend of functions inspect.getfullargspec() and inspect.signature(). Except looking for variable and non-variable parameters, it is also possible to receive type annotations of desired callable object, and overload pointer is included. 0.3.51: Added initial support for inbuilt functions. Types can be assigned to static method ~.util.ParamVar.fromType(). Not all inbuilt (built-in) functions can be introspected, especially methods, and under angle of signature. Perhaps some share the __text_signature__ attribute, value of this attribute may be either only (*args, **kwargs) or None, what decreases the chance to inspect such functions. Reason is given in documentation of function inspect.signature() (in Note section). Overloaded inbuilt functions inspection is difficult too, because this raises an AttributeError exception for accessing undefined attribute __module__ after invocation of function typing.get_overloads().

aveytense.util.ParamVar.__all__ (≥ 0.3.51)

aveytense.util.ParamVar.__init__(f, i = 0, /) (≥ 0.3.42)

Parameter f must be a callable object, meanwhile parameter i points to a specific overload, if provided callable object in parameter f has overloads. May be only in range ⟨0; overloads_amount - 1⟩. If f is an instance method accessed via reference, then first parameter (usually named self) is excluded. f can be an instance of functools.partial class too.

final-property aveytense.util.ParamVar.all (≥ 0.3.42)

Returns a tuple with all parameters in the callable object. from import def f(p1, p2, , p3, p4, , p572, p6, p7): .print(util.ParamVar(f).all) ("p1", "p2", "p3", "p4", "p5", "p6", "p7")

final-property aveytense.util.ParamVar.allCount (≥ 0.3.44)

Equivalent to len(~.all).

final-property aveytense.util.ParamVar.allDefaults (≥ 0.3.42)

Returns a tuple holding 2-item tuples with parameters and their default values. Created to be convertible to dict. from import def f(p1, p2, , p3, p4, , p572, p6, p7): .print(util.ParamVar(f).allDefaults) (("p5", 72),)

final-property aveytense.util.ParamVar.allDefaultsCount (≥ 0.3.44)

Equivalent to len(~.allDefaults).

final-property aveytense.util.ParamVar.allNoDefaults (≥ 0.3.44)

Returns a tuple with parameters that have no default value. from import def f(p1, p2, , p3, p4, , p572, p6, p7): .print(util.ParamVar(f).allNoDefaults) ("p1", "p2", "p3", "p4", "p6", "p7")

final-property aveytense.util.ParamVar.allNoDefaultsCount (≥ 0.3.44)

Equivalent to len(~.allNoDefaults).

final-property aveytense.util.ParamVar.allWithDefaults (≥ 0.3.51)

final-property aveytense.util.ParamVar.annotated (≥ 0.3.42)

Returns a tuple of parameters that have a type annotated. For type annotation details see PEP 484. from import def f(p1: int, p2, , p3, p4: strc, , p572, p6, p7): .print(util.ParamVar(f).annotated) ("p1", "p2")

final-property aveytense.util.ParamVar.annotatedCount (≥ 0.3.44)

Equivalent to len(~.annotated).

final-property aveytense.util.ParamVar.annotatedDefaults (≥ 0.3.44)

Returns a tuple of parameters that have a type annotated and default value. Created to be convertible to dict. from import def f(p1: int, p2, , p3, p4: strc, , p572, p6, p7): .print(util.ParamVar(f).annotatedDefaults) ≥ 0.3.47: (("p4", (str, "c")),) / < 0.3.47: (("p4", "c"),) 0.3.47: Annotated type is now returned along with default value in separate tuple.

final-property aveytense.util.ParamVar.annotatedDefaultsCount (≥ 0.3.44)

Equivalent to len(~.annotatedDefaults).

final-property aveytense.util.ParamVar.annotatedNoDefaults (≥ 0.3.44)

final-property aveytense.util.ParamVar.annotatedNoDefaultsCount (≥ 0.3.44)

final-property aveytense.util.ParamVar.annotatedWithDefaults (≥ 0.3.51)

final-property aveytense.util.ParamVar.allWithDefaults (≥ 0.3.42)

static aveytense.util.ParamVar.fromType(t, i = 0, /) (≥ 0.3.51)

Alternative constructor for ~.util.ParamVar and for types instead of callable objects.

property aveytense.util.ParamVar.func (≥ 0.3.42)

Gets or sets a function either passed to the constructor or assigned via this property.

final-property aveytense.util.ParamVar.keyword (≥ 0.3.42)

final-property aveytense.util.ParamVar.keywordCount (≥ 0.3.44)

final-property aveytense.util.ParamVar.keywordDefaults (≥ 0.3.42)

final-property aveytense.util.ParamVar.keywordDefaultsCount (≥ 0.3.44)

final-property aveytense.util.ParamVar.keywordNoDefaults (≥ 0.3.44)

final-property aveytense.util.ParamVar.keywordNoDefaultsCount (≥ 0.3.42)

final-property aveytense.util.ParamVar.keywordWithDefaults (≥ 0.3.51)

final-property aveytense.util.ParamVar.positional (≥ 0.3.42)

final-property aveytense.util.ParamVar.positionalCount (≥ 0.3.44)

final-property aveytense.util.ParamVar.positionalDefaults (≥ 0.3.42)

final-property aveytense.util.ParamVar.positionalDefaultsCount (≥ 0.3.44)

final-property aveytense.util.ParamVar.positionalNoDefaults (≥ 0.3.44)

final-property aveytense.util.ParamVar.positionalNoDefaultsCount (≥ 0.3.44)

final-property aveytense.util.ParamVar.positionalWithDefaults (≥ 0.3.51)

final-property aveytense.util.ParamVar.variable (≥ 0.3.42)

final-property aveytense.util.ParamVar.variableCount (≥ 0.3.44)

final-class aveytense.RGB (≥ 0.3.28)

Creates a RGB (red-green-blue) tuple.

aveytense.RGB.__init__(red = 0, green = 0, blue = 0) (≥ 0.3.28)

Creates a new RGB class instance. Parameters represent colors as in mere RGB color picker.

aveytense.RGB.__bin__() (≥ 0.3.41)
final-property aveytense.RGB.bin (≥ 0.3.44)

Convert the RGB tuple to binary notation. Normally, it isn't possible to convert the ~.RGB class instance to binary via bin(), because this inbuilt function can only accept integer values or instances of classes implementing the __index__() method, which should return int. Both members return binary number with 0b preceding, as a string.

aveytense.RGB.__bool__() (≥ 0.3.41)

Always returns True.

aveytense.RGB.__bytes__() (≥ 0.3.41)

Convert the RGB tuple to bytes object.

aveytense.RGB.__hash__() (≥ 0.3.41)

Receive hash from RGB tuple.

aveytense.RGB.__hex__() (≥ 0.3.28)
final-property aveytense.RGB.hex (≥ 0.3.38)
final-property aveytense.RGB.cssHex (≥ 0.3.49)

Convert the RGB tuple to hexadecimal notation. Normally, it isn't possible to convert the ~.RGB class instance to hexadecimal via hex(), because this inbuilt function can only accept integer values or instances of classes implementing the __index__() method, which should return int. Both members return hexadecimal number with 0x preceding, as a string. Final property ~.cssHex returns the string with prefix # instead of 0x to be used in CSS.


              from  import 

              .print(RGB(0, 0, 85).__hex__()) 0x000055

              .print(RGB(0, 0, 85).hex) 0x000055

              .print(RGB(0, 0, 85).cssHex) #000055

aveytense.RGB.__int__() (≥ 0.3.28)

Convert the RGB tuple to int object. Formula: RGB(r, g, b) = #rrggbb => int(#rrggbb).


              from  import 

              .print(int(RGB(0, 0, 85))) 85

aveytense.RGB.__lt__() (≥ 0.3.28)
aveytense.RGB.__gt__() (≥ 0.3.28)
aveytense.RGB.__le__() (≥ 0.3.28)
aveytense.RGB.__ge__() (≥ 0.3.28)
aveytense.RGB.__eq__() (≥ 0.3.28)
aveytense.RGB.__ne__() (≥ 0.3.28)

Inspect 2 RGB class instances.


              from aveytense import 

              .print(RGB(0, 0, 85)RGB(0, 0, 102)) True

              .print(RGB(0, 0, 85)RGB(0, 0, 102)) False

              .print(RGB(0, 0, 85)RGB(0, 0, 102)) True

              .print(RGB(0, 0, 85)RGB(0, 0, 102)) False

              .print(RGB(0, 0, 85)RGB(0, 0, 102)) False

              .print(RGB(0, 0, 85)RGB(0, 0, 102)) True

aveytense.RGB.__oct__() (≥ 0.3.41)
final-property aveytense.RGB.oct (≥ 0.3.44)

Convert the RGB tuple to octal notation. Normally, it isn't possible to convert the ~.RGB class instance to octal via oct(), because this inbuilt function can only accept integer values or instances of classes implementing the __index__() method, which should return int. Both members return hexadecimal number with 0o preceding, as a string.


              from aveytense import 

              .print((RGB(0, 0, 85).__oct__())) 0o125

aveytense.RGB.__pos__() (≥ 0.3.28; < 0.3.49)
aveytense.RGB.__neg__() (≥ 0.3.28; < 0.3.49)
aveytense.RGB.__invert__() (≥ 0.3.28; < 0.3.49)
final-property aveytense.RGB.tuple (≥ 0.3.38)

Returns RGB tuple as a tuple.


              from  import 

              .print(RGB(0, 0, 85)) (0, 0, 85)

              .print(RGB(0, 0, 85)) (0, 0, 85)

              .print(RGB(0, 0, 85)) (0, 0, 85)

              .print(RGB(0, 0, 85).tuple) (0, 0, 85)

0.3.41: Methods __pos__(), __neg__() and __invert__() are deprecated and will be removed in 0.3.48. Use tuple final property instead. 0.3.49: Methods __pos__(), __neg__() and __invert__() have been removed. Suprisingly these existed in code for version 0.3.48.

aveytense.RGB.__repr__() (≥ 0.3.28)

Equals invocation of repr(self), and returns more representative version about the object.


              from  import 

              .print(repr(RGB(0, 0, 85))) <aveytense.RGB object: RGB(0, 0, 85)>

aveytense.RGB.__str__() (≥ 0.3.28)
final-property aveytense.RGB.cssRgb (≥ 0.3.49)

Returns RGB tuple as a string. Final property ~.cssRgb returns the lowercased version of the string to be used in CSS.


              from  import 

              .print(RGB(0, 0, 85)) RGB(0, 0, 85)

static aveytense.RGB.fromValue(n, /) (≥ 0.3.36)

Creates a new ~.RGB class object (this static method is alternative constructor for ~.RGB) using an integer or numeric string in range [0; 2²⁴ - 1]. Right side of range equals 16777215.


              from aveytense import 

              .print(RGB.fromValue(85)) RGB(0, 0, 85)

              .print(RGB.fromValue(0o257)) RGB(0, 0, 175)

              .print(RGB.fromValue(0xc0ffee)) RGB(12, 15, 238)

              .print(RGB.fromValue(0x1278)) RGB(0, 18, 120)

0.3.38: Improved checking in aveytense.Color constructor.

0.3.39: Improved string inspection; less strict checkery and it is now allowed to precede the numeric string with 0x, 0o and 0b.

0.3.42: Caught anomaly in string integer values: internal code of this static method didn't correctly convert it to RGB tuple.

final-class _aveytense.RGBA (≥ 0.3.37)

Creates a RGBA (red-green-blue-alpha) tuple.

class _{aveytense.util.}SortedList (≥ 0.3.35)

Creates always sorted list.

abstract-final-class _aveytense.TenseOptions
≥ 0.3.27a5; < 0.3.60

Provides additional options influencing methods in class ~.Tense. All are variables, which can hold boolean values only.

Option name	Lifetime	Description
`~.disableProbability2LengthLimit`	≥ 0.3.31; < 0.3.46	It was applied to `~.Tense.probability2()`. Allowed to remove the lengh limit related to `sys.maxsize`. This attribute was been removed in version 0.3.46, according to change occured in class methods `~.Tense.probability()` and `~.Tense.probability2()`. 0.3.46
`~.initializationMessage`	≥ 0.3.27a5; < 0.3.40	It was applied to constructor of `~.Tense`. 0.3.40
`~.insertionMessage`	≥ 0.3.27b1; < 0.3.60	Applies to `~.Tense.print()`. 0.3.50 0.3.60
`~.probabilityExtendedLength`	≥ unavailable (≥ 0.3.27rc1; < 0.3.60 in code)	Had to apply to `~.Tense.probability()`. This variable was bound with usage of nested list in order to extend number support, bypassing `sys.maxsize`. This attribute was marked unrealized in version 0.3.46, according to change occured in class methods `~.Tense.probability2()` and `~.Tense.probability()`.

0.3.50

0.3.60

class _{aveytense.util.}uniquelist(iterable = ...)
≥ 0.3.48

Returns a set-like list object without duplicate items.

This class can be expected as shortcut of list(set(iterable)), but this isn't true. Except no duplicate items, order of the iterable's items doesn't change (set objects sort the iterable in ascending order, as in math), even if excluding the same items directly mutate the returned list. Example:

$k[from] $m[aveytense].$msu[util] $k[import] $c[uniquelist] $v[a] $o[=] [$n[761], $n[891], $n[112], $n[112], $n[891]] $f[print]($c[list]($c[set]($v[a]))) # [112, 761, 891] $f[print]($c[uniquelist]($v[a]))) # [761, 891, 112]

Implementation of aveytense.util.uniquelist class constructor is roughly equivalent (without type hinting) to:

$k[def] $f[uniquelist]($p[iterable] $o[=] $o[...]): $k[if] $p[iterable] $k[is] $con[Ellipsis]: $k[return] [] $v[_new_list_] $o[=] [] $v[_list_] $o[=] $c[list]($p[iterable]) $k[for] $v[e] $k[in] $v[_list_]: $k[if] $v[e] $k[not] $k[in] $v[_list_]: $v[_new_list_].$f[append]($v[e]) $k[return] $v[_new_list_]

To check, if all items are unique, consider using aveytense.Tense.inequal() with unpacking operator * as aveytense.Tense.inequal(*aveytense.util.uniquelist(iterable)).

class _{aveytense.util.}uniquetuple(iterable = ...)
≥ 0.3.48

Returns a set-like tuple object without duplicate items, as well without order change. In AveyTense code it is the same as tuple(aveytense.util.uniquelist(...)).

Functions and decorators

Functions and decorators in AveyTense. Methods are included in classes.

_aveytense.abroad(value1, /, value2 = None, modifier = None) (≥ 0.3.9)

Overall extension of range() function. Represents the easiest function to return abroad objects. The differences between range() and ~.abroad() functions are:

~.abroad() function doesn't have overloads
~.abroad() supports complex objects, iterables and file objects, doesn't support ellipsis though
step (modifier) in function ~.abroad() has no sign sensitivity (can be negative or positive, code will always go towards endpoint). This behavior is not preferred to use though
~.abroad() supports floating-point numbers

Understanding this function might be more sophisticated than range(), but there are benefits:

allows to refrain from using range(len()) and range(len(file.readlines())), no matter in which parameter
last 2 parameters don't need to be passed by position
first parameter can be negative and can count towards -1

Parameters:

value1 (former name: __value1) - The only mandatory parameter. And this parameter supports abundant gamut of types, including integers, but also floating-point numbers, complex numbers, sizeable objects, including string, list, tuple, dictionairies etc. These obscure with types supported by reckon() function; the abroad() function uses this function in reality. This parameter is a blend of range() function parameters __stop (if it is the only parameter passed) and __start (if there are more than one argument passed).

value2 (Optional; former name: __value2) - First optional parameter. Supports all sizeable objects from parameter value1, integers, floats, boolean values, the None type and also ellipsis. Defaults to None. This parameter is counterpart of range() function parameter __stop.

modifier (Optional; former name: __modifier) - Second optional parameter. Supports all sizeable objects from parameter value1, integers, floats, complex numbers, the None type and also ellipsis. Defaults to None. This parameter is counterpart of range() function parameter __step.

Previous parameter notations probably came to support pre-PEP 570 parameters. This function was really fun to make and solve mistakes inside its code. Its name abroad (behind or outside border) is tantamount with following sentence: this function really deviate from common functionality range() function offers. The argument, which led to start building my own version of range() function is because of reluctance to use this function for no reason totally! It was typically just a resign from using combination range(len()) in favor of this function. Moreover, this function solves several problems, like in class method ~.Tense.probability(). What's interesting, inner code of abroad() function has lack of for loops (only while) and there are no invocations (even one) of range()! Below example counting backwards, with range() function:


          list((6)) [-6, -5, -4, -3, -2, -1]

          list(range(6)) []

0.3.10 0.3.28: the function returns abroad object instead of list built-in.

aveytense.games.aeify(s, /) (≥ 0.3.9; < 0.3.24; ≥ 0.3.26a4; < 0.3.47)

This function converted all a and e letters occurrences into æ. Not recommended for terminals that don't read letters outside Latin-1 (ISO/IEC 8859-1 encoding). 0.3.47: To be used in separate project aveytense_games.

@aveytense.util.final (≥ 0.3.26b3)

Creates a final class. Equivalent to ~.Final, just used as decorator instead of base class.

@aveytense.util.finalmethod (≥ 0.3.27rc2)

Creates a final method. Equivalent to @typing.final.

class @aveytense.util.finalproperty (≥ 0.3.37)

Creates a final property accessible via class instance. This kind of properties cannot be modified nor deleted. To inspect these properties, it is advisable to use ~.Tense.isFinalProperty() class method. Usage with isinstance() Python function as isinstance(<class.attribute>, ~.util.finalproperty) works too. Using isinstance() as isinstance(<class.finalproperty>, property) returns False. Unlike for @property decorator, before 0.3.42, property created via ~.finalproperty decorator had typing.Any type hinted. Version 0.3.42 fixed this issue, but properties decorated with this class (~.finalproperty is actually a class) can have their values accessed via class reference too. Only in version 0.3.43 it has been fixed - and technique from 0.3.42 in method ~.Tense.isFinalProperty(), which required 2-item tuple with a type (class) and member name in a string is no longer required, however, will be kept for backward-compatibility. Since version 0.3.42 ~.finalproperty is generic class. Correct type hint was provided in 0.3.43.

class @aveytense.util.finalpropertycontainer(**properties) (≥ 0.3.43)

This class decorator creates class holding final properties, which values are assigned via variable keyword parameter properties to the affected class. If properties had keyword _static_ (with value True), affected class cannot be initialized, and can access all final properties via reference. If there are already attributes defined, and properties has the same names of attributes, these are overriden by these defined in properties. When _static_ has value True, internal code actually creates an object of the class, and in type hinting it isn't visible. 0.3.50: Marked experimental and not recommended to use; instead use @finalproperty.

aveytense.games.oeify(s, /) (≥ 0.3.9; < 0.3.24; ≥ 0.3.26a4; < 0.3.47)

This function converted all o and e letters occurrences into œ. Not recommended for terminals that don't read letters outside Latin-1 (ISO/IEC 8859-1 encoding). 0.3.47: To be used in separate project aveytense_games.

aveytense.games.owoify(s, /) (≥ 0.3.9; < 0.3.24; ≥ 0.3.25; < 0.3.47)
aveytense.games.uwuify(s, /) (≥ 0.3.27b2; < 0.3.47)

A joke function, which translated a string into a furry talk. Source here 0.3.47: To be used in separate project aveytense_games.

AveyTense

Relation to PEP 8

Versioning

Supported Python versions

Download

AveyTense Definitions

Tutorial

aveytense.Tense

aveytense.extensions

Available definitions

`aveytense` module

`aveytense.constants` module

`aveytense.exceptions` module

`aveytense.extensions` module

`aveytense.operators` module

`aveytense.util` module

Removed definitions

`aveytense` module

aveytense.extensions module

aveytense.games module

aveytense.util module

outdated article below

Available definitions

Constants

Content of `aveytense.Tense`

Math constants

Trigonemetric functions

Figurate number functions

Miscellaneous functions

Functions and decorators

Type alias details
Referred class/type	Python versions
collections.abc.ValuesView	≥ 3.9
typing.ValuesView	< 3.9

AveyTense

Relation to PEP 8

Versioning

Supported Python versions

Download

AveyTense Definitions

Tutorial

aveytense.Tense

aveytense.extensions

Available definitions

aveytense module

aveytense.constants module

aveytense.exceptions module

aveytense.extensions module

aveytense.operators module

aveytense.util module

Removed definitions

aveytense module

aveytense.extensions module

aveytense.games module

aveytense.util module

outdated article below

Available definitions

Constants

Content of aveytense.Tense

Math constants

Trigonemetric functions

Figurate number functions

Miscellaneous functions

Functions and decorators

`aveytense` module

`aveytense.constants` module

`aveytense.exceptions` module

`aveytense.extensions` module

`aveytense.operators` module

`aveytense.util` module

`aveytense` module

Content of `aveytense.Tense`