string

string#

Source code: sensai/util/string.py

class StringConverter[source]#

Bases: ABC

Abstraction for a string conversion mechanism

abstract to_string(x) → str[source]#

dict_string(d: Mapping, brackets: Optional[str] = None, converter: Optional[StringConverter] = None)[source]#

Converts a dictionary to a string of the form “<key>=<value>, <key>=<value>, …”, optionally enclosed by brackets

Parameters:

d – the dictionary
brackets – a two-character string containing the opening and closing bracket to use, e.g. "{}"; if None, do not use enclosing brackets
converter – the string converter to use for values

Returns:

the string representation

list_string(l: Iterable[Any], brackets='[]', quote: Optional[str] = None, converter: Optional[StringConverter] = None)[source]#

Converts a list or any other iterable to a string of the form “[<value>, <value>, …]”, optionally enclosed by different brackets or with the values quoted.

Parameters:

l – the list
brackets – a two-character string containing the opening and closing bracket to use, e.g. "[]"; if None, do not use enclosing brackets
quote – a 1-character string defining the quote to use around each value, e.g. "'".
converter – the string converter to use for values

Returns:

the string representation

to_string(x, converter: Optional[StringConverter] = None, apply_converter_to_non_complex_objects=True, context=None)[source]#

Converts the given object to a string, with proper handling of lists, tuples and dictionaries, optionally using a converter. The conversion also removes unwanted line breaks (as present, in particular, in sklearn’s string representations).

Parameters:

x – the object to convert
converter – the converter with which to convert objects to strings
apply_converter_to_non_complex_objects – whether to apply/pass on the converter (if any) not only when converting complex objects but also non-complex, primitive objects; use of this flag enables converters to implement their conversion functionality using this function for complex objects without causing an infinite recursion.
context – context in which the object is being converted (e.g. dictionary key for case where x is the corresponding dictionary value), only for debugging purposes (will be reported in log messages upon recursion exception)

Returns:

the string representation

object_repr(obj, member_names_or_dict: Union[List[str], Dict[str, Any]])[source]#

or_regex_group(allowed_names: Sequence[str])[source]#

Parameters:: allowed_names – strings to include as literals in the regex
Returns:: a regular expression string of the form (<name1>| …|<nameN>), which any of the given names

function_name(x: Callable) → str[source]#

class ToStringMixin[source]#

Bases: object

Provides implementations for __str__ and __repr__ which are based on the format "<class name>[<object info>]" and "<class name>[id=<object id>, <object info>]" respectively, where <object info> is usually a list of entries of the form "<name>=<value>, ...".

By default, <class name> will be the qualified name of the class, and <object info> will include all properties of the class, including private ones starting with an underscore (though the underscore will be dropped in the string representation).

To exclude private properties, override _tostring_exclude_private() to return True. If there are exceptions (and some private properties shall be retained), additionally override _tostring_exclude_exceptions().

To exclude a particular set of properties, override _tostring_excludes().

To include only select properties (introducing inclusion semantics), override _tostring_includes().

To add values to the properties list that aren’t actually properties of the object (i.e. derived properties), override _tostring_additional_entries().

To define a fully custom representation for <object info> which is not based on the above principles, override _tostring_object_info().

For well-defined string conversions within a class hierarchy, it can be a good practice to define additional inclusions/exclusions by overriding the respective method once more and basing the return value on an extended version of the value returned by superclass. In some cases, the requirements of a subclass can be at odds with the definitions in the superclass: The superclass may make use of exclusion semantics, but the subclass may want to use inclusion semantics (and include only some of the many properties it adds). In this case, if the subclass used _tostring_includes(), the exclusion semantics of the superclass would be void and none of its properties would actually be included. In such cases, override _tostring_includes_forced() to add inclusions regardless of the semantics otherwise used along the class hierarchy.

_tostring_class_name()[source]#

Returns:: the string use for <class name> in the string representation "<class name>[<object info]"

_tostring_object_info() → str[source]#

Override this method to use a fully custom definition of the <object info> part in the full string representation "<class name>[<object info>]" to be generated. As soon as this method is overridden, any property-based exclusions, inclusions, etc. will have no effect (unless the implementation is specifically designed to make use of them - as is the default implementation). NOTE: Overrides must not internally use super() because of a technical limitation in the proxy object that is used for nested object structures.

Returns:: a string containing the string to use for <object info>

_tostring_excludes() → List[str][source]#

Makes the string representation exclude the returned attributes. This method can be conveniently overridden by subclasses which can call super and extend the list returned.

This method will only have no effect if _tostring_object_info() is overridden to not use its result.

Returns:: a list of attribute names

_tostring_exclude_exceptions() → List[str][source]#

Defines attribute names which should not be excluded even though other rules (particularly the exclusion of private members via _tostring_exclude_private()) would otherwise exclude them.

Returns:: a list of attribute names

_tostring_includes() → List[str][source]#

Makes the string representation include only the returned attributes (i.e. introduces inclusion semantics); By default, the list contains only a marker element, which is interpreted as “all attributes included”.

This method can be conveniently overridden by sub-classes which can call super and extend the list returned. Note that it is not a problem for a list containing the aforementioned marker element (which stands for all attributes) to be extended; the marker element will be ignored and only the user-added elements will be considered as included.

Note: To add an included attribute in a sub-class, regardless of any super-classes using exclusion or inclusion semantics, use _tostring_includes_forced() instead.

This method will have no effect if _tostring_object_info() is overridden to not use its result.

Returns:: a list of attribute names to be included in the string representation

_tostring_includes_forced() → List[str][source]#

Defines a list of attribute names that are required to be present in the string representation, regardless of the instance using include semantics or exclude semantics, thus facilitating added inclusions in sub-classes.

This method will have no effect if _tostring_object_info() is overridden to not use its result.

Returns:: a list of attribute names

_tostring_additional_entries() → Dict[str, Any][source]#

Returns:: a dictionary of entries to be included in the <object info> part of the string representation

_tostring_exclude_private() → bool[source]#

Returns:: whether to exclude properties that are private (start with an underscore); explicitly included attributes will still be considered - as will properties exempt from the rule via _tostring_exclude_exceptions().

pprint(file=<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)[source]#

Prints a prettily formatted string representation of the object (with line breaks and indentations) to stdout or the given file.

Parameters:: file – the file to print to

pprints() → str[source]#

Returns:: a prettily formatted string representation with line breaks and indentations

pretty_string_repr(s: Any, initial_indentation_level=0, indentation_string=' ')[source]#

Creates a pretty string representation (using indentations) from the given object/string representation (as generated, for example, via ToStringMixin). An indentation level is added for every opening bracket.

Parameters:

s – an object or object string representation
initial_indentation_level – the initial indentation level
indentation_string – the string which corresponds to a single indentation level

Returns:

a reformatted version of the input string with added indentations and line breaks

class TagBuilder(*initial_components: str, glue='_')[source]#

Bases: object

Assists in building strings made up of components that are joined via a glue string

Parameters:

initial_components – initial components to always include at the beginning
glue – the glue string which joins components

with_component(component: str)[source]#

with_conditional(cond: bool, component: str)[source]#

Conditionally adds the given component

Parameters:

cond – the condition
component – the component to add if the condition holds

Returns:

the builder

with_alternative(cond: bool, true_component: str, false_component: str)[source]#

Adds a component depending on a condition

Parameters:

cond – the condition
true_component – the component to add if the condition holds
false_component – the component to add if the condition does not hold

Returns:

the builder

build()[source]#

Returns:: the string (with all components joined)