content: [tool.mypy]
  color_output = true
  error_summary = true
  pretty = true
  show_error_context = true
  show_column_numbers = true
  soft_error_limit = 20
  warn_redundant_casts = true
  warn_return_any = true
  warn_unreachable = true
  warn_unused_configs = true
  warn_unused_ignores = true
  exclude = "svgelements.py"
  
  
  [tool.isort]
  profile = "black"
  line_length = 88
  src_paths =  ["meerk40t"]
  
  
  [tool.black]
  line-length = 88
  target-version = ['py36']
  include = '\.pyi?$'
  
  
  [tool.flake8]
  filename = "*.py"
  count = "true"
  exclude = [
      "*.pyc",
      "__pycache__",
      "svgelements.py"
  ]
  indent-size = 4
  max-complexity = 10
  max-line-length = 88
  show-source = "true"
  statistics = "true"
  
  
  [tool.pylint.master]
  # A comma-separated list of package or module names from where C extensions may
  # be loaded. Extensions are loading into the active Python interpreter and may
  # run arbitrary code.
  extension-pkg-whitelist = ""
  
  # Add files or directories to the blacklist. They should be base names, not
  # paths.
  ignore = "CVS"
  
  # Add files or directories matching the regex patterns to the blacklist. The
  # regex matches against base names, not paths.
  ignore-patterns = ""
  
  # Python code to execute, usually for sys.path manipulation such as
  # pygtk.require().
  #init-hook = ""
  
  # Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
  # number of processors available to use.
  jobs = 0
  
  # Control the amount of potential inferred values when inferring a single
  # object. This can help the performance when dealing with large functions or
  # complex, nested conditions.
  limit-inference-results = 100
  
  # List of plugins (as comma separated values of python modules names) to load,
  # usually to register additional checkers.
  load-plugins = ""
  
  # Pickle collected data for later comparisons.
  persistent = true
  
  # Specify a configuration file.
  #rcfile = ""
  
  # When enabled, pylint would attempt to guess common misconfiguration and emit
  # user-friendly hints instead of false-positive error messages.
  suggestion-mode = true
  
  # Allow loading of arbitrary C extensions. Extensions are imported into the
  # active Python interpreter and may run arbitrary code.
  unsafe-load-any-extension = false
  
  
  [tool.pylint.'messages control']
  # Only show warnings with the listed confidence levels. Leave empty to show
  # all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED.
  confidence = ""
  
  # Disable the message, report, category or checker with the given id(s). You
  # can either give multiple identifiers separated by comma (,) or put this
  # option multiple times (only on the command line, not in the configuration
  # file where it should appear only once). You can also use "--disable = all" to
  # disable everything first and then reenable specific checks. For example, if
  # you want to run only the similarities checker, you can use "--disable = all
  # --enable = similarities". If you want to run only the classes checker, but have
  # no Warning level messages displayed, use "--disable = all --enable = classes
  # --disable = W".
  #disable = "all"
  enable = "all"
  
  # Enable the message, report, category or checker with the given id(s). You can
  # either give multiple identifier separated by comma (,) or put this option
  # multiple time (only on the command line, not in the configuration file where
  # it should appear only once). See also the "--disable" option for examples.
  #enable = [
  #       consider-using-enumerate,
  #       format-combined-specification,
  #       return-in-init,
  #       catching-non-exception,
  #       bad-except-order,
  #       unexpected-special-method-signature,
  #       # Enforce list comprehensions
  #       # Newline at EOF
  #       raising-bad-type,
  #       raising-non-exception,
  #       format-needs-mapping,
  #       invalid-all-object,
  #       bad-super-call,
  #       nonexistent-operator,
  #       missing-kwoa,
  #       missing-format-argument-key,
  #       init-is-generator,
  #       access-member-before-definition,
  #       used-before-assignment,
  #       redundant-keyword-arg,
  #       assert-on-tuple,
  #       assignment-from-no-return,
  #       expression-not-assigned,
  #       misplaced-bare-raise,
  #       redefined-argument-from-local,
  #       not-in-loop,
  #       bad-exception-context,
  #       unidiomatic-typecheck,
  #       no-staticmethod-decorator,
  #       nonlocal-and-global,
  #       confusing-with-statement,
  #       global-variable-undefined,
  #       global-variable-not-assigned,
  #       inconsistent-mro,
  #       no-classmethod-decorator,
  #       nonlocal-without-binding,
  #       duplicate-bases,
  #       duplicate-argument-name,
  #       duplicate-key,
  #       useless-else-on-loop,
  #       arguments-differ,
  #       logging-too-many-args,
  #       too-few-format-args,
  #       bad-format-string-key,
  #       invalid-sequence-index,
  #       inherit-non-class,
  #       bad-format-string,
  #       invalid-format-index,
  #       invalid-star-assignment-target,
  #       no-method-argument,
  #       no-value-for-parameter,
  #       missing-format-attribute,
  #       logging-too-few-args,
  #       too-few-format-args,
  #       mixed-format-string,
  #       # Old style class
  #       logging-format-truncated,
  #       truncated-format-string,
  #       notimplemented-raised,
  #       # Builtin redefined
  #       function-redefined,
  #       reimported,
  #       repeated-keyword,
  #       lost-exception,
  #       return-outside-function,
  #       return-arg-in-generator,
  #       non-iterator-returned,
  #       method-hidden,
  #       too-many-star-expressions,
  #       trailing-whitespace,
  #       unexpected-keyword-arg,
  #       missing-format-string-key,
  #       unnecessary-lambda,
  #       unnecessary-pass,
  #       unreachable,
  #       logging-unsupported-format,
  #       bad-format-character,
  #       unused-import,
  #       exec-used,
  #       pointless-statement,
  #       pointless-string-statement,
  #       undefined-all-variable,
  #       misplaced-future,
  #       continue-in-finally,
  #       invalid-slots,
  #       invalid-slice-index,
  #       invalid-slots-object,
  #       star-needs-assignment-target,
  #       global-at-module-level,
  #       yield-outside-function,
  #       mixed-indentation,
  #       non-parent-init-called,
  #       bare-except,
  #       no-self-use,
  #       dangerous-default-value,
  #       arguments-differ,
  #       signature-differs,
  #       duplicate-except,
  #       abstract-class-instantiated,
  #       binary-op-exception,
  #       undefined-variable
  #]
  
  
  [tool.pylint.reports]
  # Python expression which should return a note less than 10 (10 is the highest
  # note). You have access to the variables errors warning, statement which
  # respectively contain the number of errors / warnings messages and the total
  # number of statements analyzed. This is used by the global evaluation report
  # (RP0004). Default is:
  # evaluation = 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
  # evaluation = 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
  
  # Template used to display messages. This is a python new-style format string
  # used to format the message information. See doc for all details.
  #msg-template = ""
  
  # Set the output format. Available formats are text, parseable, colorized, json
  # and msvs (visual studio). You can also give a reporter class, e.g.
  # mypackage.mymodule.MyReporterClass.
  #output-format = text
  output-format = "colorized"
  
  # Tells whether to display a full report or only the messages.
  #reports = false
  reports = true
  
  # Activate the evaluation score.
  score = true
  
  
  [tool.pylint.refactoring]
  # Maximum number of nested blocks for function / method body
  max-nested-blocks = 5
  
  # Complete name of functions that never returns. When checking for
  # inconsistent-return-statements if a never returning function is called then
  # it will be considered as an explicit return statement and no message will be
  # printed.
  never-returning-functions = ["sys.exit"]
  
  
  [tool.pylint.format]
  # Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
  expected-line-ending-format = "LF"
  
  # Regexp for a line that is allowed to be longer than the limit.
  #ignore-long-lines = "^\s*(# )?<?https?://\S+>?$"
  
  # Number of spaces of indent required inside a hanging or continued line.
  indent-after-paren = 4
  
  # String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
  # tab).
  indent-string = "    "
  
  # Maximum number of characters on a single line.
  max-line-length = 88
  
  # Maximum number of lines in a module.
  max-module-lines = 1000
  
  # List of optional constructs for which whitespace checking is disabled.
  # `dict-separator` is used to allow tabulation in dicts, etc. e.g.
  #   {1  : 1,
  #    222: 2}.
  # `trailing-comma` allows a space between comma and closing bracket: (a, ).
  # `empty-line` allows space-only lines.
  no-space-check = [
      "trailing-comma",
      "dict-separator"
  ]
  
  # Allow the body of a class to be on the same line as the declaration if body
  # contains single statement.
  single-line-class-stmt = false
  
  # Allow the body of an if to be on the same line as the test if there is no
  # else.
  single-line-if-stmt = false
  
  
  [tool.pylint.spelling]
  # Limits count of emitted suggestions for spelling mistakes.
  max-spelling-suggestions = 4
  
  # Spelling dictionary name. Available dictionaries: none. To make it working
  # install python-enchant package..
  spelling-dict = ""
  
  # List of comma separated words that should not be checked.
  spelling-ignore-words = ""
  
  # A path to a file that contains private dictionary; one word per line.
  spelling-private-dict-file = ""
  
  # Tells whether to store unknown words to indicated private dictionary in
  # --spelling-private-dict-file option instead of raising a message.
  spelling-store-unknown-words = false
  
  
  [tool.pylint.similarities]
  # Ignore comments when computing similarities.
  ignore-comments = true
  
  # Ignore docstrings when computing similarities.
  ignore-docstrings = true
  
  # Ignore imports when computing similarities.
  ignore-imports = false
  
  # Minimum lines number of a similarity.
  min-similarity-lines = 4
  
  
  [tool.pylint.variables]
  # List of additional names supposed to be defined in builtins. Remember that
  # you should avoid defining new builtins when possible.
  additional-builtins = [
      "_",
      "N_",
      "ngettext",
      "gettext_countries",
      "gettext_attributes"
  ]
  
  # Tells whether unused global variables should be treated as a violation.
  allow-global-unused-variables = true
  
  # List of strings which can identify a callback function by name. A callback
  # name must start or end with one of those strings.
  callbacks = [
      "cb_",
      "_cb"
  ]
  
  # A regular expression matching the name of dummy variables (i.e. expected to
  # not be used).
  dummy-variables-rgx = "_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_"
  
  # Argument names that match this expression will be ignored. Default to name
  # with leading underscore.
  ignored-argument-names = "_.*|^ignored_|^unused_"
  
  # Tells whether we should check for unused import in __init__ files.
  init-import = true
  
  # List of qualified module names which can have objects that can redefine
  # builtins.
  redefining-builtins-modules = [
      "six.moves",
      "past.builtins",
      "future.builtins",
      "builtins",
      "io"
  ]
  
  
  [tool.pylint.miscellaneous]
  # List of note tags to take in consideration, separated by a comma.
  notes = [
      "FIXME",
      "XXX",
      "TODO"
  ]
  
  
  [tool.pylint.logging]
  # Format style used to check logging format string. `old` means using %
  # formatting, while `new` is for `{}` formatting.
  logging-format-style = "old"
  
  # Logging modules to check that the string format arguments are in logging
  # function parameter format.
  #logging-modules = "logging"
  logging-modules = ""
  
  
  [tool.pylint.basic]
  # Naming style matching correct argument names.
  argument-naming-style = "snake_case"
  
  # Regular expression matching correct argument names. Overrides argument-
  # naming-style.
  #argument-rgx = ""
  
  # Naming style matching correct attribute names.
  attr-naming-style = "snake_case"
  
  # Regular expression matching correct attribute names. Overrides attr-naming-
  # style.
  #attr-rgx = ""
  
  # Bad variable names which should always be refused, separated by a comma.
  bad-names = [
      "foo",
      "bar",
      "baz",
      "toto",
      "tutu",
      "tata"
  ]
  
  # Naming style matching correct class attribute names.
  class-attribute-naming-style = "any"
  
  # Regular expression matching correct class attribute names. Overrides class-
  # attribute-naming-style.
  #class-attribute-rgx = ""
  
  # Naming style matching correct class names.
  class-naming-style = "PascalCase"
  
  # Regular expression matching correct class names. Overrides class-naming-
  # style.
  #class-rgx = ""
  
  # Naming style matching correct constant names.
  const-naming-style = "UPPER_CASE"
  
  # Regular expression matching correct constant names. Overrides const-naming-
  # style.
  #const-rgx = ""
  
  # Minimum line length for functions/classes that require docstrings, shorter
  # ones are exempt.
  docstring-min-length = -1
  
  # Naming style matching correct function names.
  function-naming-style = "snake_case"
  
  # Regular expression matching correct function names. Overrides function-
  # naming-style.
  #function-rgx = ""
  
  # Good variable names which should always be accepted, separated by a comma.
  good-names = [
      "i",
      "j",
      "k",
      "_"
  ]
  
  # Include a hint for the correct naming format with invalid-name.
  include-naming-hint = false
  
  # Naming style matching correct inline iteration names.
  inlinevar-naming-style = "any"
  
  # Regular expression matching correct inline iteration names. Overrides
  # inlinevar-naming-style.
  #inlinevar-rgx = ""
  
  # Naming style matching correct method names.
  method-naming-style = "snake_case"
  
  # Regular expression matching correct method names. Overrides method-naming-
  # style.
  #method-rgx = ""
  
  # Naming style matching correct module names.
  module-naming-style = "snake_case"
  
  # Regular expression matching correct module names. Overrides module-naming-
  # style.
  #module-rgx = ""
  
  # Colon-delimited sets of names that determine each other's naming style when
  # the name regexes allow several styles.
  name-group = ""
  
  # Regular expression which should only match function or class names that do
  # not require a docstring.
  no-docstring-rgx = "^_"
  
  # List of decorators that produce properties, such as abc.abstractproperty. Add
  # to this list to register other decorators that produce valid properties.
  # These decorators are taken in consideration only for invalid-name.
  property-classes = "abc.abstractproperty"
  
  # Naming style matching correct variable names.
  variable-naming-style = "snake_case"
  
  # Regular expression matching correct variable names. Overrides variable-
  # naming-style.
  #variable-rgx = ""
  
  
  [tool.pylint.typecheck]
  # List of decorators that produce context managers, such as
  # contextlib.contextmanager. Add to this list to register other decorators that
  # produce valid context managers.
  contextmanager-decorators = ["contextlib.contextmanager"]
  
  # List of members which are set dynamically and missed by pylint inference
  # system, and so shouldn't trigger E1101 when accessed. Python regular
  # expressions are accepted.
  generated-members = ""
  
  # Tells whether missing members accessed in mixin class should be ignored. A
  # mixin class is detected if its name ends with "mixin" (case insensitive).
  ignore-mixin-members = true
  
  # Tells whether to warn about missing members when the owner of the attribute
  # is inferred to be None.
  ignore-none = true
  
  # This flag controls whether pylint should warn about no-member and similar
  # checks whenever an opaque object is returned when inferring. The inference
  # can return multiple potential results while evaluating a Python object, but
  # some branches might not be evaluated, which results in partial inference. In
  # that case, it might be useful to still emit no-member and other checks for
  # the rest of the inferred objects.
  ignore-on-opaque-inference = true
  
  # List of class names for which member attributes should not be checked (useful
  # for classes with dynamically set attributes). This supports the use of
  # qualified names.
  ignored-classes = [
      "optparse.Values",
      "thread._local",
      "_thread._local"
  ]
  
  # List of module names for which member attributes should not be checked
  # (useful for modules/projects where namespaces are manipulated during runtime
  # and thus existing member attributes cannot be deduced by static analysis. It
  # supports qualified module names, as well as Unix pattern matching.
  ignored-modules = ""
  
  # Show a hint with possible names when a member name was not found. The aspect
  # of finding the hint is based on edit distance.
  missing-member-hint = true
  
  # The minimum edit distance a name should have in order to be considered a
  # similar match for a missing member name.
  missing-member-hint-distance = 1
  
  # The total number of similar names that should be taken in consideration when
  # showing a hint for a missing member.
  missing-member-max-choices = 1
  
  
  [tool.pylint.classes]
  # List of method names used to declare (i.e. assign) instance attributes.
  defining-attr-methods = [
      "__init__",
      "__new__"
  ]
  
  # List of member names, which should be excluded from the protected access
  # warning.
  #exclude-protected = [
  #    _asdict,
  #    _fields,
  #    _replace,
  #    _source,
  #    _make
  #]
  exclude-protected = ""
  
  # List of valid names for the first argument in a class method.
  valid-classmethod-first-arg = "cls"
  
  # List of valid names for the first argument in a metaclass class method.
  valid-metaclass-classmethod-first-arg = "cls"
  
  
  [tool.pylint.imports]
  # Allow wildcard imports from modules that define __all__.
  allow-wildcard-with-all = true
  
  # Analyse import fallback blocks. This can be used to support both Python 2 and
  # 3 compatible code, which means that the block might have code that exists
  # only in one or another interpreter, leading to false positives when analysed.
  analyse-fallback-blocks = false
  
  # Deprecated modules which should not be used, separated by a comma.
  deprecated-modules = [
      "optparse",
      "tkinter.tix"
  ]
  
  # Create a graph of external dependencies in the given file (report RP0402 must
  # not be disabled).
  ext-import-graph = ""
  
  # Create a graph of every (i.e. internal and external) dependencies in the
  # given file (report RP0402 must not be disabled).
  import-graph = ""
  
  # Create a graph of internal dependencies in the given file (report RP0402 must
  # not be disabled).
  int-import-graph = ""
  
  # Force import order to recognize a module as part of the standard
  # compatibility libraries.
  known-standard-library = ""
  
  # Force import order to recognize a module as part of a third party library.
  known-third-party = ""
  
  
  [tool.pylint.design]
  # Maximum number of arguments for function / method.
  max-args = 5
  
  # Maximum number of attributes for a class (see R0902).
  max-attributes = 7
  
  # Maximum number of boolean expressions in an if statement.
  max-bool-expr = 5
  
  # Maximum number of branch for function / method body.
  max-branches = 12
  
  # Maximum number of locals for function / method body.
  max-locals = 15
  
  # Maximum number of parents for a class (see R0901).
  max-parents = 7
  
  # Maximum number of public methods for a class (see R0904).
  max-public-methods = 20
  
  # Maximum number of return / yield for function / method body.
  max-returns = 6
  
  # Maximum number of statements in function / method body.
  max-statements = 50
  
  # Minimum number of public methods for a class (see R0903).
  min-public-methods = 2
  
  
  [tool.pylint.exceptions]
  # Exceptions that will emit a warning when being caught. Defaults to
  # "Exception".
  #overgeneral-exceptions = ["Exception"]
  