redis 5.3.0b5__py3-none-any.whl → 6.0.0b1__py3-none-any.whl

redis/commands/graph/commands.py

@@ -1,313 +0,0 @@
-from redis import DataError
-from redis.exceptions import ResponseError
-
-from .exceptions import VersionMismatchException
-from .execution_plan import ExecutionPlan
-from .query_result import AsyncQueryResult, QueryResult
-
-PROFILE_CMD = "GRAPH.PROFILE"
-RO_QUERY_CMD = "GRAPH.RO_QUERY"
-QUERY_CMD = "GRAPH.QUERY"
-DELETE_CMD = "GRAPH.DELETE"
-SLOWLOG_CMD = "GRAPH.SLOWLOG"
-CONFIG_CMD = "GRAPH.CONFIG"
-LIST_CMD = "GRAPH.LIST"
-EXPLAIN_CMD = "GRAPH.EXPLAIN"
-
-
-class GraphCommands:
-    """RedisGraph Commands"""
-
-    def commit(self):
-        """
-        Create entire graph.
-        """
-        if len(self.nodes) == 0 and len(self.edges) == 0:
-            return None
-
-        query = "CREATE "
-        for _, node in self.nodes.items():
-            query += str(node) + ","
-
-        query += ",".join([str(edge) for edge in self.edges])
-
-        # Discard leading comma.
-        if query[-1] == ",":
-            query = query[:-1]
-
-        return self.query(query)
-
-    def query(self, q, params=None, timeout=None, read_only=False, profile=False):
-        """
-        Executes a query against the graph.
-        For more information see `GRAPH.QUERY <https://redis.io/commands/graph.query>`_. # noqa
-
-        Args:
-
-        q : str
-            The query.
-        params : dict
-            Query parameters.
-        timeout : int
-            Maximum runtime for read queries in milliseconds.
-        read_only : bool
-            Executes a readonly query if set to True.
-        profile : bool
-            Return details on results produced by and time
-            spent in each operation.
-        """
-
-        # maintain original 'q'
-        query = q
-
-        # handle query parameters
-        query = self._build_params_header(params) + query
-
-        # construct query command
-        # ask for compact result-set format
-        # specify known graph version
-        if profile:
-            cmd = PROFILE_CMD
-        else:
-            cmd = RO_QUERY_CMD if read_only else QUERY_CMD
-        command = [cmd, self.name, query, "--compact"]
-
-        # include timeout is specified
-        if isinstance(timeout, int):
-            command.extend(["timeout", timeout])
-        elif timeout is not None:
-            raise Exception("Timeout argument must be a positive integer")
-
-        # issue query
-        try:
-            response = self.execute_command(*command)
-            return QueryResult(self, response, profile)
-        except ResponseError as e:
-            if "unknown command" in str(e) and read_only:
-                # `GRAPH.RO_QUERY` is unavailable in older versions.
-                return self.query(q, params, timeout, read_only=False)
-            raise e
-        except VersionMismatchException as e:
-            # client view over the graph schema is out of sync
-            # set client version and refresh local schema
-            self.version = e.version
-            self._refresh_schema()
-            # re-issue query
-            return self.query(q, params, timeout, read_only)
-
-    def merge(self, pattern):
-        """
-        Merge pattern.
-        """
-        query = "MERGE "
-        query += str(pattern)
-
-        return self.query(query)
-
-    def delete(self):
-        """
-        Deletes graph.
-        For more information see `DELETE <https://redis.io/commands/graph.delete>`_. # noqa
-        """
-        self._clear_schema()
-        return self.execute_command(DELETE_CMD, self.name)
-
-    # declared here, to override the built in redis.db.flush()
-    def flush(self):
-        """
-        Commit the graph and reset the edges and the nodes to zero length.
-        """
-        self.commit()
-        self.nodes = {}
-        self.edges = []
-
-    def bulk(self, **kwargs):
-        """Internal only. Not supported."""
-        raise NotImplementedError(
-            "GRAPH.BULK is internal only. "
-            "Use https://github.com/redisgraph/redisgraph-bulk-loader."
-        )
-
-    def profile(self, query):
-        """
-        Execute a query and produce an execution plan augmented with metrics
-        for each operation's execution. Return a string representation of a
-        query execution plan, with details on results produced by and time
-        spent in each operation.
-        For more information see `GRAPH.PROFILE <https://redis.io/commands/graph.profile>`_. # noqa
-        """
-        return self.query(query, profile=True)
-
-    def slowlog(self):
-        """
-        Get a list containing up to 10 of the slowest queries issued
-        against the given graph ID.
-        For more information see `GRAPH.SLOWLOG <https://redis.io/commands/graph.slowlog>`_. # noqa
-
-        Each item in the list has the following structure:
-        1. A unix timestamp at which the log entry was processed.
-        2. The issued command.
-        3. The issued query.
-        4. The amount of time needed for its execution, in milliseconds.
-        """
-        return self.execute_command(SLOWLOG_CMD, self.name)
-
-    def config(self, name, value=None, set=False):
-        """
-        Retrieve or update a RedisGraph configuration.
-        For more information see `<https://redis.io/commands/graph.config-get/>`__.
-
-        Args:
-
-        name : str
-            The name of the configuration
-        value :
-            The value we want to set (can be used only when `set` is on)
-        set : bool
-            Turn on to set a configuration. Default behavior is get.
-        """
-        params = ["SET" if set else "GET", name]
-        if value is not None:
-            if set:
-                params.append(value)
-            else:
-                raise DataError(
-                    "``value`` can be provided only when ``set`` is True"
-                )  # noqa
-        return self.execute_command(CONFIG_CMD, *params)
-
-    def list_keys(self):
-        """
-        Lists all graph keys in the keyspace.
-        For more information see `GRAPH.LIST <https://redis.io/commands/graph.list>`_. # noqa
-        """
-        return self.execute_command(LIST_CMD)
-
-    def execution_plan(self, query, params=None):
-        """
-        Get the execution plan for given query,
-        GRAPH.EXPLAIN returns an array of operations.
-
-        Args:
-            query: the query that will be executed
-            params: query parameters
-        """
-        query = self._build_params_header(params) + query
-
-        plan = self.execute_command(EXPLAIN_CMD, self.name, query)
-        if isinstance(plan[0], bytes):
-            plan = [b.decode() for b in plan]
-        return "\n".join(plan)
-
-    def explain(self, query, params=None):
-        """
-        Get the execution plan for given query,
-        GRAPH.EXPLAIN returns ExecutionPlan object.
-        For more information see `GRAPH.EXPLAIN <https://redis.io/commands/graph.explain>`_. # noqa
-
-        Args:
-            query: the query that will be executed
-            params: query parameters
-        """
-        query = self._build_params_header(params) + query
-
-        plan = self.execute_command(EXPLAIN_CMD, self.name, query)
-        return ExecutionPlan(plan)
-
-
-class AsyncGraphCommands(GraphCommands):
-    async def query(self, q, params=None, timeout=None, read_only=False, profile=False):
-        """
-        Executes a query against the graph.
-        For more information see `GRAPH.QUERY <https://oss.redis.com/redisgraph/master/commands/#graphquery>`_. # noqa
-
-        Args:
-
-        q : str
-            The query.
-        params : dict
-            Query parameters.
-        timeout : int
-            Maximum runtime for read queries in milliseconds.
-        read_only : bool
-            Executes a readonly query if set to True.
-        profile : bool
-            Return details on results produced by and time
-            spent in each operation.
-        """
-
-        # maintain original 'q'
-        query = q
-
-        # handle query parameters
-        query = self._build_params_header(params) + query
-
-        # construct query command
-        # ask for compact result-set format
-        # specify known graph version
-        if profile:
-            cmd = PROFILE_CMD
-        else:
-            cmd = RO_QUERY_CMD if read_only else QUERY_CMD
-        command = [cmd, self.name, query, "--compact"]
-
-        # include timeout is specified
-        if isinstance(timeout, int):
-            command.extend(["timeout", timeout])
-        elif timeout is not None:
-            raise Exception("Timeout argument must be a positive integer")
-
-        # issue query
-        try:
-            response = await self.execute_command(*command)
-            return await AsyncQueryResult().initialize(self, response, profile)
-        except ResponseError as e:
-            if "unknown command" in str(e) and read_only:
-                # `GRAPH.RO_QUERY` is unavailable in older versions.
-                return await self.query(q, params, timeout, read_only=False)
-            raise e
-        except VersionMismatchException as e:
-            # client view over the graph schema is out of sync
-            # set client version and refresh local schema
-            self.version = e.version
-            self._refresh_schema()
-            # re-issue query
-            return await self.query(q, params, timeout, read_only)
-
-    async def execution_plan(self, query, params=None):
-        """
-        Get the execution plan for given query,
-        GRAPH.EXPLAIN returns an array of operations.
-
-        Args:
-            query: the query that will be executed
-            params: query parameters
-        """
-        query = self._build_params_header(params) + query
-
-        plan = await self.execute_command(EXPLAIN_CMD, self.name, query)
-        if isinstance(plan[0], bytes):
-            plan = [b.decode() for b in plan]
-        return "\n".join(plan)
-
-    async def explain(self, query, params=None):
-        """
-        Get the execution plan for given query,
-        GRAPH.EXPLAIN returns ExecutionPlan object.
-
-        Args:
-            query: the query that will be executed
-            params: query parameters
-        """
-        query = self._build_params_header(params) + query
-
-        plan = await self.execute_command(EXPLAIN_CMD, self.name, query)
-        return ExecutionPlan(plan)
-
-    async def flush(self):
-        """
-        Commit the graph and reset the edges and the nodes to zero length.
-        """
-        await self.commit()
-        self.nodes = {}
-        self.edges = []

redis/commands/graph/edge.py

@@ -1,91 +0,0 @@
-from ..helpers import quote_string
-from .node import Node
-
-
-class Edge:
-    """
-    An edge connecting two nodes.
-    """
-
-    def __init__(self, src_node, relation, dest_node, edge_id=None, properties=None):
-        """
-        Create a new edge.
-        """
-        if src_node is None or dest_node is None:
-            # NOTE(bors-42): It makes sense to change AssertionError to
-            #                ValueError here
-            raise AssertionError("Both src_node & dest_node must be provided")
-
-        self.id = edge_id
-        self.relation = relation or ""
-        self.properties = properties or {}
-        self.src_node = src_node
-        self.dest_node = dest_node
-
-    def to_string(self):
-        res = ""
-        if self.properties:
-            props = ",".join(
-                key + ":" + str(quote_string(val))
-                for key, val in sorted(self.properties.items())
-            )
-            res += "{" + props + "}"
-
-        return res
-
-    def __str__(self):
-        # Source node.
-        if isinstance(self.src_node, Node):
-            res = str(self.src_node)
-        else:
-            res = "()"
-
-        # Edge
-        res += "-["
-        if self.relation:
-            res += ":" + self.relation
-        if self.properties:
-            props = ",".join(
-                key + ":" + str(quote_string(val))
-                for key, val in sorted(self.properties.items())
-            )
-            res += "{" + props + "}"
-        res += "]->"
-
-        # Dest node.
-        if isinstance(self.dest_node, Node):
-            res += str(self.dest_node)
-        else:
-            res += "()"
-
-        return res
-
-    def __eq__(self, rhs):
-        # Type checking
-        if not isinstance(rhs, Edge):
-            return False
-
-        # Quick positive check, if both IDs are set.
-        if self.id is not None and rhs.id is not None and self.id == rhs.id:
-            return True
-
-        # Source and destination nodes should match.
-        if self.src_node != rhs.src_node:
-            return False
-
-        if self.dest_node != rhs.dest_node:
-            return False
-
-        # Relation should match.
-        if self.relation != rhs.relation:
-            return False
-
-        # Quick check for number of properties.
-        if len(self.properties) != len(rhs.properties):
-            return False
-
-        # Compare properties.
-        if self.properties != rhs.properties:
-            return False
-
-        return True

redis/commands/graph/exceptions.py

@@ -1,3 +0,0 @@
-class VersionMismatchException(Exception):
-    def __init__(self, version):
-        self.version = version

redis/commands/graph/execution_plan.py

@@ -1,211 +0,0 @@
-import re
-
-
-class ProfileStats:
-    """
-    ProfileStats, runtime execution statistics of operation.
-    """
-
-    def __init__(self, records_produced, execution_time):
-        self.records_produced = records_produced
-        self.execution_time = execution_time
-
-
-class Operation:
-    """
-    Operation, single operation within execution plan.
-    """
-
-    def __init__(self, name, args=None, profile_stats=None):
-        """
-        Create a new operation.
-
-        Args:
-            name: string that represents the name of the operation
-            args: operation arguments
-            profile_stats: profile statistics
-        """
-        self.name = name
-        self.args = args
-        self.profile_stats = profile_stats
-        self.children = []
-
-    def append_child(self, child):
-        if not isinstance(child, Operation) or self is child:
-            raise Exception("child must be Operation")
-
-        self.children.append(child)
-        return self
-
-    def child_count(self):
-        return len(self.children)
-
-    def __eq__(self, o: object) -> bool:
-        if not isinstance(o, Operation):
-            return False
-
-        return self.name == o.name and self.args == o.args
-
-    def __str__(self) -> str:
-        args_str = "" if self.args is None else " | " + self.args
-        return f"{self.name}{args_str}"
-
-
-class ExecutionPlan:
-    """
-    ExecutionPlan, collection of operations.
-    """
-
-    def __init__(self, plan):
-        """
-        Create a new execution plan.
-
-        Args:
-            plan: array of strings that represents the collection operations
-                  the output from GRAPH.EXPLAIN
-        """
-        if not isinstance(plan, list):
-            raise Exception("plan must be an array")
-
-        if isinstance(plan[0], bytes):
-            plan = [b.decode() for b in plan]
-
-        self.plan = plan
-        self.structured_plan = self._operation_tree()
-
-    def _compare_operations(self, root_a, root_b):
-        """
-        Compare execution plan operation tree
-
-        Return: True if operation trees are equal, False otherwise
-        """
-
-        # compare current root
-        if root_a != root_b:
-            return False
-
-        # make sure root have the same number of children
-        if root_a.child_count() != root_b.child_count():
-            return False
-
-        # recursively compare children
-        for i in range(root_a.child_count()):
-            if not self._compare_operations(root_a.children[i], root_b.children[i]):
-                return False
-
-        return True
-
-    def __str__(self) -> str:
-        def aggraget_str(str_children):
-            return "\n".join(
-                [
-                    "    " + line
-                    for str_child in str_children
-                    for line in str_child.splitlines()
-                ]
-            )
-
-        def combine_str(x, y):
-            return f"{x}\n{y}"
-
-        return self._operation_traverse(
-            self.structured_plan, str, aggraget_str, combine_str
-        )
-
-    def __eq__(self, o: object) -> bool:
-        """Compares two execution plans
-
-        Return: True if the two plans are equal False otherwise
-        """
-        # make sure 'o' is an execution-plan
-        if not isinstance(o, ExecutionPlan):
-            return False
-
-        # get root for both plans
-        root_a = self.structured_plan
-        root_b = o.structured_plan
-
-        # compare execution trees
-        return self._compare_operations(root_a, root_b)
-
-    def _operation_traverse(self, op, op_f, aggregate_f, combine_f):
-        """
-        Traverse operation tree recursively applying functions
-
-        Args:
-            op: operation to traverse
-            op_f: function applied for each operation
-            aggregate_f: aggregation function applied for all children of a single operation
-            combine_f: combine function applied for the operation result and the children result
-        """  # noqa
-        # apply op_f for each operation
-        op_res = op_f(op)
-        if len(op.children) == 0:
-            return op_res  # no children return
-        else:
-            # apply _operation_traverse recursively
-            children = [
-                self._operation_traverse(child, op_f, aggregate_f, combine_f)
-                for child in op.children
-            ]
-            # combine the operation result with the children aggregated result
-            return combine_f(op_res, aggregate_f(children))
-
-    def _operation_tree(self):
-        """Build the operation tree from the string representation"""
-
-        # initial state
-        i = 0
-        level = 0
-        stack = []
-        current = None
-
-        def _create_operation(args):
-            profile_stats = None
-            name = args[0].strip()
-            args.pop(0)
-            if len(args) > 0 and "Records produced" in args[-1]:
-                records_produced = int(
-                    re.search("Records produced: (\\d+)", args[-1]).group(1)
-                )
-                execution_time = float(
-                    re.search("Execution time: (\\d+.\\d+) ms", args[-1]).group(1)
-                )
-                profile_stats = ProfileStats(records_produced, execution_time)
-                args.pop(-1)
-            return Operation(
-                name, None if len(args) == 0 else args[0].strip(), profile_stats
-            )
-
-        # iterate plan operations
-        while i < len(self.plan):
-            current_op = self.plan[i]
-            op_level = current_op.count("    ")
-            if op_level == level:
-                # if the operation level equal to the current level
-                # set the current operation and move next
-                child = _create_operation(current_op.split("|"))
-                if current:
-                    current = stack.pop()
-                    current.append_child(child)
-                current = child
-                i += 1
-            elif op_level == level + 1:
-                # if the operation is child of the current operation
-                # add it as child and set as current operation
-                child = _create_operation(current_op.split("|"))
-                current.append_child(child)
-                stack.append(current)
-                current = child
-                level += 1
-                i += 1
-            elif op_level < level:
-                # if the operation is not child of current operation
-                # go back to it's parent operation
-                levels_back = level - op_level + 1
-                for _ in range(levels_back):
-                    current = stack.pop()
-                level -= levels_back
-            else:
-                raise Exception("corrupted plan")
-        return stack[0]

redis/commands/graph/node.py

@@ -1,88 +0,0 @@
-from ..helpers import quote_string
-
-
-class Node:
-    """
-    A node within the graph.
-    """
-
-    def __init__(self, node_id=None, alias=None, label=None, properties=None):
-        """
-        Create a new node.
-        """
-        self.id = node_id
-        self.alias = alias
-        if isinstance(label, list):
-            label = [inner_label for inner_label in label if inner_label != ""]
-
-        if (
-            label is None
-            or label == ""
-            or (isinstance(label, list) and len(label) == 0)
-        ):
-            self.label = None
-            self.labels = None
-        elif isinstance(label, str):
-            self.label = label
-            self.labels = [label]
-        elif isinstance(label, list) and all(
-            [isinstance(inner_label, str) for inner_label in label]
-        ):
-            self.label = label[0]
-            self.labels = label
-        else:
-            raise AssertionError(
-                "label should be either None, string or a list of strings"
-            )
-
-        self.properties = properties or {}
-
-    def to_string(self):
-        res = ""
-        if self.properties:
-            props = ",".join(
-                key + ":" + str(quote_string(val))
-                for key, val in sorted(self.properties.items())
-            )
-            res += "{" + props + "}"
-
-        return res
-
-    def __str__(self):
-        res = "("
-        if self.alias:
-            res += self.alias
-        if self.labels:
-            res += ":" + ":".join(self.labels)
-        if self.properties:
-            props = ",".join(
-                key + ":" + str(quote_string(val))
-                for key, val in sorted(self.properties.items())
-            )
-            res += "{" + props + "}"
-        res += ")"
-
-        return res
-
-    def __eq__(self, rhs):
-        # Type checking
-        if not isinstance(rhs, Node):
-            return False
-
-        # Quick positive check, if both IDs are set.
-        if self.id is not None and rhs.id is not None and self.id != rhs.id:
-            return False
-
-        # Label should match.
-        if self.label != rhs.label:
-            return False
-
-        # Quick check for number of properties.
-        if len(self.properties) != len(rhs.properties):
-            return False
-
-        # Compare properties.
-        if self.properties != rhs.properties:
-            return False
-
-        return True