objbase 0.5.0__tar.gz → 0.5.1__tar.gz

{objbase-0.5.0 → objbase-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: objbase
-Version: 0.5.0
+Version: 0.5.1
 Summary: Damn simple object store for Python dicts and Pydantic models across multiple backends
 Project-URL: Homepage, https://github.com/fm-labs/objbase
 Project-URL: Issues, https://github.com/fm-labs/objbase/issues
@@ -41,7 +41,7 @@ __No thrills__ - **just a simple key-value store for serializable Python objects
 
 ## What you get
 
-- Basic CRUD operations: `save`, `get`, `filter`, `keys`, `patch`, `delete`
+- Basic CRUD operations: `save`, `get`, `items`, `keys`, `patch`, `delete`
 - Multiple storage adapters (in-memory, file-based, SQLite, Redis, MongoDB)
 - Optional Pydantic model validation with `PydanticCollection` / `AsyncPydanticCollection`
 - Async support via `AsyncCollection` with async storage adapters (in-memory, file-based, SQLite, Redis, MongoDB)
@@ -97,12 +97,12 @@ or from their submodules as in the examples below:
 | Module | Contents |
 |---|---|
 | `objbase.interface` | `Storage`, `AsyncStorage` protocols and the `Item` type |
-| `objbase.inventory` | `Collection` |
+| `objbase.collection` | `Collection` |
 | `objbase.errors` | `CollectionError`, `ItemNotFoundError` |
 | `objbase.pydantic` | `PydanticCollection`, `AsyncPydanticCollection` (needs `objbase[pydantic]`) |
-| `objbase.storage.{inmemory,file,sqlite,redis,mongodb}_storage` | Sync storage adapters |
-| `objbase.asyncio.inventory` | `AsyncCollection` |
-| `objbase.asyncio.storage.{file,sqlite,redis,mongodb}_storage` | Async storage adapters |
+| `objbase.storage.{inmemory,local,sqlite,redis,mongodb}` | Sync storage adapters |
+| `objbase.asyncio.collection` | `AsyncCollection` |
+| `objbase.asyncio.storage.{local,sqlite,redis,mongodb}` | Async storage adapters |
 
 `import objbase` works without Pydantic installed; `PydanticCollection` and
 `AsyncPydanticCollection` are loaded on first access.
@@ -111,7 +111,7 @@ or from their submodules as in the examples below:
 
 All adapters follow the same contract (verified by a shared test suite):
 
-- `get` returns `None` for a missing item; `filter` and `keys` return `[]` for an empty type.
+- `get` returns `None` for a missing item; `items` and `keys` return `[]` for an empty type.
 - `save` inserts a new item or **replaces** an existing one entirely (it does not merge fields).
 - `patch` merges the given fields into an existing item. It cannot change the item's `id`.
 - `delete` returns `True` if the item was removed, `False` if it did not exist.
@@ -123,7 +123,7 @@ Errors are raised, not returned:
 |---|---|
 | `save` an item without an `id` (or with an empty one) | `ValueError` |
 | `patch` with data that changes the item's `id` | `ValueError` |
-| `patch` a missing item | `objbase.ItemNotFoundError` (an `CollectionError` and a `LookupError`) |
+| `patch` a missing item | `objbase.ItemNotFoundError` (a `CollectionError` and a `LookupError`) |
 | The storage backend reports a failed write | `objbase.CollectionError` |
 
 `CollectionError` is the base class of all objbase errors.
@@ -258,9 +258,9 @@ client = redis.Redis(host="localhost", port=6379, decode_responses=True)
 storage = RedisStorage(redis_client=client)
 ```
 
-Each item type is one Redis hash, `inventory:{item_type}`, mapping item ids to
+Each item type is one Redis hash, `collection:{item_type}`, mapping item ids to
 JSON-encoded items, so value types (numbers, booleans, lists, nested dicts) are
-preserved. Pass `key_prefix="myapp:"` to use a different prefix than `inventory:`.
+preserved. Pass `key_prefix="myapp:"` to use a different prefix than `collection:`.
 
 Pass a pre-configured `redis.Redis` client (sync); `decode_responses` may be on or off.
 Requires `redis-py`. `AsyncRedisStorage` takes a `redis.asyncio.Redis` client
@@ -276,10 +276,11 @@ client = pymongo.MongoClient("mongodb://localhost:27017")
 storage = MongoDBStorage(mongo_client=client)
 ```
 
-Items are stored in the `collection.py` database, one collection per `item_type`.
+Items are stored in the `collection` database, one collection per `item_type`.
+Pass `db_name="myapp"` to use a different database.
 The MongoDB `_id` field is stripped from results automatically.
 Pass a pre-configured `pymongo.MongoClient`. Requires `pymongo`. `AsyncMongoDBStorage`
-takes a `pymongo.AsyncMongoClient` and uses the same layout, so sync and async adapters
+takes a `pymongo.AsyncMongoClient` (and the same `db_name` option) and uses the same layout, so sync and async adapters
 can share data. Both accept an optional MongoDB `query` in `items` / `aitems` to filter results.
 
 ---
@@ -314,7 +315,7 @@ if item is not None:
 ```
 
 The model type is inferred from `model_class`, so type checkers know that
-`todos.get()` returns `Todo | None` and `todos.filter()` returns `list[Todo]`.
+`todos.get()` returns `Todo | None` and `todos.items()` returns `list[Todo]`.
 `todos.keys()` returns the item ids (`list[str]`) without loading or validating
 any items.
 
@@ -369,7 +370,7 @@ todos = AsyncCollection(item_type="todo", storage=AsyncRedisStorage(client))
 
 await todos.save({"id": "1", "title": "Buy milk", "done": False})
 await todos.get("1")  # → {"id": "1", "title": "Buy milk", "done": False}
-await todos.filter()  # → [{"id": "1", ...}]
+await todos.items()  # → [{"id": "1", ...}]
 await todos.keys()  # → ["1"]
 await todos.patch("1", {"done": True})  # → {"id": "1", ..., "done": True}
 await todos.delete("1")  # → True
@@ -405,7 +406,7 @@ uv run python examples/async_sqlite_example.py
 ```
 
 The file-based and SQLite examples write to `data/` in the current directory
-(ignored by git); set `INVENTORY_DIR` or `SQLITE_DB_PATH` to change that. The MongoDB
+(ignored by git); set `OBJBASE_DATA_DIR` or `SQLITE_DB_PATH` to change that. The MongoDB
 examples need a running server — `docker run --rm -p 27017:27017 mongo:7.0` — and
 connect to `MONGODB_URI` (default `mongodb://localhost:27017`).
 
@@ -453,7 +454,7 @@ def get_todos(request: Request) -> AsyncCollection:
 
 @app.get("/todos")
 async def list_todos(todos: AsyncCollection = Depends(get_todos)):
-    return await todos.filter()
+    return await todos.items()
 
 
 @app.get("/todos/{todo_id}")

{objbase-0.5.0 → objbase-0.5.1}/README.md

@@ -9,7 +9,7 @@ __No thrills__ - **just a simple key-value store for serializable Python objects
 
 ## What you get
 
-- Basic CRUD operations: `save`, `get`, `filter`, `keys`, `patch`, `delete`
+- Basic CRUD operations: `save`, `get`, `items`, `keys`, `patch`, `delete`
 - Multiple storage adapters (in-memory, file-based, SQLite, Redis, MongoDB)
 - Optional Pydantic model validation with `PydanticCollection` / `AsyncPydanticCollection`
 - Async support via `AsyncCollection` with async storage adapters (in-memory, file-based, SQLite, Redis, MongoDB)
@@ -65,12 +65,12 @@ or from their submodules as in the examples below:
 | Module | Contents |
 |---|---|
 | `objbase.interface` | `Storage`, `AsyncStorage` protocols and the `Item` type |
-| `objbase.inventory` | `Collection` |
+| `objbase.collection` | `Collection` |
 | `objbase.errors` | `CollectionError`, `ItemNotFoundError` |
 | `objbase.pydantic` | `PydanticCollection`, `AsyncPydanticCollection` (needs `objbase[pydantic]`) |
-| `objbase.storage.{inmemory,file,sqlite,redis,mongodb}_storage` | Sync storage adapters |
-| `objbase.asyncio.inventory` | `AsyncCollection` |
-| `objbase.asyncio.storage.{file,sqlite,redis,mongodb}_storage` | Async storage adapters |
+| `objbase.storage.{inmemory,local,sqlite,redis,mongodb}` | Sync storage adapters |
+| `objbase.asyncio.collection` | `AsyncCollection` |
+| `objbase.asyncio.storage.{local,sqlite,redis,mongodb}` | Async storage adapters |
 
 `import objbase` works without Pydantic installed; `PydanticCollection` and
 `AsyncPydanticCollection` are loaded on first access.
@@ -79,7 +79,7 @@ or from their submodules as in the examples below:
 
 All adapters follow the same contract (verified by a shared test suite):
 
-- `get` returns `None` for a missing item; `filter` and `keys` return `[]` for an empty type.
+- `get` returns `None` for a missing item; `items` and `keys` return `[]` for an empty type.
 - `save` inserts a new item or **replaces** an existing one entirely (it does not merge fields).
 - `patch` merges the given fields into an existing item. It cannot change the item's `id`.
 - `delete` returns `True` if the item was removed, `False` if it did not exist.
@@ -91,7 +91,7 @@ Errors are raised, not returned:
 |---|---|
 | `save` an item without an `id` (or with an empty one) | `ValueError` |
 | `patch` with data that changes the item's `id` | `ValueError` |
-| `patch` a missing item | `objbase.ItemNotFoundError` (an `CollectionError` and a `LookupError`) |
+| `patch` a missing item | `objbase.ItemNotFoundError` (a `CollectionError` and a `LookupError`) |
 | The storage backend reports a failed write | `objbase.CollectionError` |
 
 `CollectionError` is the base class of all objbase errors.
@@ -226,9 +226,9 @@ client = redis.Redis(host="localhost", port=6379, decode_responses=True)
 storage = RedisStorage(redis_client=client)
 ```
 
-Each item type is one Redis hash, `inventory:{item_type}`, mapping item ids to
+Each item type is one Redis hash, `collection:{item_type}`, mapping item ids to
 JSON-encoded items, so value types (numbers, booleans, lists, nested dicts) are
-preserved. Pass `key_prefix="myapp:"` to use a different prefix than `inventory:`.
+preserved. Pass `key_prefix="myapp:"` to use a different prefix than `collection:`.
 
 Pass a pre-configured `redis.Redis` client (sync); `decode_responses` may be on or off.
 Requires `redis-py`. `AsyncRedisStorage` takes a `redis.asyncio.Redis` client
@@ -244,10 +244,11 @@ client = pymongo.MongoClient("mongodb://localhost:27017")
 storage = MongoDBStorage(mongo_client=client)
 ```
 
-Items are stored in the `collection.py` database, one collection per `item_type`.
+Items are stored in the `collection` database, one collection per `item_type`.
+Pass `db_name="myapp"` to use a different database.
 The MongoDB `_id` field is stripped from results automatically.
 Pass a pre-configured `pymongo.MongoClient`. Requires `pymongo`. `AsyncMongoDBStorage`
-takes a `pymongo.AsyncMongoClient` and uses the same layout, so sync and async adapters
+takes a `pymongo.AsyncMongoClient` (and the same `db_name` option) and uses the same layout, so sync and async adapters
 can share data. Both accept an optional MongoDB `query` in `items` / `aitems` to filter results.
 
 ---
@@ -282,7 +283,7 @@ if item is not None:
 ```
 
 The model type is inferred from `model_class`, so type checkers know that
-`todos.get()` returns `Todo | None` and `todos.filter()` returns `list[Todo]`.
+`todos.get()` returns `Todo | None` and `todos.items()` returns `list[Todo]`.
 `todos.keys()` returns the item ids (`list[str]`) without loading or validating
 any items.
 
@@ -337,7 +338,7 @@ todos = AsyncCollection(item_type="todo", storage=AsyncRedisStorage(client))
 
 await todos.save({"id": "1", "title": "Buy milk", "done": False})
 await todos.get("1")  # → {"id": "1", "title": "Buy milk", "done": False}
-await todos.filter()  # → [{"id": "1", ...}]
+await todos.items()  # → [{"id": "1", ...}]
 await todos.keys()  # → ["1"]
 await todos.patch("1", {"done": True})  # → {"id": "1", ..., "done": True}
 await todos.delete("1")  # → True
@@ -373,7 +374,7 @@ uv run python examples/async_sqlite_example.py
 ```
 
 The file-based and SQLite examples write to `data/` in the current directory
-(ignored by git); set `INVENTORY_DIR` or `SQLITE_DB_PATH` to change that. The MongoDB
+(ignored by git); set `OBJBASE_DATA_DIR` or `SQLITE_DB_PATH` to change that. The MongoDB
 examples need a running server — `docker run --rm -p 27017:27017 mongo:7.0` — and
 connect to `MONGODB_URI` (default `mongodb://localhost:27017`).
 
@@ -421,7 +422,7 @@ def get_todos(request: Request) -> AsyncCollection:
 
 @app.get("/todos")
 async def list_todos(todos: AsyncCollection = Depends(get_todos)):
-    return await todos.filter()
+    return await todos.items()
 
 
 @app.get("/todos/{todo_id}")

{objbase-0.5.0 → objbase-0.5.1}/examples/async_directory_example.py

@@ -1,5 +1,5 @@
 # Async to-do list stored in one JSON file per item ({base_dir}/todo/{id}.json). No extra dependencies needed.
-# Set INVENTORY_DIR to use a different directory.
+# Set OBJBASE_DATA_DIR to use a different directory.
 import asyncio
 import os
 
@@ -8,28 +8,28 @@ from objbase.asyncio.storage.local import AsyncLocalDirectoryStorage
 
 
 async def main() -> None:
-    base_dir = os.getenv("INVENTORY_DIR", "data")
+    base_dir = os.getenv("OBJBASE_DATA_DIR", "data")
     os.makedirs(base_dir, exist_ok=True)  # the base directory must exist
     storage = AsyncLocalDirectoryStorage(base_dir=base_dir)
-    todos_inventory = AsyncCollection(item_type="todo", storage=storage)
+    todos_collection = AsyncCollection(item_type="todo", storage=storage)
 
     # Create some to-do items concurrently; the adapter's file locks keep the index consistent
     await asyncio.gather(
-        todos_inventory.save({"id": "1", "name": "Buy groceries", "status": "pending"}),
-        todos_inventory.save({"id": "2", "name": "Walk the dog", "status": "pending"}),
+        todos_collection.save({"id": "1", "name": "Buy groceries", "status": "pending"}),
+        todos_collection.save({"id": "2", "name": "Walk the dog", "status": "pending"}),
     )
-    print("To-do ids:", sorted(await todos_inventory.keys()))
+    print("To-do ids:", sorted(await todos_collection.keys()))
 
     # Update a to-do item
-    updated_todo = await todos_inventory.patch("1", {"status": "completed"})
+    updated_todo = await todos_collection.patch("1", {"status": "completed"})
     print("Updated To-do:", updated_todo)
 
     # Rebuild the index, e.g. after item files were added or removed by hand
     await storage.arebuild_index("todo")
 
     # Delete the to-do items
-    for todo_id in await todos_inventory.keys():
-        print(f"Deleted To-do {todo_id}:", await todos_inventory.delete(todo_id))
+    for todo_id in await todos_collection.keys():
+        print(f"Deleted To-do {todo_id}:", await todos_collection.delete(todo_id))
 
 
 asyncio.run(main())

{objbase-0.5.0 → objbase-0.5.1}/examples/async_example.py

@@ -6,22 +6,22 @@ from objbase.storage.inmemory import InMemoryStorage
 
 async def main():
     # Replace with AsyncRedisStorage(redis.asyncio.Redis(...)) for real persistence
-    todos_inventory = AsyncCollection(item_type="todo", storage=InMemoryStorage())
+    todos_collection = AsyncCollection(item_type="todo", storage=InMemoryStorage())
 
     # Create a new to-do item
-    created_todo = await todos_inventory.save({"id": "1", "name": "Buy groceries", "status": "pending"})
+    created_todo = await todos_collection.save({"id": "1", "name": "Buy groceries", "status": "pending"})
     print("Created To-do:", created_todo)
 
     # Read the to-do item
-    fetched_todo = await todos_inventory.get("1")
+    fetched_todo = await todos_collection.get("1")
     print("Fetched To-do:", fetched_todo)
 
     # Update the to-do item
-    updated_todo = await todos_inventory.patch("1", {"status": "completed"})
+    updated_todo = await todos_collection.patch("1", {"status": "completed"})
     print("Updated To-do:", updated_todo)
 
     # Delete the to-do item
-    delete_result = await todos_inventory.delete("1")
+    delete_result = await todos_collection.delete("1")
     print("Deleted To-do:", delete_result)
 
 

objbase-0.5.1/examples/async_file_example.py

@@ -0,0 +1,30 @@
+# Async to-do list stored in one JSON file per item type ({base_dir}/todo.json). No extra dependencies needed.
+# Set OBJBASE_DATA_DIR to use a different directory.
+import asyncio
+import os
+
+from objbase.asyncio.collection import AsyncCollection
+from objbase.asyncio.storage.local import AsyncLocalFileStorage
+
+
+async def main() -> None:
+    base_dir = os.getenv("OBJBASE_DATA_DIR", "data")
+    os.makedirs(base_dir, exist_ok=True)  # the base directory must exist
+    storage = AsyncLocalFileStorage(base_dir=base_dir)
+    todos_collection = AsyncCollection(item_type="todo", storage=storage)
+
+    # Create some to-do items
+    await todos_collection.save({"id": "1", "name": "Buy groceries", "status": "pending"})
+    await todos_collection.save({"id": "2", "name": "Walk the dog", "status": "pending"})
+    print("All To-dos:", await todos_collection.items())
+
+    # Update a to-do item
+    updated_todo = await todos_collection.patch("1", {"status": "completed"})
+    print("Updated To-do:", updated_todo)
+
+    # Delete the to-do items
+    for todo_id in await todos_collection.keys():
+        print(f"Deleted To-do {todo_id}:", await todos_collection.delete(todo_id))
+
+
+asyncio.run(main())

{objbase-0.5.0 → objbase-0.5.1}/examples/async_mongodb_example.py

@@ -15,23 +15,23 @@ async def main() -> None:
         os.getenv("MONGODB_URI", "mongodb://localhost:27017")
     )
     storage = AsyncMongoDBStorage(mongo_client=client)
-    todos_inventory = AsyncCollection(item_type="todo", storage=storage)
+    todos_collection = AsyncCollection(item_type="todo", storage=storage)
 
     # Create some to-do items
-    await todos_inventory.save({"id": "1", "name": "Buy groceries", "status": "pending"})
-    await todos_inventory.save({"id": "2", "name": "Walk the dog", "status": "pending"})
-    print("All To-dos:", await todos_inventory.filter())
+    await todos_collection.save({"id": "1", "name": "Buy groceries", "status": "pending"})
+    await todos_collection.save({"id": "2", "name": "Walk the dog", "status": "pending"})
+    print("All To-dos:", await todos_collection.items())
 
     # Update a to-do item
-    updated_todo = await todos_inventory.patch("1", {"status": "completed"})
+    updated_todo = await todos_collection.patch("1", {"status": "completed"})
     print("Updated To-do:", updated_todo)
 
     # Filter with a MongoDB query (a MongoDB-only extension of the storage adapter)
     print("Pending To-dos:", await storage.aitems("todo", query={"status": "pending"}))
 
     # Delete the to-do items
-    for todo_id in await todos_inventory.keys():
-        print(f"Deleted To-do {todo_id}:", await todos_inventory.delete(todo_id))
+    for todo_id in await todos_collection.keys():
+        print(f"Deleted To-do {todo_id}:", await todos_collection.delete(todo_id))
 
     await client.close()
 

{objbase-0.5.0 → objbase-0.5.1}/examples/async_pydantic_example.py

@@ -14,30 +14,30 @@ class Todo(pydantic.BaseModel):
 
 async def main() -> None:
     # Replace with AsyncRedisStorage(redis.asyncio.Redis(...)) for real persistence
-    todos_inventory = AsyncPydanticCollection(item_type="todos", storage=InMemoryStorage(), model_class=Todo)
+    todos_collection = AsyncPydanticCollection(item_type="todos", storage=InMemoryStorage(), model_class=Todo)
 
     # Create a new to-do item
-    created_todo = await todos_inventory.save(Todo(id="1", title="Buy milk"))
+    created_todo = await todos_collection.save(Todo(id="1", title="Buy milk"))
     print("Created To-do:", created_todo)
 
     # Read the to-do item
-    fetched_todo = await todos_inventory.get("1")
+    fetched_todo = await todos_collection.get("1")
     print("Fetched To-do:", fetched_todo)
     assert fetched_todo is not None  # get() returns None for a missing id
 
     # Update the to-do item
     fetched_todo.completed = True
-    updated_todo = await todos_inventory.patch("1", fetched_todo)
+    updated_todo = await todos_collection.patch("1", fetched_todo)
     print("Updated To-do:", updated_todo)
 
     # Invalid data is rejected and never stored
     try:
-        await todos_inventory.patch("1", {"completed": "not a bool"})
+        await todos_collection.patch("1", {"completed": "not a bool"})
     except pydantic.ValidationError:
-        print("Rejected invalid patch; stored item unchanged:", await todos_inventory.get("1"))
+        print("Rejected invalid patch; stored item unchanged:", await todos_collection.get("1"))
 
     # Delete the to-do item
-    delete_result = await todos_inventory.delete("1")
+    delete_result = await todos_collection.delete("1")
     print("Deleted To-do:", delete_result)
 
 

{objbase-0.5.0 → objbase-0.5.1}/examples/async_sqlite_example.py

@@ -11,20 +11,20 @@ async def main() -> None:
     db_path = os.getenv("SQLITE_DB_PATH", os.path.join("data", "todos.db"))
     os.makedirs(os.path.dirname(db_path) or ".", exist_ok=True)  # sqlite3 doesn't create missing directories
     storage = AsyncSQLiteStorage(db_path=db_path)
-    todos_inventory = AsyncCollection(item_type="todo", storage=storage)
+    todos_collection = AsyncCollection(item_type="todo", storage=storage)
 
     # Create some to-do items
-    await todos_inventory.save({"id": "1", "name": "Buy groceries", "status": "pending"})
-    await todos_inventory.save({"id": "2", "name": "Walk the dog", "status": "pending"})
-    print("All To-dos:", await todos_inventory.filter())
+    await todos_collection.save({"id": "1", "name": "Buy groceries", "status": "pending"})
+    await todos_collection.save({"id": "2", "name": "Walk the dog", "status": "pending"})
+    print("All To-dos:", await todos_collection.items())
 
     # Update a to-do item
-    updated_todo = await todos_inventory.patch("1", {"status": "completed"})
+    updated_todo = await todos_collection.patch("1", {"status": "completed"})
     print("Updated To-do:", updated_todo)
 
     # Delete the to-do items
-    for todo_id in await todos_inventory.keys():
-        print(f"Deleted To-do {todo_id}:", await todos_inventory.delete(todo_id))
+    for todo_id in await todos_collection.keys():
+        print(f"Deleted To-do {todo_id}:", await todos_collection.delete(todo_id))
 
 
 asyncio.run(main())

{objbase-0.5.0 → objbase-0.5.1}/examples/dict_example.py

@@ -3,21 +3,21 @@ from objbase.collection import Collection
 from objbase.storage.inmemory import InMemoryStorage
 
 # Replace with actual storage instance
-todos_inventory = Collection(item_type="todo", storage=InMemoryStorage())
+todos_collection = Collection(item_type="todo", storage=InMemoryStorage())
 
 # Create a new to-do item
 new_todo = {"id": "1", "name": "Buy groceries", "status": "pending"}
-created_todo = todos_inventory.save(new_todo)
+created_todo = todos_collection.save(new_todo)
 print("Created To-do:", created_todo)
 
 # Read the to-do item
-fetched_todo = todos_inventory.get("1")
+fetched_todo = todos_collection.get("1")
 print("Fetched To-do:", fetched_todo)
 
 # Update the to-do item
-updated_todo = todos_inventory.patch("1", {"status": "completed"})
+updated_todo = todos_collection.patch("1", {"status": "completed"})
 print("Updated To-do:", updated_todo)
 
 # Delete the to-do item
-delete_result = todos_inventory.delete("1")
+delete_result = todos_collection.delete("1")
 print("Deleted To-do:", delete_result)

{objbase-0.5.0 → objbase-0.5.1}/examples/mongodb_example.py

@@ -10,22 +10,22 @@ from objbase.storage.mongodb import MongoDBStorage
 
 client: pymongo.MongoClient[Item] = pymongo.MongoClient(os.getenv("MONGODB_URI", "mongodb://localhost:27017"))
 storage = MongoDBStorage(mongo_client=client)
-todos_inventory = Collection(item_type="todo", storage=storage)
+todos_collection = Collection(item_type="todo", storage=storage)
 
 # Create some to-do items
-todos_inventory.save({"id": "1", "name": "Buy groceries", "status": "pending"})
-todos_inventory.save({"id": "2", "name": "Walk the dog", "status": "pending"})
-print("All To-dos:", todos_inventory.items())
+todos_collection.save({"id": "1", "name": "Buy groceries", "status": "pending"})
+todos_collection.save({"id": "2", "name": "Walk the dog", "status": "pending"})
+print("All To-dos:", todos_collection.items())
 
 # Update a to-do item
-updated_todo = todos_inventory.patch("1", {"status": "completed"})
+updated_todo = todos_collection.patch("1", {"status": "completed"})
 print("Updated To-do:", updated_todo)
 
 # Filter with a MongoDB query (a MongoDB-only extension of the storage adapter)
 print("Pending To-dos:", storage.items("todo", query={"status": "pending"}))
 
 # Delete the to-do items
-for todo_id in todos_inventory.keys():
-    print(f"Deleted To-do {todo_id}:", todos_inventory.delete(todo_id))
+for todo_id in todos_collection.keys():
+    print(f"Deleted To-do {todo_id}:", todos_collection.delete(todo_id))
 
 client.close()

{objbase-0.5.0 → objbase-0.5.1}/examples/pydantic_example.py

@@ -11,22 +11,22 @@ class Todo(pydantic.BaseModel):
 
 
 model_storage = InMemoryStorage()
-todos_inventory = PydanticCollection(item_type="todos", model_class=Todo, storage=model_storage)
+todos_collection = PydanticCollection(item_type="todos", model_class=Todo, storage=model_storage)
 
 # Create a new to-do item
-created_todo = todos_inventory.save(Todo(id="1", title="Buy milk", completed=False))
+created_todo = todos_collection.save(Todo(id="1", title="Buy milk", completed=False))
 print("Created To-do:", created_todo)
 
 # Read the to-do item
-fetched_todo = todos_inventory.get("1")
+fetched_todo = todos_collection.get("1")
 print("Fetched To-do:", fetched_todo)
 assert fetched_todo is not None  # get() returns None for a missing id
 
 # Update the to-do item
 fetched_todo.completed = True
-updated_todo = todos_inventory.patch("1", fetched_todo)
+updated_todo = todos_collection.patch("1", fetched_todo)
 print("Updated To-do:", updated_todo)
 
 # Delete the to-do item
-delete_result = todos_inventory.delete("1")
+delete_result = todos_collection.delete("1")
 print("Deleted To-do:", delete_result)

{objbase-0.5.0 → objbase-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "objbase"
-version = "0.5.0"
+version = "0.5.1"
 description = "Damn simple object store for Python dicts and Pydantic models across multiple backends"
 requires-python = ">=3.13"
 dependencies = []

{objbase-0.5.0 → objbase-0.5.1}/src/objbase/asyncio/collection.py

@@ -20,7 +20,7 @@ class AsyncCollection:
     async def keys(self) -> list[str]:
         return await self.storage.akeys(self.item_type)
 
-    async def filter(self) -> list[Item]:
+    async def items(self) -> list[Item]:
         return await self.storage.aitems(self.item_type)
 
     async def get(self, id: str) -> Item | None:

{objbase-0.5.0 → objbase-0.5.1}/src/objbase/asyncio/storage/local.py

@@ -16,8 +16,8 @@ class AsyncLocalFileStorage(ThreadedAsyncStorage[LocalFileStorage]):
         super().__init__(LocalFileStorage(base_dir))
 
     @property
-    def inventory_dir(self) -> str:
-        return self.sync_storage.inventory_dir
+    def collection_dir(self) -> str:
+        return self.sync_storage.collection_dir
 
 
 class AsyncLocalDirectoryStorage(ThreadedAsyncStorage[LocalDirectoryStorage]):
@@ -32,8 +32,8 @@ class AsyncLocalDirectoryStorage(ThreadedAsyncStorage[LocalDirectoryStorage]):
         super().__init__(LocalDirectoryStorage(base_dir))
 
     @property
-    def inventory_dir(self) -> str:
-        return self.sync_storage.inventory_dir
+    def collection_dir(self) -> str:
+        return self.sync_storage.collection_dir
 
     async def arebuild_index(self, item_type: str) -> None:
         """Async counterpart of ``LocalDirectoryStorage.rebuild_index``."""

{objbase-0.5.0 → objbase-0.5.1}/src/objbase/asyncio/storage/mongodb.py

@@ -2,6 +2,7 @@ from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any
 
 from objbase.interface import AsyncStorage, Item
+from objbase.storage.mongodb import DEFAULT_DB_NAME
 
 if TYPE_CHECKING:
     from pymongo import AsyncMongoClient
@@ -14,11 +15,12 @@ class AsyncMongoDBStorage(AsyncStorage):
     Takes an async client such as ``pymongo.AsyncMongoClient``.
     """
 
-    def __init__(self, mongo_client: "AsyncMongoClient[Item]"):
+    def __init__(self, mongo_client: "AsyncMongoClient[Item]", db_name: str = DEFAULT_DB_NAME):
         self.mongo_client = mongo_client
+        self.db_name = db_name
 
     def get_mongo_collection(self, item_type: str) -> "AsyncCollection[Item]":
-        db = self.mongo_client["inventory"]
+        db = self.mongo_client[self.db_name]
         return db[item_type]
 
     async def akeys(self, item_type: str) -> list[str]:

{objbase-0.5.0 → objbase-0.5.1}/src/objbase/pydantic.py

@@ -48,37 +48,37 @@ class PydanticCollection[M: pydantic.BaseModel]:
 
     def __init__(self, item_type: str, storage: Storage, model_class: type[M]):
         self.model_class = model_class
-        self.inventory = Collection(item_type, storage)
+        self.collection = Collection(item_type, storage)
 
     @property
     def item_type(self) -> str:
-        return self.inventory.item_type
+        return self.collection.item_type
 
     @property
     def storage(self) -> Storage:
-        return self.inventory.storage
+        return self.collection.storage
 
     def keys(self) -> list[str]:
-        return self.inventory.keys()
+        return self.collection.keys()
 
-    def filter(self) -> list[M]:
-        return [self.model_class.model_validate(item) for item in self.inventory.items()]
+    def items(self) -> list[M]:
+        return [self.model_class.model_validate(item) for item in self.collection.items()]
 
     def save(self, model: M) -> M:
-        return self.model_class.model_validate(self.inventory.save(_validated(self.model_class, model)))
+        return self.model_class.model_validate(self.collection.save(_validated(self.model_class, model)))
 
     def get(self, id: str) -> M | None:
-        item = self.inventory.get(id)
+        item = self.collection.get(id)
         if item is None:
             return None
         return self.model_class.model_validate(item)
 
     def patch(self, id: str, data: Item | M) -> M:
-        item = _patched(self.model_class, self.item_type, id, self.inventory.get(id), data)
-        return self.model_class.model_validate(self.inventory.save(item))
+        item = _patched(self.model_class, self.item_type, id, self.collection.get(id), data)
+        return self.model_class.model_validate(self.collection.save(item))
 
     def delete(self, id: str) -> bool:
-        return self.inventory.delete(id)
+        return self.collection.delete(id)
 
 
 class AsyncPydanticCollection[M: pydantic.BaseModel]:
@@ -89,34 +89,34 @@ class AsyncPydanticCollection[M: pydantic.BaseModel]:
 
     def __init__(self, item_type: str, storage: AsyncStorage, model_class: type[M]):
         self.model_class = model_class
-        self.inventory = AsyncCollection(item_type, storage)
+        self.collection = AsyncCollection(item_type, storage)
 
     @property
     def item_type(self) -> str:
-        return self.inventory.item_type
+        return self.collection.item_type
 
     @property
     def storage(self) -> AsyncStorage:
-        return self.inventory.storage
+        return self.collection.storage
 
     async def keys(self) -> list[str]:
-        return await self.inventory.keys()
+        return await self.collection.keys()
 
-    async def filter(self) -> list[M]:
-        return [self.model_class.model_validate(item) for item in await self.inventory.filter()]
+    async def items(self) -> list[M]:
+        return [self.model_class.model_validate(item) for item in await self.collection.items()]
 
     async def save(self, model: M) -> M:
-        return self.model_class.model_validate(await self.inventory.save(_validated(self.model_class, model)))
+        return self.model_class.model_validate(await self.collection.save(_validated(self.model_class, model)))
 
     async def get(self, id: str) -> M | None:
-        item = await self.inventory.get(id)
+        item = await self.collection.get(id)
         if item is None:
             return None
         return self.model_class.model_validate(item)
 
     async def patch(self, id: str, data: Item | M) -> M:
-        item = _patched(self.model_class, self.item_type, id, await self.inventory.get(id), data)
-        return self.model_class.model_validate(await self.inventory.save(item))
+        item = _patched(self.model_class, self.item_type, id, await self.collection.get(id), data)
+        return self.model_class.model_validate(await self.collection.save(item))
 
     async def delete(self, id: str) -> bool:
-        return await self.inventory.delete(id)
+        return await self.collection.delete(id)

{objbase-0.5.0 → objbase-0.5.1}/src/objbase/storage/inmemory.py

@@ -4,7 +4,7 @@ from objbase.interface import AsyncStorage, Item, Storage
 
 
 class InMemoryStorage(Storage, AsyncStorage):
-    """In-memory storage implementation for inventory items.
+    """In-memory storage implementation for collection items.
 
     Items are deep-copied on the way in and out, so callers never share
     mutable state with the store.

{objbase-0.5.0 → objbase-0.5.1}/src/objbase/storage/local.py

@@ -62,7 +62,7 @@ def _contained_path(real_base: str, *parts: str) -> str:
 
 
 class LocalFileStorage(Storage):
-    """Simple file-based storage that saves all items of a given inventory type in a single JSON file.
+    """Simple file-based storage that saves all items of a given collection type in a single JSON file.
 
     Safe for concurrent use by multiple threads and processes on the same machine:
     writes hold an exclusive lock on ``.{item_type}.json.lock`` for the whole
@@ -71,9 +71,9 @@ class LocalFileStorage(Storage):
     """
 
     def __init__(self, base_dir: str):
-        self.inventory_dir = base_dir
-        if not os.path.exists(self.inventory_dir):
-            raise ValueError(f"Base directory {self.inventory_dir} does not exist.")
+        self.collection_dir = base_dir
+        if not os.path.exists(self.collection_dir):
+            raise ValueError(f"Base directory {self.collection_dir} does not exist.")
         self._real_base = os.path.realpath(base_dir)
 
     def keys(self, item_type: str) -> list[str]:
@@ -136,7 +136,7 @@ class LocalFileStorage(Storage):
 
 
 class LocalDirectoryStorage(Storage):
-    """Alternative file-based storage that uses a directory per inventory type and individual files per item.
+    """Alternative file-based storage that uses a directory per collection type and individual files per item.
 
     Each type directory also holds an index file (``.index``) listing the ids of
     all items of that type, one per line, so ``keys()`` doesn't have to scan the
@@ -148,9 +148,9 @@ class LocalDirectoryStorage(Storage):
     INDEX_FILE = ".index"
 
     def __init__(self, base_dir: str):
-        self.inventory_dir = base_dir
-        if not os.path.exists(self.inventory_dir):
-            raise ValueError(f"Base directory {self.inventory_dir} does not exist.")
+        self.collection_dir = base_dir
+        if not os.path.exists(self.collection_dir):
+            raise ValueError(f"Base directory {self.collection_dir} does not exist.")
         self._real_base = os.path.realpath(base_dir)
 
     def _type_dir(self, item_type: str) -> str:

{objbase-0.5.0 → objbase-0.5.1}/src/objbase/storage/mongodb.py

@@ -7,15 +7,21 @@ if TYPE_CHECKING:
     from pymongo import MongoClient
     from pymongo.collection import Collection
 
+DEFAULT_DB_NAME = "objbase"
+
 
 class MongoDBStorage(Storage):
-    """MongoDB-based storage implementation for inventory items."""
+    """MongoDB-based storage implementation for collection items.
+
+    Items are stored in the ``db_name`` database, one MongoDB collection per item type.
+    """
 
-    def __init__(self, mongo_client: "MongoClient[Item]"):
+    def __init__(self, mongo_client: "MongoClient[Item]", db_name: str = DEFAULT_DB_NAME):
         self.mongo_client = mongo_client
+        self.db_name = db_name
 
     def get_mongo_collection(self, item_type: str) -> "Collection[Item]":
-        db = self.mongo_client["inventory"]
+        db = self.mongo_client[self.db_name]
         return db[item_type]
 
     def keys(self, item_type: str) -> list[str]:

{objbase-0.5.0 → objbase-0.5.1}/src/objbase/storage/redis.py

@@ -3,7 +3,7 @@ from typing import Any, Protocol
 
 from objbase.interface import Item, Storage
 
-DEFAULT_KEY_PREFIX = "inventory:"
+DEFAULT_KEY_PREFIX = "objbase:"
 
 
 class RedisHashClient(Protocol):

{objbase-0.5.0 → objbase-0.5.1}/tests/test_async_collection.py

@@ -78,13 +78,13 @@ class TestAsyncCollectionGetFilter:
     async def test_get_missing_returns_none(self, todos):
         assert await todos.get("nope") is None
 
-    async def test_filter_returns_all_items(self, todos):
+    async def test_items_returns_all_items(self, todos):
         await todos.save({"id": "1"})
         await todos.save({"id": "2"})
-        assert sorted(i["id"] for i in await todos.filter()) == ["1", "2"]
+        assert sorted(i["id"] for i in await todos.items()) == ["1", "2"]
 
-    async def test_filter_empty(self, todos):
-        assert await todos.filter() == []
+    async def test_items_empty(self, todos):
+        assert await todos.items() == []
 
 
 class TestAsyncCollectionPatch:
@@ -175,12 +175,12 @@ class TestAsyncPydanticCollection:
         storage.write("todo", {"id": "1", "title": "a", "done": "not a bool"})  # written outside the model
         assert await model_todos.keys() == ["1"]
         with pytest.raises(pydantic.ValidationError):
-            await model_todos.filter()
+            await model_todos.items()
 
-    async def test_filter_returns_models(self, model_todos):
+    async def test_items_returns_models(self, model_todos):
         await model_todos.save(Todo(id="1", title="a"))
         await model_todos.save(Todo(id="2", title="b"))
-        result = await model_todos.filter()
+        result = await model_todos.items()
         assert all(isinstance(t, Todo) for t in result)
         assert sorted(t.id for t in result) == ["1", "2"]
 
@@ -209,7 +209,7 @@ class TestAsyncPydanticCollection:
         with pytest.raises(pydantic.ValidationError):
             await model_todos.patch("1", {"done": "not a bool"})
         assert storage.read("todo", "1") == {"id": "1", "title": "a", "done": False}
-        assert await model_todos.filter() == [Todo(id="1", title="a")]
+        assert await model_todos.items() == [Todo(id="1", title="a")]
 
     async def test_invalid_model_is_not_stored(self, model_todos, storage):
         todo = Todo(id="1", title="a")

{objbase-0.5.0 → objbase-0.5.1}/tests/test_async_file_storage.py

@@ -53,8 +53,8 @@ class TestAsyncFileStorageInit:
         with pytest.raises(ValueError, match="does not exist"):
             async_cls(str(tmp_path / "missing"))
 
-    def test_exposes_inventory_dir(self, storage, base_dir):
-        assert storage.inventory_dir == base_dir
+    def test_exposes_collection_dir(self, storage, base_dir):
+        assert storage.collection_dir == base_dir
 
 
 # ---------------------------------------------------------------------------
@@ -128,7 +128,7 @@ class TestAsyncFileStorageBehaviour:
         assert sorted(await storage.akeys("todo"), key=int) == [str(i) for i in range(30)]
         assert len(await storage.aitems("todo")) == 30
 
-    async def test_works_with_async_inventory(self, storage):
+    async def test_works_with_async_collection(self, storage):
         todos = AsyncCollection(item_type="todo", storage=storage)
         await todos.save({"id": "1", "done": False})
         assert await todos.patch("1", {"done": True}) == {"id": "1", "done": True}

{objbase-0.5.0 → objbase-0.5.1}/tests/test_async_mongodb_storage.py

@@ -8,6 +8,7 @@ import pytest
 from testcontainers.community.mongodb import MongoDbContainer
 
 from objbase.asyncio.storage.mongodb import AsyncMongoDBStorage
+from objbase.storage.mongodb import DEFAULT_DB_NAME
 
 # See tests/test_mongodb_storage.py for why mongo:latest is not used.
 MONGO_IMAGE = os.getenv("OBJBASE_TEST_MONGO_IMAGE", "mongo:7.0")
@@ -26,9 +27,9 @@ def mongo_container():
 
 @pytest.fixture()
 async def mongo_client(mongo_container):
-    """Return an AsyncMongoClient and drop the inventory DB before each test."""
+    """Return an AsyncMongoClient and drop the collection DB before each test."""
     client: pymongo.AsyncMongoClient[dict[str, Any]] = pymongo.AsyncMongoClient(mongo_container.get_connection_url())
-    await client.drop_database("inventory")
+    await client.drop_database(DEFAULT_DB_NAME)
     yield client
     await client.close()
 
@@ -190,3 +191,11 @@ class TestAsyncMongoDBStorageLayout:
 
         MongoDBStorage(mongo_container.get_connection_client()).write("todo", {"id": "1", "n": 1})
         assert await storage.aread("todo", "1") == {"id": "1", "n": 1}
+
+    async def test_custom_db_name_shares_data_with_sync_storage(self, mongo_container, mongo_client):
+        from objbase.storage.mongodb import MongoDBStorage
+
+        await mongo_client.drop_database("myapp")
+        MongoDBStorage(mongo_container.get_connection_client(), db_name="myapp").write("todo", {"id": "1"})
+        assert await AsyncMongoDBStorage(mongo_client, db_name="myapp").aread("todo", "1") == {"id": "1"}
+        assert await AsyncMongoDBStorage(mongo_client).aread("todo", "1") is None

{objbase-0.5.0 → objbase-0.5.1}/tests/test_async_redis_storage.py

@@ -47,7 +47,7 @@ class TestAsyncRedisStorageWrite:
 
     async def test_write_stores_item_in_type_hash(self, storage, redis_client):
         await storage.awrite("todo", {"id": "1", "title": "Buy milk"})
-        assert await redis_client.hexists("inventory:todo", "1")
+        assert await redis_client.hexists("objbase:todo", "1")
 
     async def test_write_stores_all_fields(self, storage):
         item = {"id": "1", "title": "Buy milk", "done": "false"}
@@ -151,7 +151,7 @@ class TestAsyncRedisStorageDelete:
     async def test_delete_removes_item_from_redis(self, storage, redis_client):
         await storage.awrite("todo", {"id": "1"})
         await storage.adelete("todo", "1")
-        assert not await redis_client.hexists("inventory:todo", "1")
+        assert not await redis_client.hexists("objbase:todo", "1")
 
     async def test_delete_item_no_longer_readable(self, storage):
         await storage.awrite("todo", {"id": "1"})

{objbase-0.5.0 → objbase-0.5.1}/tests/test_async_sqlite_storage.py

@@ -139,7 +139,7 @@ class TestAsyncSQLiteStorageBehaviour:
         await asyncio.gather(*(storage.awrite("todo", {"id": str(i)}) for i in range(20)))
         assert sorted(await storage.akeys("todo"), key=int) == [str(i) for i in range(20)]
 
-    async def test_works_with_async_inventory(self, storage):
+    async def test_works_with_async_collection(self, storage):
         todos = AsyncCollection(item_type="todo", storage=storage)
         await todos.save({"id": "1", "done": False})
         assert await todos.patch("1", {"done": True}) == {"id": "1", "done": True}

{objbase-0.5.0 → objbase-0.5.1}/tests/test_collection.py

@@ -76,12 +76,12 @@ class TestCollectionGetFilter:
     def test_get_missing_returns_none(self, todos):
         assert todos.get("nope") is None
 
-    def test_filter_returns_all_items(self, todos):
+    def test_items_returns_all_items(self, todos):
         todos.save({"id": "1"})
         todos.save({"id": "2"})
         assert sorted(i["id"] for i in todos.items()) == ["1", "2"]
 
-    def test_filter_empty(self, todos):
+    def test_items_empty(self, todos):
         assert todos.items() == []
 
 
@@ -178,12 +178,12 @@ class TestPydanticCollection:
         storage.write("todo", {"id": "1", "title": "a", "done": "not a bool"})  # written outside the model
         assert model_todos.keys() == ["1"]
         with pytest.raises(pydantic.ValidationError):
-            model_todos.filter()
+            model_todos.items()
 
-    def test_filter_returns_models(self, model_todos):
+    def test_items_returns_models(self, model_todos):
         model_todos.save(Todo(id="1", title="a"))
         model_todos.save(Todo(id="2", title="b"))
-        result = model_todos.filter()
+        result = model_todos.items()
         assert all(isinstance(t, Todo) for t in result)
         assert sorted(t.id for t in result) == ["1", "2"]
 
@@ -212,7 +212,7 @@ class TestPydanticCollection:
         with pytest.raises(pydantic.ValidationError):
             model_todos.patch("1", {"done": "not a bool"})
         assert storage.read("todo", "1") == {"id": "1", "title": "a", "done": False}
-        assert model_todos.filter() == [Todo(id="1", title="a")]
+        assert model_todos.items() == [Todo(id="1", title="a")]
 
     def test_invalid_model_is_not_stored(self, model_todos, storage):
         todo = Todo(id="1", title="a")

{objbase-0.5.0 → objbase-0.5.1}/tests/test_file_storage.py

@@ -55,7 +55,7 @@ class TestLocalFileStorageInit:
 
     def test_init_succeeds_with_existing_dir(self, base_dir):
         storage = LocalFileStorage(base_dir)
-        assert storage.inventory_dir == base_dir
+        assert storage.collection_dir == base_dir
 
 
 class TestLocalFileStorageSelect:
@@ -162,7 +162,7 @@ class TestLocalDirectoryStorageInit:
 
     def test_init_succeeds_with_existing_dir(self, base_dir):
         storage = LocalDirectoryStorage(base_dir)
-        assert storage.inventory_dir == base_dir
+        assert storage.collection_dir == base_dir
 
 
 class TestLocalDirectoryStorageSelect:

{objbase-0.5.0 → objbase-0.5.1}/tests/test_mongodb_storage.py

@@ -5,7 +5,7 @@ import os
 import pytest
 from testcontainers.community.mongodb import MongoDbContainer
 
-from objbase.storage.mongodb import MongoDBStorage
+from objbase.storage.mongodb import DEFAULT_DB_NAME, MongoDBStorage
 
 # mongo:latest (8.x) refuses to start on Linux kernels >= 6.19 (SERVER-121912),
 # which recent Docker Desktop VMs ship. Pin a known-good image by default.
@@ -25,9 +25,9 @@ def mongo_container():
 
 @pytest.fixture()
 def mongo_client(mongo_container):
-    """Return a MongoClient and drop the inventory DB before each test."""
+    """Return a MongoClient and drop the collection DB before each test."""
     client = mongo_container.get_connection_client()
-    client.drop_database("inventory")
+    client.drop_database(DEFAULT_DB_NAME)
     return client
 
 
@@ -202,3 +202,30 @@ class TestMongoDBStorageDelete:
         storage.write("todo", {"id": "2"})
         storage.delete("todo", "1")
         assert storage.read("todo", "2") == {"id": "2"}
+
+
+# ---------------------------------------------------------------------------
+# database name
+# ---------------------------------------------------------------------------
+
+
+class TestMongoDBStorageDbName:
+    def test_default_db_name(self, storage, mongo_client):
+        storage.write("todo", {"id": "1"})
+        assert mongo_client["objbase"]["todo"].count_documents({"id": "1"}) == 1
+
+    def test_custom_db_name(self, mongo_client):
+        mongo_client.drop_database("myapp")
+        storage = MongoDBStorage(mongo_client, db_name="myapp")
+        storage.write("todo", {"id": "1"})
+        assert mongo_client["myapp"]["todo"].count_documents({"id": "1"}) == 1
+        assert "todo" not in mongo_client["objbase"].list_collection_names()
+
+    def test_different_db_names_are_isolated(self, mongo_client):
+        mongo_client.drop_database("a")
+        mongo_client.drop_database("b")
+        a = MongoDBStorage(mongo_client, db_name="a")
+        b = MongoDBStorage(mongo_client, db_name="b")
+        a.write("todo", {"id": "1"})
+        assert b.read("todo", "1") is None
+        assert b.items("todo") == []

{objbase-0.5.0 → objbase-0.5.1}/tests/test_redis_storage.py

@@ -43,7 +43,7 @@ class TestRedisStorageWrite:
 
     def test_write_stores_item_as_json_in_type_hash(self, storage, redis_client):
         storage.write("todo", {"id": "1", "title": "Buy milk"})
-        raw = redis_client.hget("inventory:todo", "1")
+        raw = redis_client.hget("objbase:todo", "1")
         assert json.loads(raw) == {"id": "1", "title": "Buy milk"}
 
     def test_write_preserves_value_types(self, storage):
@@ -149,7 +149,7 @@ class TestRedisStorageDelete:
     def test_delete_removes_item_from_redis(self, storage, redis_client):
         storage.write("todo", {"id": "1"})
         storage.delete("todo", "1")
-        assert not redis_client.hexists("inventory:todo", "1")
+        assert not redis_client.hexists("objbase:todo", "1")
 
     def test_delete_item_no_longer_readable(self, storage):
         storage.write("todo", {"id": "1"})
@@ -203,7 +203,7 @@ class TestRedisStorageLayout:
         storage = RedisStorage(redis_client, key_prefix="myapp:")
         storage.write("todo", {"id": "1"})
         assert redis_client.hexists("myapp:todo", "1")
-        assert not redis_client.exists("inventory:todo")
+        assert not redis_client.exists("objbase:todo")
 
     def test_different_prefixes_are_isolated(self, redis_client):
         a = RedisStorage(redis_client, key_prefix="a:")

{objbase-0.5.0 → objbase-0.5.1}/tests/test_storage_contract.py

@@ -76,7 +76,7 @@ def _directory(request, tmp_path):
 
 
 def _sqlite(request, tmp_path):
-    return SQLiteStorage(str(tmp_path / "inventory.db"))
+    return SQLiteStorage(str(tmp_path / "collection.db"))
 
 
 def _redis(request, tmp_path):
@@ -88,10 +88,10 @@ def _redis(request, tmp_path):
 
 
 def _mongodb(request, tmp_path):
-    from objbase.storage.mongodb import MongoDBStorage
+    from objbase.storage.mongodb import DEFAULT_DB_NAME, MongoDBStorage
 
     client = request.getfixturevalue("mongo_container").get_connection_client()
-    client.drop_database("inventory")
+    client.drop_database(DEFAULT_DB_NAME)
     return MongoDBStorage(client)
 
 
@@ -293,7 +293,7 @@ async def _async_mongodb(request):
 
     url = request.getfixturevalue("mongo_container").get_connection_url()
     client: pymongo.AsyncMongoClient[Item] = pymongo.AsyncMongoClient(url)
-    await client.drop_database("inventory")
+    await client.drop_database("collection")
     return AsyncMongoDBStorage(client)
 
 

{objbase-0.5.0 → objbase-0.5.1}/uv.lock

@@ -414,7 +414,7 @@ wheels = [
 
 [[package]]
 name = "objbase"
-version = "0.5.0"
+version = "0.5.1"
 source = { editable = "." }
 
 [package.optional-dependencies]

objbase-0.5.0/examples/async_file_example.py

@@ -1,30 +0,0 @@
-# Async to-do list stored in one JSON file per item type ({base_dir}/todo.json). No extra dependencies needed.
-# Set INVENTORY_DIR to use a different directory.
-import asyncio
-import os
-
-from objbase.asyncio.collection import AsyncCollection
-from objbase.asyncio.storage.local import AsyncLocalFileStorage
-
-
-async def main() -> None:
-    base_dir = os.getenv("INVENTORY_DIR", "data")
-    os.makedirs(base_dir, exist_ok=True)  # the base directory must exist
-    storage = AsyncLocalFileStorage(base_dir=base_dir)
-    todos_inventory = AsyncCollection(item_type="todo", storage=storage)
-
-    # Create some to-do items
-    await todos_inventory.save({"id": "1", "name": "Buy groceries", "status": "pending"})
-    await todos_inventory.save({"id": "2", "name": "Walk the dog", "status": "pending"})
-    print("All To-dos:", await todos_inventory.filter())
-
-    # Update a to-do item
-    updated_todo = await todos_inventory.patch("1", {"status": "completed"})
-    print("Updated To-do:", updated_todo)
-
-    # Delete the to-do items
-    for todo_id in await todos_inventory.keys():
-        print(f"Deleted To-do {todo_id}:", await todos_inventory.delete(todo_id))
-
-
-asyncio.run(main())