serializable
Submodules
Package Contents
Classes
Base of all views. |
|
Enum to define the different formats supported for serialization and deserialization. |
|
Enum to differentiate how array-type properties (think Iterables) are serialized. |
|
namespace-like |
Functions
Decorator |
|
Decorator used to tell |
|
|
Decorator |
|
Decorator |
|
Decorator |
|
Decorator |
|
Decorator |
|
Decorator |
|
Decorator |
|
Decorator |
|
Decorator |
Attributes
The logger. The thing that captures all this package has to say. |
- serializable.logger
The logger. The thing that captures all this package has to say. Feel free to modify its level and attach handlers to it.
- class serializable.ViewType
Base of all views.
- class serializable.SerializationType
Bases:
str
,enum.Enum
Enum to define the different formats supported for serialization and deserialization.
- JSON = 'JSON'
- XML = 'XML'
- capitalize()
Return a capitalized version of the string.
More specifically, make the first character have upper case and the rest lower case.
- casefold()
Return a version of the string suitable for caseless comparisons.
- center()
Return a centered string of length width.
Padding is done using the specified fill character (default is a space).
- count()
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation.
- encode()
Encode the string using the codec registered for encoding.
- encoding
The encoding in which to encode the string.
- errors
The error handling scheme to use for encoding errors. The default is ‘strict’ meaning that encoding errors raise a UnicodeEncodeError. Other possible values are ‘ignore’, ‘replace’ and ‘xmlcharrefreplace’ as well as any other name registered with codecs.register_error that can handle UnicodeEncodeErrors.
- endswith()
S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. suffix can also be a tuple of strings to try.
- expandtabs()
Return a copy where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
- find()
S.find(sub[, start[, end]]) -> int
Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- format()
S.format(*args, **kwargs) -> str
Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces (‘{’ and ‘}’).
- format_map()
S.format_map(mapping) -> str
Return a formatted version of S, using substitutions from mapping. The substitutions are identified by braces (‘{’ and ‘}’).
- index()
S.index(sub[, start[, end]]) -> int
Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.
Raises ValueError when the substring is not found.
- isalnum()
Return True if the string is an alpha-numeric string, False otherwise.
A string is alpha-numeric if all characters in the string are alpha-numeric and there is at least one character in the string.
- isalpha()
Return True if the string is an alphabetic string, False otherwise.
A string is alphabetic if all characters in the string are alphabetic and there is at least one character in the string.
- isascii()
Return True if all characters in the string are ASCII, False otherwise.
ASCII characters have code points in the range U+0000-U+007F. Empty string is ASCII too.
- isdecimal()
Return True if the string is a decimal string, False otherwise.
A string is a decimal string if all characters in the string are decimal and there is at least one character in the string.
- isdigit()
Return True if the string is a digit string, False otherwise.
A string is a digit string if all characters in the string are digits and there is at least one character in the string.
- isidentifier()
Return True if the string is a valid Python identifier, False otherwise.
Call keyword.iskeyword(s) to test whether string s is a reserved identifier, such as “def” or “class”.
- islower()
Return True if the string is a lowercase string, False otherwise.
A string is lowercase if all cased characters in the string are lowercase and there is at least one cased character in the string.
- isnumeric()
Return True if the string is a numeric string, False otherwise.
A string is numeric if all characters in the string are numeric and there is at least one character in the string.
- isprintable()
Return True if the string is printable, False otherwise.
A string is printable if all of its characters are considered printable in repr() or if it is empty.
- isspace()
Return True if the string is a whitespace string, False otherwise.
A string is whitespace if all characters in the string are whitespace and there is at least one character in the string.
- istitle()
Return True if the string is a title-cased string, False otherwise.
In a title-cased string, upper- and title-case characters may only follow uncased characters and lowercase characters only cased ones.
- isupper()
Return True if the string is an uppercase string, False otherwise.
A string is uppercase if all cased characters in the string are uppercase and there is at least one cased character in the string.
- join()
Concatenate any number of strings.
The string whose method is called is inserted in between each given string. The result is returned as a new string.
Example: ‘.’.join([‘ab’, ‘pq’, ‘rs’]) -> ‘ab.pq.rs’
- ljust()
Return a left-justified string of length width.
Padding is done using the specified fill character (default is a space).
- lower()
Return a copy of the string converted to lowercase.
- lstrip()
Return a copy of the string with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
- partition()
Partition the string into three parts using the given separator.
This will search for the separator in the string. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.
If the separator is not found, returns a 3-tuple containing the original string and two empty strings.
- removeprefix()
Return a str with the given prefix string removed if present.
If the string starts with the prefix string, return string[len(prefix):]. Otherwise, return a copy of the original string.
- removesuffix()
Return a str with the given suffix string removed if present.
If the string ends with the suffix string and that suffix is not empty, return string[:-len(suffix)]. Otherwise, return a copy of the original string.
- replace()
Return a copy with all occurrences of substring old replaced by new.
- count
Maximum number of occurrences to replace. -1 (the default value) means replace all occurrences.
If the optional argument count is given, only the first count occurrences are replaced.
- rfind()
S.rfind(sub[, start[, end]]) -> int
Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.
Return -1 on failure.
- rindex()
S.rindex(sub[, start[, end]]) -> int
Return the highest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation.
Raises ValueError when the substring is not found.
- rjust()
Return a right-justified string of length width.
Padding is done using the specified fill character (default is a space).
- rpartition()
Partition the string into three parts using the given separator.
This will search for the separator in the string, starting at the end. If the separator is found, returns a 3-tuple containing the part before the separator, the separator itself, and the part after it.
If the separator is not found, returns a 3-tuple containing two empty strings and the original string.
- rsplit()
Return a list of the substrings in the string, using sep as the separator string.
- sep
The separator used to split the string.
When set to None (the default value), will split on any whitespace character (including n r t f and spaces) and will discard empty strings from the result.
- maxsplit
Maximum number of splits (starting from the left). -1 (the default value) means no limit.
Splitting starts at the end of the string and works to the front.
- rstrip()
Return a copy of the string with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
- split()
Return a list of the substrings in the string, using sep as the separator string.
- sep
The separator used to split the string.
When set to None (the default value), will split on any whitespace character (including n r t f and spaces) and will discard empty strings from the result.
- maxsplit
Maximum number of splits (starting from the left). -1 (the default value) means no limit.
Note, str.split() is mainly useful for data that has been intentionally delimited. With natural text that includes punctuation, consider using the regular expression module.
- splitlines()
Return a list of the lines in the string, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends is given and true.
- startswith()
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise. With optional start, test S beginning at that position. With optional end, stop comparing S at that position. prefix can also be a tuple of strings to try.
- strip()
Return a copy of the string with leading and trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
- swapcase()
Convert uppercase characters to lowercase and lowercase characters to uppercase.
- title()
Return a version of the string where each word is titlecased.
More specifically, words start with uppercased characters and all remaining cased characters have lower case.
- translate()
Replace each character in the string using the given translation table.
- table
Translation table, which must be a mapping of Unicode ordinals to Unicode ordinals, strings, or None.
The table must implement lookup/indexing via __getitem__, for instance a dictionary or list. If this operation raises LookupError, the character is left untouched. Characters mapped to None are deleted.
- upper()
Return a copy of the string converted to uppercase.
- zfill()
Pad a numeric string with zeros on the left, to fill a field of the given width.
The string is never truncated.
- name()
The name of the Enum member.
- value()
The value of the Enum member.
- class serializable.XmlArraySerializationType(*args, **kwds)
Bases:
enum.Enum
Enum to differentiate how array-type properties (think Iterables) are serialized.
Given a
Warehouse
has a propertyboxes
that returns List[Box]:FLAT
would allow for XML looking like:`` <warehouse>
<box>..box 1..</box> <box>..box 2..</box>
</warehouse> ``
NESTED
would allow for XML looking like:`` <warehouse>
- <boxes>
<box>..box 1..</box> <box>..box 2..</box>
</boxes>
</warehouse> ``
- FLAT = 1
- NESTED = 2
- name()
The name of the Enum member.
- value()
The value of the Enum member.
- class serializable.ObjectMetadataLibrary
namespace-like
The core Class in
serializable
that is used to record all metadata about classes that you annotate for serialization and deserialization.- class SerializableClass(*, klass: type, custom_name: str | None = None, serialization_types: Iterable[SerializationType] | None = None, ignore_during_deserialization: Iterable[str] | None = None)
Internal model class used to represent metadata we hold about Classes that are being included in (de-)serialization.
- property name: str
- property klass: type
- property custom_name: str | None
- property serialization_types: Iterable[SerializationType]
- property ignore_during_deserialization: Set[str]
- class SerializableProperty(*, prop_name: str, prop_type: Any, custom_names: Dict[SerializationType, str], custom_type: Any | None = None, include_none_config: Set[Tuple[Type[ViewType], Any]] | None = None, is_xml_attribute: bool = False, string_format_: str | None = None, views: Iterable[Type[ViewType]] | None = None, xml_array_config: Tuple[XmlArraySerializationType, str] | None = None, xml_sequence_: int | None = None)
Internal model class used to represent metadata we hold about Properties that are being included in (de-)serialization.
- property name: str
- property custom_names: Dict[SerializationType, str]
- property type_: Any
- property concrete_type: Any
- property custom_type: Any | None
- property include_none: bool
- property is_xml_attribute: bool
- property string_format: str | None
- property xml_array_config: Tuple[XmlArraySerializationType, str] | None
- property is_array: bool
- property is_enum: bool
- property is_optional: bool
- property xml_sequence: int
- custom_name(serialization_type: SerializationType) str | None
- is_helper_type() bool
- is_primitive_type() bool
- parse_type_deferred() None
- custom_enum_klasses: Set[Type[enum.Enum]]
- klass_mappings: Dict[str, ObjectMetadataLibrary]
- klass_property_mappings: Dict[str, Dict[str, ObjectMetadataLibrary]]
- classmethod defer_property_type_parsing(prop: ObjectMetadataLibrary, klasses: Iterable[str]) None
- classmethod is_klass_serializable(klass: Any) bool
- classmethod is_property(o: Any) bool
- classmethod register_enum(klass: Type[_E]) Type[_E]
- classmethod register_klass(klass: Type[_T], custom_name: str | None, serialization_types: Iterable[SerializationType], ignore_during_deserialization: Iterable[str] | None = None) Type[_T] | Type[_JsonSerializable] | Type[_XmlSerializable]
- classmethod register_custom_json_property_name(qual_name: str, json_property_name: str) None
- classmethod register_custom_string_format(qual_name: str, string_format: str) None
- classmethod register_custom_xml_property_name(qual_name: str, xml_property_name: str) None
- classmethod register_property_include_none(qual_name: str, view_: Type[ViewType] | None = None, none_value: Any | None = None) None
- classmethod register_xml_property_array_config(qual_name: str, array_type: XmlArraySerializationType, child_name: str) None
- classmethod register_xml_property_attribute(qual_name: str) None
- classmethod register_xml_property_sequence(qual_name: str, sequence: int) None
- classmethod register_property_type_mapping(qual_name: str, mapped_type: type) None
- serializable.serializable_enum(cls: Literal[None] = None) Callable[[Type[_E]], Type[_E]]
- serializable.serializable_enum(cls: Type[_E]) Type[_E]
Decorator
- serializable.serializable_class(cls: Literal[None] = None, *, name: str | None = ..., serialization_types: Iterable[SerializationType] | None = ..., ignore_during_deserialization: Iterable[str] | None = ...) Callable[[Type[_T]], Type[_T] | Type[_JsonSerializable] | Type[_XmlSerializable]]
- serializable.serializable_class(cls: Type[_T], *, name: str | None = ..., serialization_types: Iterable[SerializationType] | None = ..., ignore_during_deserialization: Iterable[str] | None = ...) Type[_T] | Type[_JsonSerializable] | Type[_XmlSerializable]
Decorator used to tell
serializable
that a class is to be included in (de-)serialization.- Parameters:
cls – Class
name – Alternative name to use for this Class
serialization_types – Serialization Types that are to be supported for this class.
ignore_during_deserialization – List of properties/elements to ignore during deserialization
- Returns:
- serializable.type_mapping(type_: type) Callable[[_F], _F]
Decorator
- serializable.include_none(view_: Type[ViewType] | None = None, none_value: Any | None = None) Callable[[_F], _F]
Decorator
- serializable.json_name(name: str) Callable[[_F], _F]
Decorator
- serializable.string_format(format_: str) Callable[[_F], _F]
Decorator
- serializable.xml_attribute() Callable[[_F], _F]
Decorator
- serializable.xml_array(array_type: XmlArraySerializationType, child_name: str) Callable[[_F], _F]
Decorator
- serializable.xml_name(name: str) Callable[[_F], _F]
Decorator
- serializable.xml_sequence(sequence: int) Callable[[_F], _F]
Decorator