rqltypes.py

# copyright 2004-2021 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
#
# This file is part of rql.
#
# rql is free software: you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 2.1 of the License, or (at your option)
# any later version.
#
# rql is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with rql. If not, see <http://www.gnu.org/licenses/>.
"""Types declarations for RQL types annotations"""

import sys

from typing import (
    TYPE_CHECKING,
    Dict,
    Iterator,
    List,
    Tuple,
    Union as Union_,
    Optional,
    Callable,
    Set,
    Type,
    TypeVar,
    Any,
)

if sys.version_info[0] == 3 and sys.version_info[1] >= 8:
    from typing import Protocol  # Python 3.8 or above
else:
    from typing_extensions import Protocol


__docformat__ = "restructuredtext en"

Solution = Dict[str, str]
SolutionsList = List[Solution]

# this is a node of the syntax tree
# used, for now, for Select.vargraph
Graph = Union_[Dict[Tuple[str, str], str], Dict[str, List[str]], Dict]


class TranslationFunction(Protocol):
    def __call__(self, msg: str, context: Optional[str] = None) -> str:
        ...


class ResolvesEType(Protocol):
    def __init__(self, schema, uid_func_mapping=None) -> None:
        ...

    def set_schema(self, schema) -> None:
        ...

    def solve(self, node, constraints) -> None:
        ...

    def visit(self, node, uid_func_mapping=None, kwargs=None, debug=False) -> Set[Any]:
        ...

    def visit_union(self, node) -> None:
        ...

    def visit_insert(self, node) -> None:
        ...

    def visit_delete(self, node) -> None:
        ...

    def visit_set(self, node) -> None:
        ...

    def visit_select(self, node) -> None:
        ...

    def visit_relation(self, relation, constraints) -> None:
        ...

    def visit_type_restriction(self, relation, constraints) -> None:
        ...

    def visit_and(self, et, constraints) -> None:
        ...

    def visit_or(self, ou, constraints) -> None:
        ...

    def visit_not(self, et, constraints) -> None:
        ...

    def visit_comparison(self, comparison, constraints) -> None:
        ...

    def visit_mathexpression(self, mathexpression, constraints) -> None:
        ...

    def visit_function(self, function, constraints) -> None:
        ...

    def visit_variableref(self, variableref, constraints) -> None:
        ...

    def visit_constant(self, constant, constraints) -> None:
        ...

    def visit_keyword(self, keyword, constraints) -> None:
        ...

    def visit_exists(self, exists, constraints) -> None:
        ...


if TYPE_CHECKING:
    import rql

    BaseNode = rql.base.BaseNode
else:
    BaseNode = "rql.base.BaseNode"

UIDFuncMapping = Optional[Dict[str, Callable[[int], str]]]

# AnyStatement is the Union of all Statement child classes
AnyStatementNode = Union_[
    "rql.stmts.Set",
    "rql.stmts.Delete",
    "rql.stmts.Union",
    "rql.stmts.Insert",
]

P = TypeVar("P", bound="rql.base.BaseNode")


class HasRelationAttribute(Protocol):
    def relation(
        self,
    ) -> "P":
        ...


class HasHand(Protocol):
    parent: HasRelationAttribute

    def get_type(
        self,
        solution: Optional[Dict[str, str]] = None,
        kwargs: Optional[Dict] = None,
    ) -> str:
        ...


Y = TypeVar("Y")


class HasOperatorAttribute(Protocol):
    operator: str

    def iget_nodes(self, klass: Type["Y"]) -> Iterator["Y"]:
        ...

    def get_type(
        self,
        solution: Optional[Dict[str, str]] = None,
        kwargs: Optional[Dict] = None,
    ) -> str:
        ...


# AnyScopeNode is the Union of all ScopeNode child classes
AnyScopeNode = Union_[
    "rql.stmts.Set",
    "rql.stmts.Delete",
    "rql.stmts.Insert",
    "rql.stmts.Select",
    "rql.stmts.Select",
]