':param name: Name of this pattern
:type name: str
:param tags: List of tags related to this pattern
:type tags: list[str]
:param formatter: dict (name, func) of formatter to use with this pattern. name is the match name to support,
and func a function(input_string) that returns the formatted string. A single formatter function can also be
passed as a shortcut for {None: formatter}. The returned formatted string with be set in Match.value property.
:type formatter: dict[str, func] || func
:param value: dict (name, value) of value to use with this pattern. name is the match name to support,
and value an object for the match value. A single object value can also be
passed as a shortcut for {None: value}. The value with be set in Match.value property.
:type value: dict[str, object] || object
:param validator: dict (name, func) of validator to use with this pattern. name is the match name to support,
and func a function(match) that returns the a boolean. A single validator function can also be
passed as a shortcut for {None: validator}. If return value is False, match will be ignored.
:param children: generates children instead of parent
:type children: bool
:param every: generates both parent and children.
:type every: bool
:param private: flag this pattern as beeing private.
:type private: bool
:param private_parent: force return of parent and flag parent matches as private.
:type private_parent: bool
:param private_children: force return of children and flag children matches as private.
:type private_children: bool
:param private_names: force return of named matches as private.
:type private_names: bool
:param ignore_names: drop some named matches after validation.
:type ignore_names: bool
:param marker: flag this pattern as beeing a marker.
:type private: bool
:param format_all if True, pattern will format every match in the hierarchy (even match not yield).
:type format_all: bool
:param validate_all if True, pattern will validate every match in the hierarchy (even match not yield).
:type validate_all: bool
:param disabled: if True, this pattern is disabled. Can also be a function(context).
:type disabled: bool|function
:param log_lvl: Log level associated to this pattern
:type log_lvl: int'

def __init__(self, name=None, tags=None, formatter=None, value=None, validator=None, children=False, every=False, private_parent=False, private_children=False, private=False, private_names=None, ignore_names=None, marker=False, format_all=False, validate_all=False, disabled=(lambda context: False), log_level=None, properties=None):

    self.name = name
    self.tags = ensure_list(tags)
    (self.formatters, self._default_formatter) = ensure_dict(formatter, (lambda x: x))
    (self.values, self._default_value) = ensure_dict(value, None)
    (self.validators, self._default_validator) = ensure_dict(validator, (lambda match: True))
    self.every = every
    self.children = children
    self.private = private
    self.private_names = (private_names if private_names else [])
    self.ignore_names = (ignore_names if ignore_names else [])
    self.private_parent = private_parent
    self.private_children = private_children
    self.marker = marker
    self.format_all = format_all
    self.validate_all = validate_all
    if (not callable(disabled)):
        self.disabled = (lambda context: disabled)
    else:
        self.disabled = disabled
    self._log_level = log_level
    self._properties = properties
    self.defined_at = debug.defined_at()
