solentware-base 5.2__tar.gz → 5.2.1__tar.gz

{solentware-base-5.2/solentware_base.egg-info → solentware_base-5.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: solentware-base
-Version: 5.2
+Version: 5.2.1
 Summary: Bitmapped record number databases.
 Author-email: Roger Marsh <roger.marsh@solentware.co.uk>
 License: Licence for solentware_base package

{solentware-base-5.2 → solentware_base-5.2.1}/pyproject.toml

@@ -10,7 +10,7 @@ line-length = 79
 
 [project]
 name = "solentware-base"
-version = "5.2"
+version = "5.2.1"
 authors = [
   { name="Roger Marsh", email="roger.marsh@solentware.co.uk" },
 ]

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_databasedu.py

@@ -151,9 +151,9 @@ class Database(_database.Database):
             if values[-1] != record_number:
                 values.append(record_number)
                 if len(values) > SegmentSize.db_upper_conversion_limit:
-                    vsk = value_segments[
-                        key
-                    ] = SegmentSize.empty_bitarray.copy()
+                    vsk = value_segments[key] = (
+                        SegmentSize.empty_bitarray.copy()
+                    )
                     for j in values:
                         vsk[j] = True
                     vsk[record_number] = True

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_db.py

@@ -1414,7 +1414,7 @@ class Database(_database.Database):
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         if keylike is None:
             return recordlist
-        pattern = b".*?" + keylike
+        matcher = re.compile(keylike)
         cursor = self.table[SUBFILE_DELIMITER.join((file, field))].cursor(
             txn=self.dbtxn
         )
@@ -1422,7 +1422,7 @@ class Database(_database.Database):
             record = cursor.first()
             while record:
                 key, value = record
-                if re.match(pattern, key, flags=re.IGNORECASE | re.DOTALL):
+                if matcher.search(key):
                     self.populate_recordset_segment(recordlist, value)
                 record = cursor.next()
         finally:
@@ -1478,9 +1478,9 @@ class Database(_database.Database):
 
         Keys are in range set by combinations of ge, gt, le, and lt.
         """
-        if ge and gt:
+        if isinstance(ge, bytes) and isinstance(gt, bytes):
             raise DatabaseError("Both 'ge' and 'gt' given in key range")
-        if le and lt:
+        if isinstance(le, bytes) and isinstance(lt, bytes):
             raise DatabaseError("Both 'le' and 'lt' given in key range")
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         cursor = self.table[SUBFILE_DELIMITER.join((file, field))].cursor(
@@ -1490,7 +1490,7 @@ class Database(_database.Database):
             if ge is None and gt is None:
                 record = cursor.first()
             else:
-                record = cursor.set_range(ge or gt)
+                record = cursor.set_range(ge or gt or b"")
             if gt:
                 while record:
                     if record[0] > gt:

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_db_tkinter.py

@@ -1793,7 +1793,7 @@ class Database(_database.Database):
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         if keylike is None:
             return recordlist
-        pattern = b".*?" + keylike
+        matcher = re.compile(keylike)
         command = [
             self.table[SUBFILE_DELIMITER.join((file, field))],
             "cursor",
@@ -1805,7 +1805,7 @@ class Database(_database.Database):
             record = tcl_tk_call((cursor, "get", "-first"))
             while record:
                 key, value = record[0]
-                if re.match(pattern, key, flags=re.IGNORECASE | re.DOTALL):
+                if matcher.search(key):
                     self.populate_recordset_segment(recordlist, value)
                 record = tcl_tk_call((cursor, "get", "-next"))
         finally:
@@ -1872,9 +1872,9 @@ class Database(_database.Database):
 
         Keys are in range set by combinations of ge, gt, le, and lt.
         """
-        if ge and gt:
+        if isinstance(ge, str) and isinstance(gt, str):
             raise DatabaseError("Both 'ge' and 'gt' given in key range")
-        if le and lt:
+        if isinstance(le, str) and isinstance(lt, str):
             raise DatabaseError("Both 'le' and 'lt' given in key range")
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         command = [
@@ -1888,7 +1888,9 @@ class Database(_database.Database):
             if ge is None and gt is None:
                 record = tcl_tk_call((cursor, "get", "-first"))
             else:
-                record = tcl_tk_call((cursor, "get", "-set_range", ge or gt))
+                record = tcl_tk_call(
+                    (cursor, "get", "-set_range", ge or gt or "")
+                )
             if gt:
                 while record:
                     record0 = record[0]

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_dbdu.py

@@ -553,10 +553,10 @@ class Database(_databasedu.Database):
                     new_segment = make_segment_from_item(item)
                     new_segment |= existing_segment
                     new_segment.normalize()
-                    item[
-                        -2
-                    ] = self.database.encode_number_for_sequential_file_dump(
-                        new_segment.count_records(), 2
+                    item[-2] = (
+                        self.database.encode_number_for_sequential_file_dump(
+                            new_segment.count_records(), 2
+                        )
                     )
                     if int.from_bytes(high[-2], byteorder="big") == 1:
                         item[-1] = segment_table.append(

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_dbdu_tkinter.py

@@ -700,10 +700,10 @@ class Database(_databasedu.Database):
                     new_segment = make_segment_from_item(item)
                     new_segment |= existing_segment
                     new_segment.normalize()
-                    item[
-                        -2
-                    ] = self.database.encode_number_for_sequential_file_dump(
-                        new_segment.count_records(), 2
+                    item[-2] = (
+                        self.database.encode_number_for_sequential_file_dump(
+                            new_segment.count_records(), 2
+                        )
                     )
                     if int.from_bytes(high[-2], byteorder="big") == 1:
                         item[-1] = tcl_tk_call(

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_dpt.py

@@ -849,14 +849,14 @@ class Database(_database.Database):
                 dptapi.APIFieldValue(""),
             )
         )
-        matcher = re.compile(".*?" + keylike, flags=re.IGNORECASE | re.DOTALL)
+        matcher = re.compile(keylike)
         dvcursor = dptfile.table_connection.OpenDirectValueCursor(
             dptapi.APIFindValuesSpecification(dptfile.secondary[field])
         )
         dvcursor.GotoFirst()
         while dvcursor.Accessible():
             value = dvcursor.GetCurrentValue()
-            if matcher.match(value.ExtractString()):
+            if matcher.search(value.ExtractString()):
                 vfs = _DPTFoundSet(
                     dptfile,
                     dptfile.table_connection.FindRecords(
@@ -961,9 +961,9 @@ class Database(_database.Database):
 
         cache_size is not relevant to DPT.
         """
-        if ge and gt:
+        if isinstance(ge, str) and isinstance(gt, str):
             raise DatabaseError("Both 'ge' and 'gt' given in key range")
-        if le and lt:
+        if isinstance(le, str) and isinstance(lt, str):
             raise DatabaseError("Both 'le' and 'lt' given in key range")
         if ge is None and gt is None and le is None and lt is None:
             return self.recordlist_all(file, field, cache_size=cache_size)
@@ -975,8 +975,8 @@ class Database(_database.Database):
                 dptfile.table_connection.FindRecords(
                     dptapi.APIFindSpecification(
                         dptfile.secondary[field],
-                        dptapi.FD_GE if ge else dptapi.FD_GT,
-                        dptapi.APIFieldValue(ge or gt),
+                        dptapi.FD_GE if ge is not None else dptapi.FD_GT,
+                        dptapi.APIFieldValue(ge or gt or ""),
                     )
                 ),
             )
@@ -986,24 +986,32 @@ class Database(_database.Database):
                 dptfile.table_connection.FindRecords(
                     dptapi.APIFindSpecification(
                         dptfile.secondary[field],
-                        dptapi.FD_LE if le else dptapi.FD_LT,
-                        dptapi.APIFieldValue(le or lt),
+                        dptapi.FD_LE if le is not None else dptapi.FD_LT,
+                        dptapi.APIFieldValue(le or lt or ""),
                     )
                 ),
             )
         else:
             if ge:
-                range_ = dptapi.FD_RANGE_GE_LE if le else dptapi.FD_RANGE_GE_LT
+                range_ = (
+                    dptapi.FD_RANGE_GE_LE
+                    if le is not None
+                    else dptapi.FD_RANGE_GE_LT
+                )
             else:
-                range_ = dptapi.FD_RANGE_GT_LE if le else dptapi.FD_RANGE_GT_LT
+                range_ = (
+                    dptapi.FD_RANGE_GT_LE
+                    if le is not None
+                    else dptapi.FD_RANGE_GT_LT
+                )
             foundset = _DPTFoundSet(
                 dptfile,
                 dptfile.table_connection.FindRecords(
                     dptapi.APIFindSpecification(
                         dptfile.secondary[field],
                         range_,
-                        dptapi.APIFieldValue(ge or gt),
-                        dptapi.APIFieldValue(le or lt),
+                        dptapi.APIFieldValue(ge or gt or ""),
+                        dptapi.APIFieldValue(le or lt or ""),
                     )
                 ),
             )

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_lmdb.py

@@ -1482,14 +1482,14 @@ class Database(_database.Database):
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         if keylike is None:
             return recordlist
-        pattern = b".*?" + keylike
+        matcher = re.compile(keylike)
         with self.dbtxn.transaction.cursor(
             self.table[SUBFILE_DELIMITER.join((file, field))].datastore
         ) as cursor:
             record = cursor.first()
             while record:
                 key, value = cursor.item()
-                if re.match(pattern, key, flags=re.IGNORECASE | re.DOTALL):
+                if matcher.search(key):
                     self.populate_recordset_segment(recordlist, value)
                 record = cursor.next()
         return recordlist
@@ -1540,9 +1540,9 @@ class Database(_database.Database):
 
         Keys are in range set by combinations of ge, gt, le, and lt.
         """
-        if ge and gt:
+        if isinstance(ge, bytes) and isinstance(gt, bytes):
             raise DatabaseError("Both 'ge' and 'gt' given in key range")
-        if le and lt:
+        if isinstance(le, bytes) and isinstance(lt, bytes):
             raise DatabaseError("Both 'le' and 'lt' given in key range")
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         with self.dbtxn.transaction.cursor(
@@ -1551,7 +1551,7 @@ class Database(_database.Database):
             if ge is None and gt is None:
                 record = cursor.first()
             else:
-                record = cursor.set_range(ge or gt)
+                record = cursor.set_range(ge or gt or b"")
             if gt:
                 while record:
                     record = cursor.item()

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_lmdbdu.py

@@ -611,10 +611,10 @@ class Database(_databasedu.Database):
                     new_segment = make_segment_from_item(item)
                     new_segment |= existing_segment
                     new_segment.normalize()
-                    item[
-                        -2
-                    ] = self.database.encode_number_for_sequential_file_dump(
-                        new_segment.count_records(), 2
+                    item[-2] = (
+                        self.database.encode_number_for_sequential_file_dump(
+                            new_segment.count_records(), 2
+                        )
                     )
                     if int.from_bytes(item[-2], byteorder="big") == 1:
                         item[-1] = write_segment_value(

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_nosql.py

@@ -108,9 +108,9 @@ class Database(_database.Database):
                     continue
                 for fieldattr in NOSQL_FIELDATTS:
                     if fieldattr not in filedesc[FIELDS][fieldname]:
-                        filedesc[FIELDS][fieldname][
-                            fieldattr
-                        ] = SECONDARY_FIELDATTS[fieldattr]
+                        filedesc[FIELDS][fieldname][fieldattr] = (
+                            SECONDARY_FIELDATTS[fieldattr]
+                        )
         self.specification = specification
         self.segment_size_bytes = segment_size_bytes
         self.dbenv = None
@@ -1229,7 +1229,7 @@ class Database(_database.Database):
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         if keylike is None:
             return recordlist
-        matcher = re.compile(".*?" + keylike, flags=re.IGNORECASE | re.DOTALL)
+        matcher = re.compile(keylike)
         db = self.dbenv
         fieldtree = self.trees[SUBFILE_DELIMITER.join((file, field))]
         cursor = tree.Cursor(fieldtree)
@@ -1238,7 +1238,7 @@ class Database(_database.Database):
                 k = cursor.next()
                 if k is None:
                     break
-                if not matcher.match(k):
+                if not matcher.search(k):
                     continue
                 self.populate_recordset(
                     recordlist,
@@ -1322,9 +1322,9 @@ class Database(_database.Database):
                     ("'", field, "' field in '", file, "' file is not ordered")
                 )
             )
-        if ge and gt:
+        if isinstance(ge, str) and isinstance(gt, str):
             raise DatabaseError("Both 'ge' and 'gt' given in key range")
-        if le and lt:
+        if isinstance(le, str) and isinstance(lt, str):
             raise DatabaseError("Both 'le' and 'lt' given in key range")
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         db = self.dbenv
@@ -1334,7 +1334,7 @@ class Database(_database.Database):
             if ge is None and gt is None:
                 k = cursor.first()
             else:
-                k = cursor.nearest(ge or gt)
+                k = cursor.nearest(ge or gt or "")
             if gt:
                 while k is not None:
                     if k > gt:

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_nosqldu.py

@@ -121,9 +121,9 @@ class Database(_databasedu.Database):
         ebmc = self.ebm_control[file]
         tes = ebmc.table_ebm_segments
         insertion_point = bisect_right(tes, segment)
-        self.dbenv[
-            SUBFILE_DELIMITER.join((ebmc.ebm_table, str(segment)))
-        ] = repr(self.existence_bit_maps[file][segment].tobytes())
+        self.dbenv[SUBFILE_DELIMITER.join((ebmc.ebm_table, str(segment)))] = (
+            repr(self.existence_bit_maps[file][segment].tobytes())
+        )
         if not (tes and tes[insertion_point - 1] == segment):
             tes.insert(insertion_point, segment)
             self.dbenv[ebmc.ebm_table] = repr(tes)

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/_sqlite.py

@@ -991,9 +991,12 @@ class Database(_database.Database):
                     update_count_and_reference,
                     (
                         count,
-                        record_number % (segment * SegmentSize.db_segment_size)
-                        if segment
-                        else record_number,
+                        (
+                            record_number
+                            % (segment * SegmentSize.db_segment_size)
+                            if segment
+                            else record_number
+                        ),
                         key,
                         segment,
                     ),
@@ -1488,12 +1491,12 @@ class Database(_database.Database):
             )
         )
         db_segment_size_bytes = SegmentSize.db_segment_size_bytes
-        matcher = re.compile(".*?" + keylike, flags=re.IGNORECASE | re.DOTALL)
+        matcher = re.compile(keylike)
         get_segment_records = self.get_segment_records
         cursor = self.dbenv.cursor()
         try:
             for record in cursor.execute(statement):
-                if not matcher.match(record[0]):
+                if not matcher.search(record[0]):
                     continue
                 if record[2] == 1:
                     segment = RecordsetSegmentInt(
@@ -1595,9 +1598,11 @@ class Database(_database.Database):
         values = (
             b"".join(
                 (
-                    keystart.encode()
-                    if isinstance(keystart, str)
-                    else keystart,
+                    (
+                        keystart.encode()
+                        if isinstance(keystart, str)
+                        else keystart
+                    ),
                     b"*",
                 )
             ),
@@ -1638,14 +1643,22 @@ class Database(_database.Database):
 
         Keys are in range set by combinations of ge, gt, le, and lt.
         """
-        if ge and gt:
+        if isinstance(ge, str) and isinstance(gt, str):
             raise DatabaseError("Both 'ge' and 'gt' given in key range")
-        if le and lt:
+        if isinstance(le, str) and isinstance(lt, str):
             raise DatabaseError("Both 'le' and 'lt' given in key range")
         if ge is None and gt is None and le is None and lt is None:
             return self.recordlist_all(file, field, cache_size=cache_size)
-        highop = "<" if lt else "<=" if le else None
-        lowop = ">" if gt else ">=" if ge else None
+        highop = (
+            "<"
+            if isinstance(lt, str)
+            else "<=" if isinstance(le, str) else None
+        )
+        lowop = (
+            ">"
+            if isinstance(gt, str)
+            else ">=" if isinstance(ge, str) else None
+        )
         recordlist = RecordList(dbhome=self, dbset=file, cache_size=cache_size)
         if highop is None:
             statement = " ".join(
@@ -1666,7 +1679,7 @@ class Database(_database.Database):
                     "?",
                 )
             )
-            values = (ge or gt,)
+            values = (ge or gt or "",)
         elif lowop is None:
             statement = " ".join(
                 (
@@ -1686,7 +1699,7 @@ class Database(_database.Database):
                     "?",
                 )
             )
-            values = (le or lt,)
+            values = (le or lt or "",)
         else:
             statement = " ".join(
                 (
@@ -1709,7 +1722,7 @@ class Database(_database.Database):
                     "?",
                 )
             )
-            values = ge or gt, le or lt
+            values = (ge or gt or "", le or lt or "")
         db_segment_size_bytes = SegmentSize.db_segment_size_bytes
         get_segment_records = self.get_segment_records
         cursor = self.dbenv.cursor()

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/find.py

@@ -152,8 +152,10 @@ class Find:
         for segment in recordset.rs_segments.values():
             j = segment.first()
             while j:
-                instance.load_record(j)
-                yield j[0], instance.value
+                instance.load_record(
+                    self._db.get_primary_record(self._dbset, j[1])
+                )
+                yield j[1], instance.value
                 j = segment.next()
 
     def non_index_condition(self, obj, record_number, record):

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/record.py

@@ -547,9 +547,11 @@ class Record:
             record = database.get_primary_record(
                 dbset,
                 # database.decode_as_primary_key(dbset, newrecord.srkey))
-                database.decode_record_number(newrecord.srkey)
-                if isinstance(newrecord.srkey, int)
-                else newrecord.srkey,
+                (
+                    database.decode_record_number(newrecord.srkey)
+                    if isinstance(newrecord.srkey, int)
+                    else newrecord.srkey
+                ),
             )
             if record is None:
                 database.put_instance(dbset, newrecord)

{solentware-base-5.2 → solentware_base-5.2.1}/solentware_base/core/where.py

@@ -36,13 +36,12 @@ particularly the last of these.
 """
 
 import re
-import sre_constants
 from tkinter import simpledialog
 
 from .constants import SECONDARY
 
-DOUBLE_QUOTE_STRING = '".*?"'
-SINGLE_QUOTE_STRING = "'.*?'"
+DOUBLE_QUOTE_STRING = r'"[^\\"]*(?:\\.[^\\"]*)*"'
+SINGLE_QUOTE_STRING = r"'[^\\']*(?:\\.[^\\']*)*'"
 LEFT_PARENTHESIS = "("
 RIGHT_PARENTHESIS = ")"
 OR = "or"
@@ -67,7 +66,7 @@ BELOW = "below"
 BEFORE = "before"
 STARTS = "starts"
 PRESENT = "present"
-STRING = ".+?"
+STRING = r"\w+|\s+|[^\w\s()'\"]+|['\"]"
 
 LEADING_SPACE = r"(?<=\s)"
 TRAILING_SPACE = r"(?=\s)"
@@ -102,9 +101,9 @@ WHERE_RE = re.compile(
             BEFORE.join((LEADING_SPACE, TRAILING_SPACE)),
             STARTS.join((LEADING_SPACE, TRAILING_SPACE)),
             PRESENT.join((LEADING_SPACE, r"(?=\s|\)|\Z)")),
-            STRING,
+            STRING.join("()"),
         )
-    ).join(("(", ")")),
+    ),
     flags=re.IGNORECASE | re.DOTALL,
 )
 
@@ -175,26 +174,41 @@ class Where:
     def lex(self):
         """Split instance's statement into tokens."""
         tokens = []
+        items = []
         strings = []
-        for word in WHERE_RE.split(self.statement):
+        string_items = []
+        for item in WHERE_RE.finditer(self.statement):
+            word = item.group()
             if word.lower() in KEYWORDS:
                 if strings:
-                    tokens.append("".join([_trim(s) for s in strings if s]))
+                    tokens.append("".join(_trim(strings)))
                     strings.clear()
+                    items.append(tuple(string_items))
+                    string_items.clear()
                 tokens.append(word.lower())
-            elif word.strip():
-                strings.append(word.strip())
+                items.append((item,))
+            elif word:
+                strings.append(word)
+                string_items.append(item)
         if strings:
-            tokens.append("".join([_trim(s) for s in strings if s]))
+            tokens.append("".join(_trim(strings)))
             strings.clear()
-        self.tokens = tokens
+            items.append(tuple(string_items))
+            string_items.clear()
+        self.tokens = [
+            (i, t)
+            for i, t in zip(items, tokens)
+            if t != "" or None in [j.group(1) for j in i]
+        ]
 
     def parse(self):
         """Parse instance's tokens to create node structure to do query."""
         self.node = WhereClause()
         state = self._set_field_not_leftp_start
         for i, token in enumerate(self.tokens):
-            state = state(token)
+            # May need to be 'state = state(token)' with the <state>
+            # methods influenced by token[0] if appropriate.
+            state = state(token[1])
             if not state:
                 self._error_information.tokens = self.tokens[: i + 1]
                 break
@@ -392,10 +406,10 @@ class Where:
         if token_lower == LEFT_PARENTHESIS:
             self._first_token_left_parenthesis(token)
             return self._set_field_not_leftp
-        if token_lower not in KEYWORDS:
-            self._first_token_field(token)
-            return self._set_not_num_alpha_condition
-        return self.error(token)
+        if token_lower in KEYWORDS:
+            self.raise_where_error(token)
+        self._first_token_field(token)
+        return self._set_not_num_alpha_condition
 
     def _set_field_leftp(self, token):
         """Expect fieldname, or '(', after 'not'."""
@@ -403,11 +417,11 @@ class Where:
         if token_lower == LEFT_PARENTHESIS:
             self._boolean_left_parenthesis(token)
             return self._set_field_not_leftp
-        if token_lower not in KEYWORDS:
-            self._deferred_not_phrase()
-            self.node.field = token
-            return self._set_not_num_alpha_condition
-        return self.error(token)
+        if token_lower in KEYWORDS:
+            self.raise_where_error(token)
+        self._deferred_not_phrase()
+        self.node.field = token
+        return self._set_not_num_alpha_condition
 
     def _set_field_not_leftp(self, token):
         """Expect fieldname, 'not', or '(', after '(' or boolean."""
@@ -418,11 +432,11 @@ class Where:
         if token_lower == LEFT_PARENTHESIS:
             self._boolean_left_parenthesis(token)
             return self._set_field_not_leftp
-        if token_lower not in KEYWORDS:
-            self._deferred_not_phrase()
-            self.node.field = token
-            return self._set_not_num_alpha_condition
-        return self.error(token)
+        if token_lower in KEYWORDS:
+            self.raise_where_error(token)
+        self._deferred_not_phrase()
+        self.node.field = token
+        return self._set_not_num_alpha_condition
 
     def _set_not_num_alpha_condition(self, token):
         """Expect 'not', 'num', 'alpha', or a condition, after fieldname."""
@@ -440,7 +454,7 @@ class Where:
             # for the token_lower == NOT case because 'is' is never
             # preceded by 'not'.
             if self._not:
-                return self.error(token)
+                self.raise_where_error(token)
             self.node.condition = token_lower
             return self._set_not_value
 
@@ -473,7 +487,8 @@ class Where:
             self._deferred_not_condition()
             self.node.condition = token_lower
             return self._set_first_value
-        return self.error(token)
+        self.raise_where_error(token)
+        return None
 
     def _set_second_condition(self, token):
         """Expect second condition after first value of double condition."""
@@ -481,7 +496,8 @@ class Where:
         if token_lower in SECOND_CONDITIONS:
             self.node.condition = self.node.condition, token_lower
             return self._set_second_value
-        return self.error(token)
+        self.raise_where_error(token)
+        return None
 
     def _set_not_value(self, token):
         """Expect 'not', or a value, after a condition."""
@@ -493,39 +509,37 @@ class Where:
 
     def _set_value(self, token):
         """Expect value after single condition."""
-        token_lower = token.lower()
-        if token_lower not in KEYWORDS:
-            self.node.value = token
-            return self._set_and_or_nor_rightp__single_condition
-        return self.error(token)
+        self.node.value = token
+        return self._set_and_or_nor_rightp__single_condition
 
     def _set_value_like(self, token):
         """Expect value, a regular expression, after like."""
-        token_lower = token.lower()
-        if token_lower not in KEYWORDS:
-            try:
-                re.compile(token, flags=re.IGNORECASE | re.DOTALL)
-            except sre_constants.error:
-                return self.error(token)
-            self.node.value = token
-            return self._set_and_or_nor_rightp__single_condition
-        return self.error(token)
+        try:
+            re.compile(token)
+        except re.error as exc:
+            raise WhereError(
+                "".join(
+                    (
+                        "Problem with 'like' argument\n\n'",
+                        token,
+                        "'\n\nThe reported regular expression ",
+                        "error is\n\n",
+                        str(exc),
+                    )
+                )
+            ) from exc
+        self.node.value = token
+        return self._set_and_or_nor_rightp__single_condition
 
     def _set_first_value(self, token):
         """Expect first value after first condition in double condition."""
-        token_lower = token.lower()
-        if token_lower not in KEYWORDS:
-            self.node.value = token
-            return self._set_second_condition
-        return self.error(token)
+        self.node.value = token
+        return self._set_second_condition
 
     def _set_second_value(self, token):
         """Expect second value after second condition in double condition."""
-        token_lower = token.lower()
-        if token_lower not in KEYWORDS:
-            self.node.value = self.node.value, token
-            return self._set_and_or_nor_rightp__single_condition
-        return self.error(token)
+        self.node.value = self.node.value, token
+        return self._set_and_or_nor_rightp__single_condition
 
     def _set_and_or_nor_rightp__single_condition(self, token):
         """Expect boolean or rightp after value in single condition phrase.
@@ -589,7 +603,8 @@ class Where:
                 raise WhereError("No unmatched left-parentheses")
             self.node = self.node.up
             return self._set_and_or_nor_rightp
-        return self.error(token)
+        self.raise_where_error(token)
+        return None
 
     def _set_field_leftp_not_condition(self, token):
         """Expect fieldname, '(', 'not', or condition after rightp."""
@@ -602,11 +617,11 @@ class Where:
     def _set_field_leftp_condition(self, token):
         """Expect fieldname, '(', or condition after rightp 'not'."""
         token_lower = token.lower()
-        if token_lower not in KEYWORDS:
-            self._deferred_not_phrase()
-            self.node.field = token
-            return self._set_not_num_alpha_condition
-        return self._set_leftp_condition(token)
+        if token_lower in KEYWORDS:
+            return self._set_leftp_condition(token)
+        self._deferred_not_phrase()
+        self.node.field = token
+        return self._set_not_num_alpha_condition
 
     def _set_field_leftp_not_condition_value(self, token):
         """Expect fieldname, '(', 'not', condition, or value, after rightp."""
@@ -619,10 +634,10 @@ class Where:
     def _set_field_leftp_condition_value(self, token):
         """Expect fieldname, '(', condition, or value, after rightp 'not'."""
         token_lower = token.lower()
-        if token_lower not in KEYWORDS:
-            self._f_or_v = token
-            return self._set_field_or_value__not
-        return self._set_leftp_condition(token)
+        if token_lower in KEYWORDS:
+            return self._set_leftp_condition(token)
+        self._f_or_v = token
+        return self._set_field_or_value__not
 
     def _set_field_or_value__not(self, token):
         """Expect keyword to interpret previous token as field or value."""
@@ -657,7 +672,7 @@ class Where:
             # for the token_lower == NOT case because 'is' is never
             # preceded by 'not'.
             if self._not:
-                return self.error(token)
+                self.raise_where_error(token)
             self._field_condition(token_lower)
             return self._set_not_value
 
@@ -680,7 +695,8 @@ class Where:
             self._field_condition(token_lower)
             self._alphanum_condition(token_lower)
             return self._set_condition
-        return self.error(token)
+        self.raise_where_error(token)
+        return None
 
     # Why is this not the same as _set_num_alpha_condition?
     # Perhaps the question should be the other way round!
@@ -699,7 +715,7 @@ class Where:
             # for the token_lower == NOT case because 'is' is never
             # preceded by 'not'.
             if self._not:
-                return self.error(token)
+                self.raise_where_error(token)
             self.node.condition = token_lower
             return self._set_not_value
 
@@ -727,14 +743,12 @@ class Where:
             self._copy_pre_alphanumeric()
             self._alphanum_condition(token_lower)
             return self._set_condition
-        return self.error(token)
+        self.raise_where_error(token)
+        return None
 
-    # Returning False always cannot possibly be correct, surely?
-    def error(self, token):
-        """Return False."""
-        if token.lower() in KEYWORDS:
-            return False
-        return False
+    def raise_where_error(self, token):
+        """Raise WhereError exception."""
+        raise WhereError(token.join(("Unable to process token '", "'")))
 
     def _deferred_not_condition(self):
         """Nearest 'not' to left inverts a condition such as 'eq'."""
@@ -1112,15 +1126,18 @@ class WhereConstraint:
         self.pending = False
 
 
-def _trim(string):
-    """Return string with one leading and trailing ' or " removed.
+def _trim(strings):
+    """Return trimmed copy of strings.
 
-    The two quote characters allow values containing spaces.
+    The first item has leading whitespace removed.
+    The last item has trailing whitespace removed.
+    One leading and one trailing ' or " is removed from all items longer
+    than one character.
 
     """
-    if string[0] in "'\"":
-        return string[1:-1]
-    return string
+    strings[0] = strings[0].lstrip()
+    strings[-1] = strings[-1].rstrip()
+    return [s[1:-1] if len(s) > 1 and s[0] in "'\"" else s for s in strings]
 
 
 class WhereStatementError:

{solentware-base-5.2 → solentware_base-5.2.1/solentware_base.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: solentware-base
-Version: 5.2
+Version: 5.2.1
 Summary: Bitmapped record number databases.
 Author-email: Roger Marsh <roger.marsh@solentware.co.uk>
 License: Licence for solentware_base package