mirror of
https://github.com/certbot/certbot.git
synced 2026-01-26 07:41:33 +03:00
06a53cb7df
Fixes #8425 This PR upgrades mypy to the latest version available, 0.812. Given the advanced type inference capabilities provided by this newer version, this PRs also fixes various type inconsistencies that are now detected. Here are the non obvious changes done to fix types: * typing in mixins has been solved using `Protocol` classes, as recommended by mypy (https://mypy.readthedocs.io/en/latest/more_types.html#mixin-classes, https://mypy.readthedocs.io/en/stable/protocols.html) * `cast` when we are playing with `Union` types This PR also disables the strict optional checks that have been enable by default in recent versions of mypy. Once this PR is merged, I will create an issue to study how these checks can be enabled. `typing.Protocol` is available only since Python 3.8. To keep compatibility with Python 3.6, I try to import the class `Protocol` from `typing`, and fallback to assign `object` to `Protocol` if that fails. This way the code is working with all versions of Python, but the mypy check can be run only with Python 3.8+ because it needs the protocol feature. As a consequence, tox runs mypy under Python 3.8. Alternatives are: * importing `typing_extensions`, that proposes backport of newest typing features to Python 3.6, but this implies to add a dependency to Certbot just to run mypy * redesign the concerned classes to not use mixins, or use them differently, but this implies to modify the code itself even if there is nothing wrong with it and it is just a matter of instructing mypy to understand in which context the mixins can be used * ignoring type for these classes with `# type: ignore` but we loose the benefit of mypy for them * Upgrade mypy * First step for acme * Cast for the rescue * Fixing types for certbot * Fix typing for certbot-nginx * Finalize type fixes, configure no optional strict check for mypy in tox * Align requirements * Isort * Pylint * Protocol for python 3.6 * Use Python 3.9 for mypy, make code compatible with Python 3.8< * Pylint and mypy * Pragma no cover * Pythonic NotImplemented constant * More type definitions * Add comments * Simplify typing logic * Use vararg tuple * Relax constraints on mypy * Add more type * Do not silence error if target is not defined * Conditionally import Protocol for type checking only * Clean up imports * Add comments * Align python version linting with mypy and coverage * Just ignore types in an unused module * Add comments * Fix lint
174 lines
7.2 KiB
Python
174 lines
7.2 KiB
Python
""" apacheconfig implementation of the ParserNode interfaces """
|
|
from typing import Tuple
|
|
|
|
from certbot_apache._internal import assertions
|
|
from certbot_apache._internal import interfaces
|
|
from certbot_apache._internal import parsernode_util as util
|
|
|
|
|
|
class ApacheParserNode(interfaces.ParserNode):
|
|
""" apacheconfig implementation of ParserNode interface.
|
|
|
|
Expects metadata `ac_ast` to be passed in, where `ac_ast` is the AST provided
|
|
by parsing the equivalent configuration text using the apacheconfig library.
|
|
"""
|
|
|
|
def __init__(self, **kwargs):
|
|
ancestor, dirty, filepath, metadata = util.parsernode_kwargs(kwargs) # pylint: disable=unused-variable
|
|
super(ApacheParserNode, self).__init__(**kwargs)
|
|
self.ancestor = ancestor
|
|
self.filepath = filepath
|
|
self.dirty = dirty
|
|
self.metadata = metadata
|
|
self._raw = self.metadata["ac_ast"]
|
|
|
|
def save(self, msg): # pragma: no cover
|
|
pass
|
|
|
|
def find_ancestors(self, name): # pylint: disable=unused-variable
|
|
"""Find ancestor BlockNodes with a given name"""
|
|
return [ApacheBlockNode(name=assertions.PASS,
|
|
parameters=assertions.PASS,
|
|
ancestor=self,
|
|
filepath=assertions.PASS,
|
|
metadata=self.metadata)]
|
|
|
|
|
|
class ApacheCommentNode(ApacheParserNode):
|
|
""" apacheconfig implementation of CommentNode interface """
|
|
|
|
def __init__(self, **kwargs):
|
|
comment, kwargs = util.commentnode_kwargs(kwargs) # pylint: disable=unused-variable
|
|
super(ApacheCommentNode, self).__init__(**kwargs)
|
|
self.comment = comment
|
|
|
|
def __eq__(self, other): # pragma: no cover
|
|
if isinstance(other, self.__class__):
|
|
return (self.comment == other.comment and
|
|
self.dirty == other.dirty and
|
|
self.ancestor == other.ancestor and
|
|
self.metadata == other.metadata and
|
|
self.filepath == other.filepath)
|
|
return False
|
|
|
|
|
|
class ApacheDirectiveNode(ApacheParserNode):
|
|
""" apacheconfig implementation of DirectiveNode interface """
|
|
|
|
def __init__(self, **kwargs):
|
|
name, parameters, enabled, kwargs = util.directivenode_kwargs(kwargs)
|
|
super(ApacheDirectiveNode, self).__init__(**kwargs)
|
|
self.name = name
|
|
self.parameters = parameters
|
|
self.enabled = enabled
|
|
self.include = None
|
|
|
|
def __eq__(self, other): # pragma: no cover
|
|
if isinstance(other, self.__class__):
|
|
return (self.name == other.name and
|
|
self.filepath == other.filepath and
|
|
self.parameters == other.parameters and
|
|
self.enabled == other.enabled and
|
|
self.dirty == other.dirty and
|
|
self.ancestor == other.ancestor and
|
|
self.metadata == other.metadata)
|
|
return False
|
|
|
|
def set_parameters(self, _parameters): # pragma: no cover
|
|
"""Sets the parameters for DirectiveNode"""
|
|
return
|
|
|
|
|
|
class ApacheBlockNode(ApacheDirectiveNode):
|
|
""" apacheconfig implementation of BlockNode interface """
|
|
|
|
def __init__(self, **kwargs):
|
|
super(ApacheBlockNode, self).__init__(**kwargs)
|
|
self.children: Tuple[ApacheParserNode, ...] = ()
|
|
|
|
def __eq__(self, other): # pragma: no cover
|
|
if isinstance(other, self.__class__):
|
|
return (self.name == other.name and
|
|
self.filepath == other.filepath and
|
|
self.parameters == other.parameters and
|
|
self.children == other.children and
|
|
self.enabled == other.enabled and
|
|
self.dirty == other.dirty and
|
|
self.ancestor == other.ancestor and
|
|
self.metadata == other.metadata)
|
|
return False
|
|
|
|
# pylint: disable=unused-argument
|
|
def add_child_block(self, name, parameters=None, position=None): # pragma: no cover
|
|
"""Adds a new BlockNode to the sequence of children"""
|
|
new_block = ApacheBlockNode(name=assertions.PASS,
|
|
parameters=assertions.PASS,
|
|
ancestor=self,
|
|
filepath=assertions.PASS,
|
|
metadata=self.metadata)
|
|
self.children += (new_block,)
|
|
return new_block
|
|
|
|
# pylint: disable=unused-argument
|
|
def add_child_directive(self, name, parameters=None, position=None): # pragma: no cover
|
|
"""Adds a new DirectiveNode to the sequence of children"""
|
|
new_dir = ApacheDirectiveNode(name=assertions.PASS,
|
|
parameters=assertions.PASS,
|
|
ancestor=self,
|
|
filepath=assertions.PASS,
|
|
metadata=self.metadata)
|
|
self.children += (new_dir,)
|
|
return new_dir
|
|
|
|
# pylint: disable=unused-argument
|
|
def add_child_comment(self, comment="", position=None): # pragma: no cover
|
|
|
|
"""Adds a new CommentNode to the sequence of children"""
|
|
new_comment = ApacheCommentNode(comment=assertions.PASS,
|
|
ancestor=self,
|
|
filepath=assertions.PASS,
|
|
metadata=self.metadata)
|
|
self.children += (new_comment,)
|
|
return new_comment
|
|
|
|
def find_blocks(self, name, exclude=True): # pylint: disable=unused-argument
|
|
"""Recursive search of BlockNodes from the sequence of children"""
|
|
return [ApacheBlockNode(name=assertions.PASS,
|
|
parameters=assertions.PASS,
|
|
ancestor=self,
|
|
filepath=assertions.PASS,
|
|
metadata=self.metadata)]
|
|
|
|
def find_directives(self, name, exclude=True): # pylint: disable=unused-argument
|
|
"""Recursive search of DirectiveNodes from the sequence of children"""
|
|
return [ApacheDirectiveNode(name=assertions.PASS,
|
|
parameters=assertions.PASS,
|
|
ancestor=self,
|
|
filepath=assertions.PASS,
|
|
metadata=self.metadata)]
|
|
|
|
# pylint: disable=unused-argument
|
|
def find_comments(self, comment, exact=False): # pragma: no cover
|
|
"""Recursive search of DirectiveNodes from the sequence of children"""
|
|
return [ApacheCommentNode(comment=assertions.PASS,
|
|
ancestor=self,
|
|
filepath=assertions.PASS,
|
|
metadata=self.metadata)]
|
|
|
|
def delete_child(self, child): # pragma: no cover
|
|
"""Deletes a ParserNode from the sequence of children"""
|
|
return
|
|
|
|
def unsaved_files(self): # pragma: no cover
|
|
"""Returns a list of unsaved filepaths"""
|
|
return [assertions.PASS]
|
|
|
|
def parsed_paths(self): # pragma: no cover
|
|
"""Returns a list of parsed configuration file paths"""
|
|
return [assertions.PASS]
|
|
|
|
|
|
interfaces.CommentNode.register(ApacheCommentNode)
|
|
interfaces.DirectiveNode.register(ApacheDirectiveNode)
|
|
interfaces.BlockNode.register(ApacheBlockNode)
|