Use f-strings everywhere where it makes sense

Author: boris-42

redisgraph/edge.py

@@ -19,46 +19,37 @@ def __init__(self, src_node, relation, dest_node, edge_id=None, properties=None)
         self.dest_node = dest_node
 
     def toString(self):
-        res = ""
+        res = ''
         if self.properties:
-            props = ','.join(key+':'+str(quote_string(val)) for key, val in sorted(self.properties.items()))
-            res += '{' + props + '}'
+            props = ','.join(
+                f'{key}:{quote_string(val)}'
+                for key, val in sorted(self.properties.items()))
+            res = f'{{{props}}}'
 
         return res
 
     def __str__(self):
         # Source node.
-        if isinstance(self.src_node, Node):
-            res = str(self.src_node)
-        else:
-            res = '()'
+        res = str(self.src_node) if isinstance(self.src_node, Node) else '()'
 
         # 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 += ']->'
+        edge_relation = f':{self.relation}' if self.relation else ''
+        res += f'-[{edge_relation} {self.toString()}]->'
 
         # Dest node.
-        if isinstance(self.dest_node, Node):
-            res += str(self.dest_node)
-        else:
-            res += '()'
+        res += f"{self.dest_node if isinstance(self.dest_node, Node) else ''}"
 
         return res
 
     def __eq__(self, rhs):
         # 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:
+        if self.id 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
 

redisgraph/graph.py

@@ -104,19 +104,11 @@ def commit(self):
         """
         Create entire graph.
         """
-        if len(self.nodes) == 0 and len(self.edges) == 0:
+        if not (self.nodes or self.edges):
             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]
-
+        query = f'CREATE '
+        query += ','.join(str(v) for v in [*self.nodes.values(), *self.edges])
         return self.query(query)
 
     def flush(self):
@@ -138,7 +130,7 @@ def build_params_header(self, params):
             # Value is None, replace with "null" string.
             elif value is None:
                 value = "null"
-            params_header += str(key) + "=" + str(value) + " "
+            params_header += f"{key} = {value} "
         return params_header
 
     def query(self, q, params=None, timeout=None, read_only=False):
@@ -150,7 +142,7 @@ def query(self, q, params=None, timeout=None, read_only=False):
         query = q
 
         # handle query parameters
-        if params is not None:
+        if params:
             query = self.build_params_header(params) + query
 
         # construct query command
@@ -172,7 +164,7 @@ def query(self, q, params=None, timeout=None, read_only=False):
         except redis.exceptions.ResponseError as e:
             if "wrong number of arguments" in str(e):
                 print ("Note: RedisGraph Python requires server version 2.2.8 or above")
-            raise e
+            raise
         except VersionMismatchException as e:
             # client view over the graph schema is out of sync
             # set client version and refresh local schema
@@ -189,10 +181,10 @@ def execution_plan(self, query, params=None):
         Get the execution plan for given query,
         GRAPH.EXPLAIN returns an array of operations.
         """
-        
+
         if params is not None:
             query = self.build_params_header(params) + query
-        
+
         plan = self.redis_con.execute_command("GRAPH.EXPLAIN", self.name, query, query)
         return self._execution_plan_to_string(plan)
 
@@ -202,27 +194,23 @@ def delete(self):
         """
         self._clear_schema()
         return self.redis_con.execute_command("GRAPH.DELETE", self.name)
-    
+
     def merge(self, pattern):
         """
         Merge pattern.
         """
-
-        query = 'MERGE '
-        query += str(pattern)
-
-        return self.query(query)
+        return self.query(f'MERGE {pattern}'
 
     # Procedures.
     def call_procedure(self, procedure, read_only=False, *args, **kwagrs):
         args = [quote_string(arg) for arg in args]
-        q = 'CALL %s(%s)' % (procedure, ','.join(args))
+        query = f'CALL {procedure}({",".join(args)})'
 
-        y = kwagrs.get('y', None)
+        y = kwagrs.get('y')
         if y:
-            q += ' YIELD %s' % ','.join(y)
+            query += f' YIELD {",".join(y)}'
 
-        return self.query(q, read_only=read_only)
+        return self.query(query, read_only=read_only)
 
     def labels(self):
         return self.call_procedure("db.labels", read_only=True).result_set

redisgraph/node.py

@@ -14,29 +14,22 @@ def __init__(self, node_id=None, alias=None, label=None, properties={}):
         self.properties = properties
 
     def toString(self):
-        res = ""
+        res = ''
         if self.properties:
-            props = ','.join(key+':'+str(quote_string(val)) for key, val in sorted(self.properties.items()))
-            res += '{' + props + '}'
+            props = ','.join(
+                f'{key}:{quote_string(val)}'
+                for key, val in sorted(self.properties.items()))
+            res = f'{{{props}}}'
 
         return res
 
     def __str__(self):
-        res = '('
-        if self.alias:
-            res += self.alias
-        if self.label:
-            res += ':' + self.label
-        if self.properties:
-            props = ','.join(key+':'+str(quote_string(val)) for key, val in sorted(self.properties.items()))
-            res += '{' + props + '}'
-        res += ')'
-
-        return res
+        label = f':{self.label}' if label else ''
+        return f'({self.alias or ""}{label} {self.toString()})'
 
     def __eq__(self, rhs):
         # 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:
+        if self.id and self.id == rhs.id:
             return True
 
         # Label should match.

redisgraph/path.py

@@ -33,7 +33,7 @@ def last_node(self):
 
     def edge_count(self):
         return len(self._edges)
-    
+
     def nodes_count(self):
         return len(self._nodes)
 
@@ -53,15 +53,15 @@ def __eq__(self, other):
         return self.nodes() == other.nodes() and self.edges() == other.edges()
 
     def __str__(self):
-        res = "<"
+        res = ""
         edge_count = self.edge_count()
-        for i in range(0, edge_count):
+        for i in range(edge_count):
             node_id = self.get_node(i).id
-            res += "(" + str(node_id) + ")"
+            res += f"({node_id})"
             edge = self.get_relationship(i)
-            res += "-[" + str(int(edge.id)) + "]->" if edge.src_node == node_id else "<-[" + str(int(edge.id)) + "]-"
-        node_id = self.get_node(edge_count).id
-        res += "(" + str(node_id) + ")"
-        res += ">"
-        return res
-    
+            if edge.src_node == node_id:
+                res = f"{res}-[{edge.id}]->"
+            else:
+                res = f"{res}<-[{edge.id}]-"
+
+        return f'<{res}({self.get_node(edge_count).id})>'

redisgraph/util.py

@@ -3,12 +3,14 @@
 
 __all__ = ['random_string', 'quote_string']
 
+
 def random_string(length=10):
     """
     Returns a random N chracter long string.
     """
     return ''.join(random.choice(string.ascii_lowercase) for x in range(length))
 
+
 def quote_string(v):
     """
     RedisGraph strings must be quoted,