Add robust error handling for malformed Pocket data

- Add try-catch blocks around item and author processing
- Skip malformed author data (e.g. non-numeric author_id values)
- Continue processing even when individual items have errors
- Add silent parameter to suppress error warnings when needed
- Add comprehensive test coverage for:
  * Malformed author data (non-numeric IDs)
  * Mixed valid/invalid author data
  * Items with processing errors

Fixes crash when Pocket API returns malformed author data like
'author_id': 'Sandra E. Garcia' instead of numeric values.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: digithree

pocket_to_sqlite/cli.py

@@ -104,9 +104,9 @@ def fetch(db_path, auth, all, silent, debug):
     if (all or last_since is None) and not silent:
         total_items = utils.fetch_stats(auth)["count_list"]
         with click.progressbar(fetch, length=total_items, show_pos=True) as bar:
-            utils.save_items(bar, db)
+            utils.save_items(bar, db, silent=silent)
     else:
         # No progress bar
         print("Fetching items since {}".format(last_since))
-        utils.save_items(fetch, db)
+        utils.save_items(fetch, db, silent=silent)
     utils.ensure_fts(db)

pocket_to_sqlite/utils.py

@@ -6,39 +6,62 @@
 from sqlite_utils.db import AlterError, ForeignKey
 
 
-def save_items(items, db):
+def save_items(items, db, silent=False):
     count = 0
     for item in items:
         count += 1
-        logging.debug(f"Processing item {count}: {item.get('item_id', 'unknown')}")
-        transform(item)
-        authors = item.pop("authors", None)
-        items_authors_to_save = []
-        if authors:
-            authors_to_save = []
-            for details in authors.values():
-                authors_to_save.append(
-                    {
-                        "author_id": int(details["author_id"]),
-                        "name": details["name"],
-                        "url": details["url"],
-                    }
-                )
-                items_authors_to_save.append(
-                    {
-                        "author_id": int(details["author_id"]),
-                        "item_id": int(details["item_id"]),
-                    }
+        item_id = item.get('item_id', 'unknown')
+        logging.debug(f"Processing item {count}: {item_id}")
+        
+        try:
+            transform(item)
+            authors = item.pop("authors", None)
+            items_authors_to_save = []
+            if authors:
+                authors_to_save = []
+                for details in authors.values():
+                    try:
+                        # Safely convert author_id to int, skip if invalid
+                        author_id = int(details["author_id"])
+                        item_id_int = int(details["item_id"])
+                        
+                        authors_to_save.append(
+                            {
+                                "author_id": author_id,
+                                "name": details["name"],
+                                "url": details["url"],
+                            }
+                        )
+                        items_authors_to_save.append(
+                            {
+                                "author_id": author_id,
+                                "item_id": item_id_int,
+                            }
+                        )
+                    except (ValueError, KeyError) as e:
+                        # Skip malformed author data
+                        if not silent:
+                            print(f"Warning: Skipping malformed author data for item {item_id}: {e}")
+                        logging.warning(f"Skipping malformed author data for item {item_id}: {e}")
+                        continue
+                
+                if authors_to_save:
+                    db["authors"].insert_all(authors_to_save, pk="author_id", replace=True)
+            
+            db["items"].insert(item, pk="item_id", alter=True, replace=True)
+            if items_authors_to_save:
+                db["items_authors"].insert_all(
+                    items_authors_to_save,
+                    pk=("author_id", "item_id"),
+                    foreign_keys=("author_id", "item_id"),
+                    replace=True,
                 )
-            db["authors"].insert_all(authors_to_save, pk="author_id", replace=True)
-        db["items"].insert(item, pk="item_id", alter=True, replace=True)
-        if items_authors_to_save:
-            db["items_authors"].insert_all(
-                items_authors_to_save,
-                pk=("author_id", "item_id"),
-                foreign_keys=("author_id", "item_id"),
-                replace=True,
-            )
+        except Exception as e:
+            # Skip entire item if there's any other error
+            if not silent:
+                print(f"Warning: Skipping item {item_id} due to error: {e}")
+            logging.error(f"Skipping item {item_id} due to error: {e}")
+            continue
 
 
 def transform(item):

tests/test_save_pocket.py

@@ -14,7 +14,7 @@ def load():
 @pytest.fixture(scope="session")
 def converted():
     db = sqlite_utils.Database(":memory:")
-    utils.save_items(load(), db)
+    utils.save_items(load(), db, silent=True)
     utils.ensure_fts(db)
     return db
 
@@ -220,6 +220,84 @@ def test_fetch_items_handles_error_none_success():
         assert items[0]["item_id"] == "1"
 
 
+def test_save_items_handles_malformed_author_data():
+    """Test that save_items handles malformed author data gracefully."""
+    db = sqlite_utils.Database(":memory:")
+    
+    # Create item with malformed author data
+    malformed_item = {
+        "item_id": "123",
+        "title": "Test Item",
+        "authors": {
+            "1": {
+                "author_id": "Sandra E. Garcia",  # Invalid - should be numeric
+                "name": "Sandra Garcia",
+                "url": "http://example.com",
+                "item_id": "123"
+            }
+        }
+    }
+    
+    # Should not crash, just skip the malformed author
+    utils.save_items([malformed_item], db, silent=True)
+    
+    # Item should be saved but no authors
+    assert "items" in db.table_names()
+    assert db["items"].count == 1
+    assert "authors" not in db.table_names()  # No valid authors to save
+
+
+def test_save_items_handles_mixed_author_data():
+    """Test that save_items handles mix of valid and invalid author data."""
+    db = sqlite_utils.Database(":memory:")
+    
+    # Create item with mixed author data
+    mixed_item = {
+        "item_id": "123",
+        "title": "Test Item",
+        "authors": {
+            "1": {
+                "author_id": "Sandra E. Garcia",  # Invalid
+                "name": "Sandra Garcia", 
+                "url": "http://example.com",
+                "item_id": "123"
+            },
+            "2": {
+                "author_id": "456",  # Valid
+                "name": "John Doe",
+                "url": "http://example2.com", 
+                "item_id": "123"
+            }
+        }
+    }
+    
+    # Should save item and valid author, skip invalid author
+    utils.save_items([mixed_item], db, silent=True)
+    
+    # Should have item and one valid author
+    assert db["items"].count == 1
+    assert db["authors"].count == 1
+    assert list(db["authors"].rows)[0]["author_id"] == 456
+
+
+def test_save_items_handles_completely_malformed_item():
+    """Test that save_items handles items missing required fields."""
+    db = sqlite_utils.Database(":memory:")
+    
+    # Create item missing item_id (will cause issues in transform)
+    malformed_item = {"title": "No ID Item", "time_added": "not_a_number"}
+    valid_item = {"item_id": "123", "title": "Valid Item"}
+    
+    # Should handle errors gracefully and continue processing
+    utils.save_items([malformed_item, valid_item], db, silent=True)
+    
+    # Both items may be saved, but the valid one should definitely be there
+    assert db["items"].count >= 1
+    # Check that the valid item was saved correctly
+    valid_items = [row for row in db["items"].rows if row.get("item_id") == 123]
+    assert len(valid_items) == 1
+
+
 def test_ensure_fts_with_no_items_table():
     """Test that ensure_fts handles case when items table doesn't exist."""
     db = sqlite_utils.Database(":memory:")