objbase 0.5.0__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: objbase
-Version: 0.5.0
+Version: 0.5.2
 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,13 @@ or from their submodules as in the examples below:
 | Module | Contents |
 |---|---|
 | `objbase.interface` | `Storage`, `AsyncStorage` protocols and the `Item` type |
-| `objbase.inventory` | `Collection` |
-| `objbase.errors` | `CollectionError`, `ItemNotFoundError` |
+| `objbase.collection` | `Collection` |
+| `objbase.errors` | `CollectionError`, `ItemNotFoundError`, `ActionNotFoundError` |
+| `objbase.actions` | `ActionHandler`, `AsyncActionHandler`, `ActionParams`, `load_action_handler` |
 | `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 +112,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,8 +124,9 @@ 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` |
+| `run_action` with an action that isn't registered | `objbase.ActionNotFoundError` (a `CollectionError` and a `LookupError`) |
 
 `CollectionError` is the base class of all objbase errors.
 
@@ -258,9 +260,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 +278,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 +317,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 +372,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
@@ -384,6 +387,83 @@ can also be called directly on the storage.
 
 ---
 
+## Actions
+
+An action is a named operation on a single item. Register a handler on a
+collection, then run it by item id:
+
+```python
+from objbase import Collection, InMemoryStorage
+
+
+def set_status(item, params):
+    return {**item, "status": params["status"]}
+
+
+todos = Collection(item_type="todo", storage=InMemoryStorage())
+todos.register_action("set_status", set_status)
+
+todos.save({"id": "1", "title": "Buy milk", "status": "pending"})
+todos.run_action("1", "set_status", {"status": "done"})  # → {"id": "1", ..., "status": "done"}
+```
+
+A handler is called as `handler(item, params)` with the stored item and the
+params (`{}` if none are given):
+
+- If it returns an item, that item **replaces** the stored one (like `save`) and is
+  returned. It must keep the item's `id`, otherwise `ValueError` is raised and nothing is saved.
+- If it returns `None`, nothing is saved and the stored item is returned.
+- Exceptions raised by the handler propagate unchanged.
+
+`run_action` raises `ActionNotFoundError` for an unregistered action and
+`ItemNotFoundError` for a missing item. Actions are registered per collection
+instance; registering a name again replaces its handler. Like `patch`, an action
+reads, changes and writes the item, so it is not atomic across concurrent writers.
+
+On `AsyncCollection`, `run_action` is a coroutine and handlers may be sync or
+async: async handlers are awaited, sync handlers run in a worker thread
+(`asyncio.to_thread`). `Collection` accepts only sync handlers and raises
+`TypeError` for an async one.
+
+```python
+async def set_status(item, params):
+    return {**item, "status": params["status"]}
+
+
+todos = AsyncCollection(item_type="todo", storage=storage)
+todos.register_action("set_status", set_status)
+await todos.run_action("1", "set_status", {"status": "done"})
+```
+
+### Loading handlers from a module
+
+`load_action_handler(module_name, action_name)` imports a module and returns
+the handler from its `actions` mapping (pass `attr_name=` to use another name):
+
+```python
+# myapp/todo_actions.py
+def set_status(item, params):
+    return {**item, "status": params["status"]}
+
+
+actions = {"set_status": set_status}
+```
+
+```python
+from objbase import load_action_handler
+
+todos.register_action("set_status", load_action_handler("myapp.todo_actions", "set_status"))
+```
+
+It raises `ActionNotFoundError` if the module has no such mapping or action, and
+`TypeError` if the entry isn't callable. Errors from importing the module itself
+propagate unchanged. Only pass module names you trust: importing a module runs its code.
+
+Runs are logged at `DEBUG` level on the `objbase.collection` and
+`objbase.asyncio.collection` loggers.
+
+---
+
 ## Examples
 
 Runnable scripts are in [`examples/`](examples/):
@@ -405,7 +485,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 +533,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.2}/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,13 @@ or from their submodules as in the examples below:
 | Module | Contents |
 |---|---|
 | `objbase.interface` | `Storage`, `AsyncStorage` protocols and the `Item` type |
-| `objbase.inventory` | `Collection` |
-| `objbase.errors` | `CollectionError`, `ItemNotFoundError` |
+| `objbase.collection` | `Collection` |
+| `objbase.errors` | `CollectionError`, `ItemNotFoundError`, `ActionNotFoundError` |
+| `objbase.actions` | `ActionHandler`, `AsyncActionHandler`, `ActionParams`, `load_action_handler` |
 | `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 +80,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,8 +92,9 @@ 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` |
+| `run_action` with an action that isn't registered | `objbase.ActionNotFoundError` (a `CollectionError` and a `LookupError`) |
 
 `CollectionError` is the base class of all objbase errors.
 
@@ -226,9 +228,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 +246,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 +285,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 +340,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
@@ -352,6 +355,83 @@ can also be called directly on the storage.
 
 ---
 
+## Actions
+
+An action is a named operation on a single item. Register a handler on a
+collection, then run it by item id:
+
+```python
+from objbase import Collection, InMemoryStorage
+
+
+def set_status(item, params):
+    return {**item, "status": params["status"]}
+
+
+todos = Collection(item_type="todo", storage=InMemoryStorage())
+todos.register_action("set_status", set_status)
+
+todos.save({"id": "1", "title": "Buy milk", "status": "pending"})
+todos.run_action("1", "set_status", {"status": "done"})  # → {"id": "1", ..., "status": "done"}
+```
+
+A handler is called as `handler(item, params)` with the stored item and the
+params (`{}` if none are given):
+
+- If it returns an item, that item **replaces** the stored one (like `save`) and is
+  returned. It must keep the item's `id`, otherwise `ValueError` is raised and nothing is saved.
+- If it returns `None`, nothing is saved and the stored item is returned.
+- Exceptions raised by the handler propagate unchanged.
+
+`run_action` raises `ActionNotFoundError` for an unregistered action and
+`ItemNotFoundError` for a missing item. Actions are registered per collection
+instance; registering a name again replaces its handler. Like `patch`, an action
+reads, changes and writes the item, so it is not atomic across concurrent writers.
+
+On `AsyncCollection`, `run_action` is a coroutine and handlers may be sync or
+async: async handlers are awaited, sync handlers run in a worker thread
+(`asyncio.to_thread`). `Collection` accepts only sync handlers and raises
+`TypeError` for an async one.
+
+```python
+async def set_status(item, params):
+    return {**item, "status": params["status"]}
+
+
+todos = AsyncCollection(item_type="todo", storage=storage)
+todos.register_action("set_status", set_status)
+await todos.run_action("1", "set_status", {"status": "done"})
+```
+
+### Loading handlers from a module
+
+`load_action_handler(module_name, action_name)` imports a module and returns
+the handler from its `actions` mapping (pass `attr_name=` to use another name):
+
+```python
+# myapp/todo_actions.py
+def set_status(item, params):
+    return {**item, "status": params["status"]}
+
+
+actions = {"set_status": set_status}
+```
+
+```python
+from objbase import load_action_handler
+
+todos.register_action("set_status", load_action_handler("myapp.todo_actions", "set_status"))
+```
+
+It raises `ActionNotFoundError` if the module has no such mapping or action, and
+`TypeError` if the entry isn't callable. Errors from importing the module itself
+propagate unchanged. Only pass module names you trust: importing a module runs its code.
+
+Runs are logged at `DEBUG` level on the `objbase.collection` and
+`objbase.asyncio.collection` loggers.
+
+---
+
 ## Examples
 
 Runnable scripts are in [`examples/`](examples/):
@@ -373,7 +453,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 +501,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.2}/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.2}/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.2/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.2}/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.2}/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.2}/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.2}/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.2}/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()