velocity-python 0.0.103__py3-none-any.whl → 0.0.105__py3-none-any.whl

velocity/aws/amplify.py

@@ -250,7 +250,7 @@ class AmplifyProject:
             customRules=[
                 {"source": "/<*>", "target": "/index.html", "status": "404-200"},
                 {
-                    "source": f'</^[^.]+$|\.(?!({"|".join(srv_list)})$)([^.]+$)/>',
+                    "source": f'</^[^.]+$|\\.(?!({"|".join(srv_list)})$)([^.]+$)/>',
                     "target": "/",
                     "status": "200",
                 },

velocity/db/__init__.py

@@ -3,6 +3,17 @@ from velocity.db.servers import postgres
 from velocity.db.servers import mysql
 from velocity.db.servers import sqlite
 from velocity.db.servers import sqlserver
+from velocity.db import utils
 
 # Export exceptions at the package level for backward compatibility
 from velocity.db.exceptions import *
+
+# Export commonly used utility functions
+from velocity.db.utils import (
+    safe_sort_rows,
+    safe_sort_key_none_last,
+    safe_sort_key_none_first,
+    safe_sort_key_with_default,
+    group_by_fields,
+    safe_sort_grouped_rows
+)

velocity/db/core/engine.py

@@ -335,8 +335,8 @@ class Engine:
             sql: The SQL statement that caused the error (optional)
             parameters: The parameters passed to the SQL statement (optional)
             
-        Returns:
-            The appropriate velocity exception to raise
+        Raises:
+            The appropriate velocity exception with proper chaining
         """
         logger = logging.getLogger(__name__)
         
@@ -369,7 +369,7 @@ class Engine:
                 if error_code in codes:
                     logger.info(f"✅ Successfully classified error: {error_code} → {error_class}")
                     try:
-                        return self._create_exception_with_chaining(
+                        raise self._create_exception_with_chaining(
                             error_class, error_message, exception, sql, parameters
                         )
                     except Exception as creation_error:
@@ -445,7 +445,7 @@ class Engine:
                 try:
                     if re.search(pattern, error_message_lower):
                         logger.info(f"✅ Classified error by pattern match: '{pattern}' → {error_class}")
-                        return self._create_exception_with_chaining(
+                        raise self._create_exception_with_chaining(
                             error_class, error_message, exception, sql, parameters
                         )
                 except re.error as regex_error:
@@ -464,7 +464,7 @@ class Engine:
             f"   → Available Classifications: {available_codes or 'None configured'}"
         )
         
-        return self._create_exception_with_chaining(
+        raise self._create_exception_with_chaining(
             'DatabaseError', error_message, exception, sql, parameters
         )
     
@@ -1082,7 +1082,7 @@ class Engine:
             else:
                 new_exception = ExceptionClass(formatted_message)
                 
-            # Only set __cause__ if original_exception is actually a BaseException
+            # Only set __cause__ if original_exception is not None and derives from BaseException
             if isinstance(original_exception, BaseException):
                 new_exception.__cause__ = original_exception  # Preserve exception chain
             
@@ -1105,7 +1105,7 @@ class Engine:
                 )
                 
                 fallback_exception = DatabaseError(formatted_message)
-                # Only set __cause__ if original_exception is actually a BaseException
+                # Only set __cause__ if original_exception is not None and derives from BaseException
                 if isinstance(original_exception, BaseException):
                     fallback_exception.__cause__ = original_exception
                 return fallback_exception

velocity/db/core/result.py

@@ -7,11 +7,37 @@ class Result:
     """
     Wraps a database cursor to provide various convenience transformations
     (dict, list, tuple, etc.) and helps iterate over query results.
+    
+    Features:
+    - Pre-fetches first row for immediate boolean evaluation
+    - Boolean state changes as rows are consumed: bool(result) tells you if MORE rows are available
+    - Supports __bool__, is_empty(), has_results() for checking remaining results
+    - Efficient iteration without unnecessary fetchall() calls
+    - Caches next row to maintain accurate state without redundant database calls
+    
+    Boolean Behavior:
+    - Initially: bool(result) = True if query returned any rows
+    - After each row: bool(result) = True if more rows are available to fetch
+    - After last row: bool(result) = False (no more rows)
+    - After one() or scalar(): bool(result) = False (marked as exhausted)
     """
 
     def __init__(self, cursor=None, tx=None, sql=None, params=None):
         self._cursor = cursor
-        self._headers = [x[0].lower() for x in getattr(cursor, "description", []) or []]
+        # Safely extract headers from cursor description
+        try:
+            description = getattr(cursor, "description", []) or []
+            self._headers = []
+            for col in description:
+                if hasattr(col, '__getitem__'):  # Tuple-like (col[0])
+                    self._headers.append(col[0].lower())
+                elif hasattr(col, 'name'):  # Object with name attribute
+                    self._headers.append(col.name.lower())
+                else:
+                    self._headers.append(f'column_{len(self._headers)}')
+        except (AttributeError, TypeError, IndexError):
+            self._headers = []
+            
         self.__as_strings = False
         self.__enumerate = False
         self.__count = -1
@@ -20,6 +46,32 @@ class Result:
         self.__sql = sql
         self.__params = params
         self.transform = lambda row: dict(zip(self.headers, row))  # Default transform
+        self._cached_first_row = None
+        self._first_row_fetched = False
+        self._exhausted = False
+        
+        # Pre-fetch the first row to enable immediate boolean evaluation
+        self._fetch_first_row()
+
+    def _fetch_first_row(self):
+        """
+        Pre-fetch the first row from the cursor to enable immediate boolean evaluation.
+        """
+        if self._first_row_fetched or not self._cursor:
+            return
+            
+        try:
+            raw_row = self._cursor.fetchone()
+            if raw_row:
+                self._cached_first_row = raw_row
+            else:
+                self._exhausted = True
+        except Exception:
+            # If there's an error fetching (e.g., cursor closed), assume no results
+            self._exhausted = True
+            self._cursor = None  # Mark cursor as invalid
+        finally:
+            self._first_row_fetched = True
 
     def __str__(self):
         return repr(self.all())
@@ -31,20 +83,80 @@ class Result:
         if not exc_type:
             self.close()
 
+    def __bool__(self):
+        """
+        Return True if there are more rows available to fetch.
+        This changes as rows are consumed - after the last row is fetched, this becomes False.
+        """
+        return self.has_results()
+
+    def is_empty(self):
+        """
+        Return True if there are no more rows available to fetch.
+        """
+        return not self.has_results()
+
+    def has_results(self):
+        """
+        Return True if there are more rows available to fetch.
+        This is based on whether we have a cached row or the cursor isn't exhausted.
+        """
+        return self._cached_first_row is not None or (not self._exhausted and self._cursor)
+
     def __next__(self):
         """
         Iterator interface to retrieve the next row.
         """
-        if self._cursor:
-            row = self._cursor.fetchone()
-            if row:
-                if self.__as_strings:
-                    row = ["" if x is None else str(x) for x in row]
-                if self.__enumerate:
-                    self.__count += 1
-                    return (self.__count, self.transform(row))
-                return self.transform(row)
-        raise StopIteration
+        # If we have a cached first row, return it and clear the cache
+        if self._cached_first_row is not None:
+            row = self._cached_first_row
+            self._cached_first_row = None
+            # Try to pre-fetch the next row to update our state
+            self._try_cache_next_row()
+        elif not self._exhausted and self._cursor:
+            try:
+                row = self._cursor.fetchone()
+                if not row:
+                    self._exhausted = True
+                    raise StopIteration
+                # Try to pre-fetch the next row to update our state  
+                self._try_cache_next_row()
+            except Exception as e:
+                # Handle cursor errors (e.g., closed cursor)
+                self._exhausted = True
+                self._cursor = None
+                if isinstance(e, StopIteration):
+                    raise
+                raise StopIteration
+        else:
+            raise StopIteration
+
+        # Apply transformations
+        if self.__as_strings:
+            row = ["" if x is None else str(x) for x in row]
+        if self.__enumerate:
+            self.__count += 1
+            return (self.__count, self.transform(row))
+        return self.transform(row)
+
+    def _try_cache_next_row(self):
+        """
+        Try to cache the next row to maintain accurate boolean state.
+        This is called after we return a row to check if there are more.
+        """
+        if not self._cursor or self._cached_first_row is not None:
+            return
+            
+        try:
+            next_row = self._cursor.fetchone()
+            if next_row:
+                self._cached_first_row = next_row
+            else:
+                self._exhausted = True
+        except Exception:
+            # If cursor is closed or has error, mark as exhausted
+            self._exhausted = True
+            self._cursor = None
 
     def batch(self, qty=1):
         """
@@ -90,16 +202,33 @@ class Result:
     def columns(self):
         """
         Retrieves detailed column information from the cursor.
+        Gracefully handles different database types.
         """
         if not self.__columns and self._cursor and hasattr(self._cursor, "description"):
             for column in self._cursor.description:
                 data = {
-                    "type_name": self.__tx.pg_types[column.type_code],
+                    "type_name": "unknown"  # Default value
                 }
+                
+                # Try to get type information (PostgreSQL specific)
+                try:
+                    if hasattr(column, 'type_code') and self.__tx and hasattr(self.__tx, 'pg_types'):
+                        data["type_name"] = self.__tx.pg_types.get(column.type_code, "unknown")
+                except (AttributeError, KeyError):
+                    # Keep default value
+                    pass
+                
+                # Get all other column attributes safely
                 for key in dir(column):
-                    if "__" not in key:
-                        data[key] = getattr(column, key)
-                self.__columns[column.name] = data
+                    if not key.startswith("__"):
+                        try:
+                            data[key] = getattr(column, key)
+                        except (AttributeError, TypeError):
+                            # Skip attributes that can't be accessed
+                            continue
+                            
+                column_name = getattr(column, 'name', f'column_{len(self.__columns)}')
+                self.__columns[column_name] = data
         return self.__columns
 
     @property
@@ -108,10 +237,19 @@ class Result:
 
     def close(self):
         """
-        Closes the underlying cursor if it exists.
+        Closes the underlying cursor if it exists and marks result as exhausted.
         """
         if self._cursor:
-            self._cursor.close()
+            try:
+                self._cursor.close()
+            except Exception:
+                # Ignore errors when closing cursor
+                pass
+            finally:
+                self._cursor = None
+        # Mark as exhausted and clear cached data
+        self._exhausted = True
+        self._cached_first_row = None
 
     def as_dict(self):
         """
@@ -165,23 +303,35 @@ class Result:
     def scalar(self, default=None):
         """
         Return the first column of the first row, or `default` if no rows.
-        """
-        if not self._cursor:
-            return None
-        val = self._cursor.fetchone()
-        # Drain any remaining rows.
-        self._cursor.fetchall()
-        return val[0] if val else default
+        After calling this method, the result is marked as exhausted.
+        """
+        if self._cached_first_row is not None:
+            val = self._cached_first_row
+            self._cached_first_row = None
+            self._exhausted = True  # Mark as exhausted since we only want one value
+            return val[0] if val else default
+        elif not self._exhausted and self._cursor:
+            try:
+                val = self._cursor.fetchone()
+                self._exhausted = True
+                return val[0] if val else default
+            except Exception:
+                # If cursor error, return default
+                self._exhausted = True
+                self._cursor = None
+                return default
+        return default
 
     def one(self, default=None):
         """
         Return the first row or `default` if no rows.
+        After calling this method, the result is marked as exhausted.
         """
         try:
             row = next(self)
-            # Drain remaining.
-            if self._cursor:
-                self._cursor.fetchall()
+            # Mark as exhausted since we only want one row
+            self._exhausted = True
+            self._cached_first_row = None  # Clear any cached row
             return row
         except StopIteration:
             return default

velocity/db/core/row.py

@@ -1,4 +1,5 @@
 import pprint
+from velocity.db.exceptions import DbColumnMissingError
 
 
 class Row:
@@ -85,10 +86,21 @@ class Row:
         return list(d.items())
 
     def get(self, key, failobj=None):
-        data = self[key]
-        if data is None:
+        try:
+            data = self[key]
+            if data is None:
+                return failobj
+            return data
+        except DbColumnMissingError:
+            # Column doesn't exist in the table, return the default value
             return failobj
-        return data
+        except Exception as e:
+            # Check if the error message indicates a missing column
+            error_msg = str(e).lower()
+            if 'column' in error_msg and ('does not exist' in error_msg or 'not found' in error_msg):
+                return failobj
+            # Re-raise other exceptions
+            raise
 
     def setdefault(self, key, default=None):
         data = self[key]

velocity/db/core/table.py

@@ -61,7 +61,8 @@ class Table:
         try:
             return self._cursor
         except:
-            self._cursor = self.tx.cursor()
+            pass
+        self._cursor = self.tx.cursor()
         return self._cursor
 
     def __call__(self, where=None):

velocity/db/utils.py

@@ -0,0 +1,209 @@
+"""
+Database utility functions for common operations.
+
+This module provides utility functions to handle common database operations
+safely, including sorting with None values and other edge cases.
+"""
+
+from typing import Any, Callable, List, Optional, Union
+
+
+def safe_sort_key_none_last(field_name: str) -> Callable[[dict], tuple]:
+    """
+    Create a sort key function that places None values at the end.
+    
+    Args:
+        field_name: Name of the field to sort by
+        
+    Returns:
+        A function suitable for use as a sort key that handles None values
+        
+    Example:
+        rows = [{"date": "2024-01"}, {"date": None}, {"date": "2023-12"}]
+        sorted_rows = sorted(rows, key=safe_sort_key_none_last("date"))
+        # Result: [{"date": "2023-12"}, {"date": "2024-01"}, {"date": None}]
+    """
+    def sort_key(row: dict) -> tuple:
+        value = row.get(field_name)
+        if value is None:
+            return (1, "")  # None values sort last
+        return (0, value)
+    
+    return sort_key
+
+
+def safe_sort_key_none_first(field_name: str) -> Callable[[dict], tuple]:
+    """
+    Create a sort key function that places None values at the beginning.
+    
+    Args:
+        field_name: Name of the field to sort by
+        
+    Returns:
+        A function suitable for use as a sort key that handles None values
+        
+    Example:
+        rows = [{"date": "2024-01"}, {"date": None}, {"date": "2023-12"}]
+        sorted_rows = sorted(rows, key=safe_sort_key_none_first("date"))
+        # Result: [{"date": None}, {"date": "2023-12"}, {"date": "2024-01"}]
+    """
+    def sort_key(row: dict) -> tuple:
+        value = row.get(field_name)
+        if value is None:
+            return (0, "")  # None values sort first
+        return (1, value)
+    
+    return sort_key
+
+
+def safe_sort_key_with_default(field_name: str, default_value: Any = "") -> Callable[[dict], Any]:
+    """
+    Create a sort key function that replaces None values with a default.
+    
+    Args:
+        field_name: Name of the field to sort by
+        default_value: Value to use for None entries
+        
+    Returns:
+        A function suitable for use as a sort key that handles None values
+        
+    Example:
+        rows = [{"date": "2024-01"}, {"date": None}, {"date": "2023-12"}]
+        sorted_rows = sorted(rows, key=safe_sort_key_with_default("date", "1900-01"))
+        # Result: [{"date": None}, {"date": "2023-12"}, {"date": "2024-01"}]
+    """
+    def sort_key(row: dict) -> Any:
+        value = row.get(field_name)
+        return default_value if value is None else value
+    
+    return sort_key
+
+
+def safe_sort_rows(rows: List[dict], field_name: str, 
+                   none_handling: str = "last", 
+                   default_value: Any = "",
+                   reverse: bool = False) -> List[dict]:
+    """
+    Safely sort a list of dictionaries by a field that may contain None values.
+    
+    Args:
+        rows: List of dictionaries to sort
+        field_name: Name of the field to sort by
+        none_handling: How to handle None values - "first", "last", or "default"
+        default_value: Default value to use when none_handling is "default"
+        reverse: Whether to reverse the sort order
+        
+    Returns:
+        New list of dictionaries sorted by the specified field
+        
+    Raises:
+        ValueError: If none_handling is not a valid option
+        
+    Example:
+        rows = [
+            {"name": "Alice", "date": "2024-01"},
+            {"name": "Bob", "date": None},
+            {"name": "Charlie", "date": "2023-12"}
+        ]
+        
+        # None values last
+        sorted_rows = safe_sort_rows(rows, "date")
+        
+        # None values first  
+        sorted_rows = safe_sort_rows(rows, "date", none_handling="first")
+        
+        # Replace None with default
+        sorted_rows = safe_sort_rows(rows, "date", none_handling="default", 
+                                   default_value="1900-01")
+    """
+    if none_handling == "last":
+        key_func = safe_sort_key_none_last(field_name)
+    elif none_handling == "first":
+        key_func = safe_sort_key_none_first(field_name)
+    elif none_handling == "default":
+        key_func = safe_sort_key_with_default(field_name, default_value)
+    else:
+        raise ValueError(f"Invalid none_handling option: {none_handling}. "
+                        "Must be 'first', 'last', or 'default'")
+    
+    return sorted(rows, key=key_func, reverse=reverse)
+
+
+def group_by_fields(rows: List[dict], *field_names: str) -> dict:
+    """
+    Group rows by one or more field values.
+    
+    Args:
+        rows: List of dictionaries to group
+        *field_names: Names of fields to group by
+        
+    Returns:
+        Dictionary where keys are tuples of field values and values are lists of rows
+        
+    Example:
+        rows = [
+            {"email": "alice@example.com", "type": "premium", "amount": 100},
+            {"email": "alice@example.com", "type": "basic", "amount": 50},
+            {"email": "bob@example.com", "type": "premium", "amount": 100},
+        ]
+        
+        # Group by email only
+        groups = group_by_fields(rows, "email")
+        # Result: {
+        #     ("alice@example.com",): [row1, row2],
+        #     ("bob@example.com",): [row3]
+        # }
+        
+        # Group by email and type
+        groups = group_by_fields(rows, "email", "type")
+        # Result: {
+        #     ("alice@example.com", "premium"): [row1],
+        #     ("alice@example.com", "basic"): [row2],
+        #     ("bob@example.com", "premium"): [row3]
+        # }
+    """
+    groups = {}
+    for row in rows:
+        key = tuple(row.get(field) for field in field_names)
+        if key not in groups:
+            groups[key] = []
+        groups[key].append(row)
+    
+    return groups
+
+
+def safe_sort_grouped_rows(grouped_rows: dict, field_name: str,
+                          none_handling: str = "last",
+                          default_value: Any = "",
+                          reverse: bool = False) -> dict:
+    """
+    Safely sort rows within each group of a grouped result.
+    
+    Args:
+        grouped_rows: Dictionary of grouped rows (from group_by_fields)
+        field_name: Name of the field to sort by within each group
+        none_handling: How to handle None values - "first", "last", or "default"
+        default_value: Default value to use when none_handling is "default"
+        reverse: Whether to reverse the sort order
+        
+    Returns:
+        Dictionary with the same keys but sorted lists as values
+        
+    Example:
+        # After grouping payment profiles by email and card number
+        groups = group_by_fields(payment_profiles, "email_address", "card_number")
+        
+        # Sort each group by expiration date, with None values last
+        sorted_groups = safe_sort_grouped_rows(groups, "expiration_date")
+        
+        # Now process each sorted group
+        for group_key, sorted_group in sorted_groups.items():
+            for idx, row in enumerate(sorted_group):
+                # Process each row safely
+                pass
+    """
+    result = {}
+    for key, rows in grouped_rows.items():
+        result[key] = safe_sort_rows(rows, field_name, none_handling, default_value, reverse)
+    
+    return result

{velocity_python-0.0.103.dist-info → velocity_python-0.0.105.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.103
+Version: 0.0.105
 Summary: A rapid application development library for interfacing with data storage
-Author-email: Velocity Team <contact@example.com>
-License: MIT
+Author-email: Velocity Team <info@codeclubs.org>
+License-Expression: MIT
 Project-URL: Homepage, https://codeclubs.org/projects/velocity
 Keywords: database,orm,sql,rapid-development,data-storage
 Classifier: Development Status :: 3 - Alpha
@@ -16,7 +16,6 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
@@ -146,6 +145,58 @@ pip install velocity-python[sqlserver]
 pip install velocity-python[all]
 ```
 
+## Project Structure
+
+```
+velocity-python/
+├── src/velocity/           # Main package source code
+├── tests/                  # Test suite
+├── scripts/                # Utility scripts and demos
+│   ├── run_tests.py       # Test runner script
+│   ├── bump.py            # Version management
+│   ├── demo_*.py          # Demo scripts
+│   └── README.md          # Script documentation
+├── docs/                   # Documentation
+│   ├── TESTING.md         # Testing guide
+│   ├── DUAL_FORMAT_DOCUMENTATION.md
+│   ├── ERROR_HANDLING_IMPROVEMENTS.md
+│   └── sample_error_email.html
+├── Makefile               # Development commands
+├── pyproject.toml         # Package configuration
+└── README.md              # This file
+```
+
+## Development
+
+### Running Tests
+
+```bash
+# Run unit tests (fast, no database required)
+make test-unit
+
+# Run integration tests (requires database)
+make test-integration
+
+# Run with coverage
+make coverage
+
+# Clean cache files
+make clean
+```
+
+### Using Scripts
+
+```bash
+# Run the test runner directly
+python scripts/run_tests.py --unit --verbose
+
+# Version management
+python scripts/bump.py
+
+# See all available demo scripts
+ls scripts/demo_*.py
+```
+
 ## Quick Start
 
 ### Database Connection

{velocity_python-0.0.103.dist-info → velocity_python-0.0.105.dist-info}/RECORD

@@ -5,24 +5,25 @@ velocity/app/orders.py,sha256=W-HAXEwY8-IFXbKh82HnMeRVZM7P-TWGEQOWtkLIzI4,6298
 velocity/app/payments.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/app/purchase_orders.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/aws/__init__.py,sha256=tj9-NliYxRVPYLnnDuA4FMwBHbbH4ed8gtHgwRskNgY,647
-velocity/aws/amplify.py,sha256=3W0o1eOzypLzzMezPRlGISyoGtc-anbMs9p9nVphHGc,15047
+velocity/aws/amplify.py,sha256=n6ttzHmbF8tc0ZDN8LIA6s_fnkZ3ylu3AAUAYyD9MzE,15048
 velocity/aws/handlers/__init__.py,sha256=xnpFZJVlC2uoeeFW4zuPST8wA8ajaQDky5Y6iXZzi3A,172
 velocity/aws/handlers/context.py,sha256=UIjNR83y2NSIyK8HMPX8t5tpJHFNabiZvNgmmdQL3HA,1822
 velocity/aws/handlers/lambda_handler.py,sha256=0KrT6UIxDILzBRpoRSvwDgHpQ-vWfubcZFOCbJsewDc,6516
 velocity/aws/handlers/response.py,sha256=LXhtizLKnVBWjtHyE0h0bk-NYDrRpj7CHa7tRz9KkC4,9324
 velocity/aws/handlers/sqs_handler.py,sha256=nqt8NMOc5yO-L6CZo7NjgR8Q4KPKTDFBO-0eHu6oxkY,7149
-velocity/db/__init__.py,sha256=Xr-kN98AKgjDic1Lxi0yLiobsEpN5a6ZjDMS8KHSTlE,301
+velocity/db/__init__.py,sha256=t7YJT42U19Vkd4MMz5MhU8IFryKfblNPLJcPqzpb4HQ,566
 velocity/db/exceptions.py,sha256=oTXzdxP0GrraGrqRD1JgIVP5urO5yNN7A3IzTiAtNJ0,2173
+velocity/db/utils.py,sha256=3uUTLjMUC6g18bn7jRGBajYlXNFlBDZkGxIwQSBK_Y8,7298
 velocity/db/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/core/column.py,sha256=tAr8tL3a2nyaYpNHhGl508FrY_pGZTzyYgjAV5CEBv4,4092
 velocity/db/core/database.py,sha256=3zNGItklu9tZCKsbx2T2vCcU1so8AL9PPL0DLjvaz6s,3554
 velocity/db/core/decorators.py,sha256=76Jkr9XptXt8cvcgp1zbHfuL8uHzWy8lwfR29u-DVu4,4574
-velocity/db/core/engine.py,sha256=uF0XC_kVTNQ2LdX1xaUPSCYYtGHyGSZ-qmhRtSQvSO8,49187
+velocity/db/core/engine.py,sha256=iLQSr9hvn4w78EGiCbS2WsiojQgPYRBW_EGjTS2074g,49225
 velocity/db/core/exceptions.py,sha256=tuDniRqTX8Opc2d033LPJOI3Ux4NSwUcHqW729n-HXA,1027
-velocity/db/core/result.py,sha256=OVqoMwlx3CHNNwr-JGWRx5I8u_YX6hlUpecx99UT5nE,6164
-velocity/db/core/row.py,sha256=aliLYTTFirgJsOvmUsANwJMyxaATuhpGpFJhcu_twwY,6709
+velocity/db/core/result.py,sha256=q5YvOP8_ozDdWJxLfFkGyEvF_ZqSn-WqI0qO5UgVBa4,12393
+velocity/db/core/row.py,sha256=zZ3zZbWjZkZfYAYuZJLHFJ8jdXc7dYv8Iyv9Ut8W8tE,7261
 velocity/db/core/sequence.py,sha256=VMBc0ZjGnOaWTwKW6xMNTdP8rZ2umQ8ml4fHTTwuGq4,3904
-velocity/db/core/table.py,sha256=g2mq7_VzLBtxITAn47BbgMcUoJAy9XVP6ohzScNl_so,34573
+velocity/db/core/table.py,sha256=yUZVKrQXgHBMWY5Mf-XmwgaNhW-HHqfg57PpUW_RXHQ,34586
 velocity/db/core/transaction.py,sha256=unjmVkkfb7D8Wow6V8V8aLaxUZo316i--ksZxc4-I1Q,6613
 velocity/db/servers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/db/servers/mysql.py,sha256=qHwlB_Mg02R7QFjD5QvJCorYYiP50CqEiQyZVl3uYns,20914
@@ -48,8 +49,8 @@ velocity/misc/tools.py,sha256=_bGneHHA_BV-kUonzw5H3hdJ5AOJRCKfzhgpkFbGqIo,1502
 velocity/misc/conv/__init__.py,sha256=MLYF58QHjzfDSxb1rdnmLnuEQCa3gnhzzZ30CwZVvQo,40
 velocity/misc/conv/iconv.py,sha256=d4_BucW8HTIkGNurJ7GWrtuptqUf-9t79ObzjJ5N76U,10603
 velocity/misc/conv/oconv.py,sha256=h5Lo05DqOQnxoD3y6Px_MQP_V-pBbWf8Hkgkb9Xp1jk,6032
-velocity_python-0.0.103.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.0.103.dist-info/METADATA,sha256=9FYOm2SrGrV7CJloPGfUn8upxC3zNSst9bFUXwVOEng,33023
-velocity_python-0.0.103.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-velocity_python-0.0.103.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.0.103.dist-info/RECORD,,
+velocity_python-0.0.105.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.0.105.dist-info/METADATA,sha256=TEKdozOuF6TjYw8yBGI57YZpr_bvGWAufFkdcRscBlI,34262
+velocity_python-0.0.105.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+velocity_python-0.0.105.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.0.105.dist-info/RECORD,,