Improve code quality using ruff

Author: GjjvdBurg

clevercsv/__init__.py

@@ -24,3 +24,29 @@
 from .wrappers import stream_table
 from .wrappers import write_table
 from .write import writer
+
+__all__ = [
+    "QUOTE_ALL",
+    "QUOTE_MINIMAL",
+    "QUOTE_NONE",
+    "QUOTE_NONNUMERIC",
+    "__version__",
+    "field_size_limit",
+    "Detector",
+    "Sniffer",
+    "excel",
+    "excel_tab",
+    "unix_dialect",
+    "DictReader",
+    "DictWriter",
+    "Error",
+    "reader",
+    "detect_dialect",
+    "read_dataframe",
+    "read_dicts",
+    "read_table",
+    "stream_dicts",
+    "stream_table",
+    "write_table",
+    "writer",
+]

clevercsv/break_ties.py

@@ -8,6 +8,7 @@
 """
 
 from .cparser_util import parse_string
+from .dialect import SimpleDialect
 from .utils import pairwise
 
 
@@ -76,19 +77,28 @@ def reduce_pairwise(data, dialects):
     visited = set()
     for A, B in equal_dialects:
         ans = break_ties_two(data, A, B)
-        if not ans is None:
+        if ans is not None:
             new_dialects.add(ans)
         visited.add(A)
         visited.add(B)
 
     # and add the dialects that we didn't visit
     for d in dialects:
-        if not d in visited:
+        if d not in visited:
             new_dialects.add(d)
 
     return list(new_dialects)
 
 
+def _dialects_only_differ_in_field(
+    A: SimpleDialect, B: SimpleDialect, field: str
+) -> bool:
+    keys = ["delimiter", "quotechar", "escapechar"]
+    return all(
+        getattr(A, key) == getattr(B, key) for key in keys if key != field
+    )
+
+
 def break_ties_two(data, A, B):
     """Break ties between two dialects.
 
@@ -127,11 +137,7 @@ def break_ties_two(data, A, B):
         The chosen dialect if the tie can be broken, None otherwise.
 
     """
-    keys = {"delimiter", "quotechar", "escapechar"}
-    diff_only_in_key = lambda key: all(
-        getattr(A, x) == getattr(B, x) for x in keys if x != key
-    )
-    if diff_only_in_key("quotechar"):
+    if _dialects_only_differ_in_field(A, B, "quotechar"):
         if A.quotechar == "" or B.quotechar == "":
             d_no = A if A.quotechar == "" else B
             d_yes = B if d_no == A else A
@@ -145,7 +151,7 @@ def break_ties_two(data, A, B):
             else:
                 # quotechar has an effect
                 return d_yes
-    elif diff_only_in_key("delimiter"):
+    elif _dialects_only_differ_in_field(A, B, "delimiter"):
         if sorted([A.delimiter, B.delimiter]) == sorted([",", " "]):
             # Artifact due to type detection (comma as radix point)
             if A.delimiter == ",":
@@ -158,7 +164,7 @@ def break_ties_two(data, A, B):
                 return B
             else:
                 return A
-    elif diff_only_in_key("escapechar"):
+    elif _dialects_only_differ_in_field(A, B, "escapechar"):
         Dnone, Descape = (A, B) if A.escapechar == "" else (B, A)
 
         X = list(parse_string(data, Dnone))
@@ -226,7 +232,7 @@ def break_ties_two(data, A, B):
             for rX, rY in zip(X, Y):
                 for x, y in zip(rX, rY):
                     if x != y:
-                        if not eq in x:
+                        if eq not in x:
                             return None
 
             # Now we know that the only cells that have the

clevercsv/consistency.py

@@ -58,41 +58,41 @@ def detect_consistency_dialects(data, dialects, skip=True, verbose=False):
 
     This function takes a list of dialects to consider.
     """
-    log = lambda *a, **kw: print(*a, **kw) if verbose else None
-    log("Considering %i dialects." % len(dialects))
-
     old_limit = field_size_limit(len(data) + 1)
-    scores = consistency_scores(data, dialects, skip=skip, logger=log)
+    scores = consistency_scores(data, dialects, skip=skip, verbose=verbose)
     H = get_best_set(scores)
     result = break_ties(data, H)
     field_size_limit(old_limit)
 
     return result
 
 
-def consistency_scores(data, dialects, skip=True, logger=print):
+def consistency_scores(data, dialects, skip=True, verbose: bool = False):
     scores = {}
 
     Qmax = -float("inf")
     for dialect in sorted(dialects):
         P = pattern_score(data, dialect)
         if P < Qmax and skip:
             scores[dialect] = {"pattern": P, "type": None, "Q": None}
-            logger("%15r:\tP = %15.6f\tskip." % (dialect, P))
+            if verbose:
+                print("%15r:\tP = %15.6f\tskip." % (dialect, P))
             continue
         T = type_score(data, dialect)
         Q = P * T
         Qmax = max(Q, Qmax)
         scores[dialect] = {"pattern": P, "type": T, "Q": Q}
-        logger(
-            "%15r:\tP = %15.6f\tT = %15.6f\tQ = %15.6f" % (dialect, P, T, Q)
-        )
+        if verbose:
+            print(
+                "%15r:\tP = %15.6f\tT = %15.6f\tQ = %15.6f"
+                % (dialect, P, T, Q)
+            )
     return scores
 
 
 def get_best_set(scores):
     Qscores = [score["Q"] for score in scores.values()]
-    Qscores = filter(lambda q: not q is None, Qscores)
+    Qscores = filter(lambda q: q is not None, Qscores)
     Qmax = max(Qscores)
     return set([d for d, score in scores.items() if score["Q"] == Qmax])
 

clevercsv/console/commands/__init__.py

@@ -5,3 +5,11 @@
 from .explore import ExploreCommand
 from .standardize import StandardizeCommand
 from .view import ViewCommand
+
+__all__ = [
+    "CodeCommand",
+    "DetectCommand",
+    "ExploreCommand",
+    "StandardizeCommand",
+    "ViewCommand",
+]

clevercsv/console/commands/_utils.py

@@ -28,7 +28,8 @@ def generate_code(filename, dialect, encoding, use_pandas=False):
     if use_pandas:
         return base + [
             "",
-            f'df = clevercsv.read_dataframe("{filename}", delimiter={d}, quotechar={q}, escapechar={e})',
+            f'df = clevercsv.read_dataframe("{filename}", delimiter={d}, '
+            f"quotechar={q}, escapechar={e})",
             "",
         ]
 

clevercsv/cparser_util.py

@@ -91,10 +91,10 @@ def parse_data(
     if dialect is None:
         dialect = SimpleDialect("", "", "")
 
-    delimiter_ = delimiter if not delimiter is None else dialect.delimiter
-    quotechar_ = quotechar if not quotechar is None else dialect.quotechar
-    escapechar_ = escapechar if not escapechar is None else dialect.escapechar
-    strict_ = strict if not strict is None else dialect.strict
+    delimiter_ = delimiter if delimiter is not None else dialect.delimiter
+    quotechar_ = quotechar if quotechar is not None else dialect.quotechar
+    escapechar_ = escapechar if escapechar is not None else dialect.escapechar
+    strict_ = strict if strict is not None else dialect.strict
 
     parser = Parser(
         data,

clevercsv/detect.py

@@ -36,23 +36,27 @@ def sniff(self, sample, delimiters=None, verbose=False):
         return self.detect(sample, delimiters=delimiters, verbose=verbose)
 
     def detect(
-        self, sample, delimiters=None, verbose=False, method="auto", skip=True
+        self,
+        sample,
+        delimiters=None,
+        verbose=False,
+        method="auto",
+        skip=True,
     ):
         # method in ['auto', 'normal', 'consistency']
-        # wrapper for the print function
-        log = lambda *a, **kw: print(*a, **kw) if verbose else None
-
         if method == "normal" or method == "auto":
-            log("Running normal form detection ...", flush=True)
+            if verbose:
+                print("Running normal form detection ...", flush=True)
             dialect = detect_dialect_normal(
                 sample, delimiters=delimiters, verbose=verbose
             )
-            if not dialect is None:
+            if dialect is not None:
                 self.method_ = "normal"
                 return dialect
 
         self.method_ = "consistency"
-        log("Running data consistency measure ...", flush=True)
+        if verbose:
+            print("Running data consistency measure ...", flush=True)
         return detect_dialect_consistency(
             sample, delimiters=delimiters, skip=skip, verbose=verbose
         )
@@ -117,7 +121,7 @@ def has_header(self, sample):
         # on whether it's a header
         hasHeader = 0
         for col, colType in columnTypes.items():
-            if type(colType) == type(0):  # it's a length
+            if isinstance(colType, int):  # it's a length
                 if len(header[col]) != colType:
                     hasHeader += 1
                 else: