queuerPy 0.16.0__tar.gz → 0.17.0__tar.gz

{queuerpy-0.16.0/queuerPy.egg-info → queuerpy-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: queuerPy
-Version: 0.16.0
+Version: 0.17.0
 Summary: A Python implementation of the queuer system - a job queuing and processing system with PostgreSQL backend
 Author-email: Simon Herrmann <siherrmann@users.noreply.github.com>
 Maintainer-email: Simon Herrmann <siherrmann@users.noreply.github.com>
@@ -43,9 +43,10 @@ Dynamic: license-file
 
 # queuerPy
 
+[![PyPi](https://pythonico.leapcell.app/pypi/queuerPy.svg?style=shields&data=n,v,d)](https://pypi.org/project/queuerPy/)
 [![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/siherrmann/queuer/blob/master/LICENSE)
 ![Coverage](https://raw.githubusercontent.com/siherrmann/queuerPy/refs/heads/main/coverage-badge.svg)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/siherrmann/queuer/blob/master/LICENSE)
 
 Python port of the queuer package - a queueing system based on PostgreSQL.
 
@@ -97,9 +98,15 @@ def example_task():
 That's easy, right? Adding a job is just as easy:
 
 ```python
-# Add a job to the queue
+# Add a job to the queue with positional arguments
 job = q.add_job(example_task, 5, "12")
 print(f"Job added: {job.rid}")
+
+# Add a job with keyword arguments (kwargs)
+job = q.add_job(example_task, paramKeyed1="test", debug=True)
+
+# Add a job with both positional and keyword arguments
+job = q.add_job(example_task, 5, "12", paramKeyed1="test", debug=True)
 ```
 
 In the initialisation of the queuer the existence of the necessary database tables is checked and if they don't exist they get created. The database is configured with these environment variables:
@@ -199,6 +206,72 @@ This method handles the registration of a task, making the worker able to pick u
 
 ---
 
+## add_job
+
+The `add_job` method adds a new job to the queue for execution. Jobs are units of work that will be processed by the queuer.
+
+```python
+def add_job(
+    self, 
+    task: Union[Callable, str], 
+    *parameters: Any,
+    **parameters_keyed: Any
+) -> Job
+
+def add_job_with_options(
+    self,
+    options: Optional[Options],
+    task: Union[Callable, str],
+    *parameters: Any,
+    **parameters_keyed: Any
+) -> Job
+```
+
+- `task`: A `Callable` or `str` representing the task to execute. If a callable, it must be registered with `add_task` first.
+- `options`: Optional `Options` for custom error handling or scheduling behavior. Only available in `add_job_with_options()`.
+- `*parameters`: Positional arguments to pass to the task function.
+- `**parameters_keyed`: Keyword arguments to pass to the task function (Python-specific feature).
+
+**Examples:**
+
+```python
+# Job with both positional and keyword arguments
+job = queuer.add_job(my_task, "arg1", paramKeyed1="test", paramKeyed2=1)
+
+# Job with custom options (requires add_job_with_options)
+options = Options(on_error=OnError(max_retries=5))
+job = queuer.add_job_with_options(options, my_task, "arg1", debug=True)
+```
+
+**Note:** Keyword arguments (`**parameters_keyed`) are stored separately in the database and enable Python functions to be called with named parameters. This is useful for optional parameters, default values, and improved code clarity. Go jobs continue to use only positional parameters.
+
+---
+
+## add_jobs
+
+The `add_jobs` method allows efficient batch insertion of multiple jobs at once.
+
+```python
+def add_jobs(self, batch_jobs: List[BatchJob]) -> List[UUID]
+```
+
+- `batch_jobs`: A list of `BatchJob` instances to insert.
+
+**Example:**
+
+```python
+from model.batch_job import BatchJob
+
+batch = [
+    BatchJob(task=my_task, parameters=[1, "a"]),
+    BatchJob(task=my_task, parameters=[2], parameters_keyed={"name": "b"}),
+    BatchJob(task=my_task, parameters_keyed={"id": 3, "name": "c"})
+]
+job_rids = queuer.add_jobs(batch)
+```
+
+---
+
 ## add_next_interval_func
 
 The `add_next_interval_func` method registers a custom function that determines the next execution time for scheduled jobs. This is useful for implementing complex scheduling logic beyond simple fixed intervals.
@@ -296,19 +369,20 @@ class Schedule:
 ### Job Management
 
 ```python
-# Add a single job
-job = queuer.add_job(my_task, param1, param2)
+# Add a job with both positional and keyword arguments
+job = queuer.add_job(my_task, param1, param2, paramKeyed1="test", paramKeyed2=1)
 
 # Add a job with custom options
 from model.options import Options, OnError
 options = Options(on_error=OnError(max_retries=5, timeout=60.0))
-job = queuer.add_job_with_options(options, my_task, param1)
+job = queuer.add_job_with_options(options, my_task, param1, paramKeyed1="test")
 
 # Add multiple jobs as a batch
 from model.batch_job import BatchJob
 batch = [
     BatchJob(task=my_task, parameters=[1, "a"]),
-    BatchJob(task=my_task, parameters=[2, "b"])
+    BatchJob(task=my_task, parameters=[2], parameters_keyed={"name": "b"}),
+    BatchJob(task=my_task, parameters_keyed={"id": 3, "name": "c"})
 ]
 queuer.add_jobs(batch)
 
@@ -335,6 +409,7 @@ worker_jobs = queuer.get_jobs_by_worker_rid(worker.rid)
 
 # ⭐ Features
 
+- **Keyword Arguments Support**: Python functions can use both positional arguments (`*args`) and keyword arguments (`**kwargs`), while maintaining compatibility with Go jobs that use only positional parameters.
 - **Async/Await Support**: Full asyncio integration with threading fallbacks.
 - **PostgreSQL NOTIFY/LISTEN**: Real-time job notifications without polling overhead.
 - **Batch Job Processing**: Insert job batches efficiently using PostgreSQL's `COPY FROM` feature.

{queuerpy-0.16.0 → queuerpy-0.17.0}/README.md

@@ -1,8 +1,9 @@
 # queuerPy
 
+[![PyPi](https://pythonico.leapcell.app/pypi/queuerPy.svg?style=shields&data=n,v,d)](https://pypi.org/project/queuerPy/)
 [![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/siherrmann/queuer/blob/master/LICENSE)
 ![Coverage](https://raw.githubusercontent.com/siherrmann/queuerPy/refs/heads/main/coverage-badge.svg)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/siherrmann/queuer/blob/master/LICENSE)
 
 Python port of the queuer package - a queueing system based on PostgreSQL.
 
@@ -54,9 +55,15 @@ def example_task():
 That's easy, right? Adding a job is just as easy:
 
 ```python
-# Add a job to the queue
+# Add a job to the queue with positional arguments
 job = q.add_job(example_task, 5, "12")
 print(f"Job added: {job.rid}")
+
+# Add a job with keyword arguments (kwargs)
+job = q.add_job(example_task, paramKeyed1="test", debug=True)
+
+# Add a job with both positional and keyword arguments
+job = q.add_job(example_task, 5, "12", paramKeyed1="test", debug=True)
 ```
 
 In the initialisation of the queuer the existence of the necessary database tables is checked and if they don't exist they get created. The database is configured with these environment variables:
@@ -156,6 +163,72 @@ This method handles the registration of a task, making the worker able to pick u
 
 ---
 
+## add_job
+
+The `add_job` method adds a new job to the queue for execution. Jobs are units of work that will be processed by the queuer.
+
+```python
+def add_job(
+    self, 
+    task: Union[Callable, str], 
+    *parameters: Any,
+    **parameters_keyed: Any
+) -> Job
+
+def add_job_with_options(
+    self,
+    options: Optional[Options],
+    task: Union[Callable, str],
+    *parameters: Any,
+    **parameters_keyed: Any
+) -> Job
+```
+
+- `task`: A `Callable` or `str` representing the task to execute. If a callable, it must be registered with `add_task` first.
+- `options`: Optional `Options` for custom error handling or scheduling behavior. Only available in `add_job_with_options()`.
+- `*parameters`: Positional arguments to pass to the task function.
+- `**parameters_keyed`: Keyword arguments to pass to the task function (Python-specific feature).
+
+**Examples:**
+
+```python
+# Job with both positional and keyword arguments
+job = queuer.add_job(my_task, "arg1", paramKeyed1="test", paramKeyed2=1)
+
+# Job with custom options (requires add_job_with_options)
+options = Options(on_error=OnError(max_retries=5))
+job = queuer.add_job_with_options(options, my_task, "arg1", debug=True)
+```
+
+**Note:** Keyword arguments (`**parameters_keyed`) are stored separately in the database and enable Python functions to be called with named parameters. This is useful for optional parameters, default values, and improved code clarity. Go jobs continue to use only positional parameters.
+
+---
+
+## add_jobs
+
+The `add_jobs` method allows efficient batch insertion of multiple jobs at once.
+
+```python
+def add_jobs(self, batch_jobs: List[BatchJob]) -> List[UUID]
+```
+
+- `batch_jobs`: A list of `BatchJob` instances to insert.
+
+**Example:**
+
+```python
+from model.batch_job import BatchJob
+
+batch = [
+    BatchJob(task=my_task, parameters=[1, "a"]),
+    BatchJob(task=my_task, parameters=[2], parameters_keyed={"name": "b"}),
+    BatchJob(task=my_task, parameters_keyed={"id": 3, "name": "c"})
+]
+job_rids = queuer.add_jobs(batch)
+```
+
+---
+
 ## add_next_interval_func
 
 The `add_next_interval_func` method registers a custom function that determines the next execution time for scheduled jobs. This is useful for implementing complex scheduling logic beyond simple fixed intervals.
@@ -253,19 +326,20 @@ class Schedule:
 ### Job Management
 
 ```python
-# Add a single job
-job = queuer.add_job(my_task, param1, param2)
+# Add a job with both positional and keyword arguments
+job = queuer.add_job(my_task, param1, param2, paramKeyed1="test", paramKeyed2=1)
 
 # Add a job with custom options
 from model.options import Options, OnError
 options = Options(on_error=OnError(max_retries=5, timeout=60.0))
-job = queuer.add_job_with_options(options, my_task, param1)
+job = queuer.add_job_with_options(options, my_task, param1, paramKeyed1="test")
 
 # Add multiple jobs as a batch
 from model.batch_job import BatchJob
 batch = [
     BatchJob(task=my_task, parameters=[1, "a"]),
-    BatchJob(task=my_task, parameters=[2, "b"])
+    BatchJob(task=my_task, parameters=[2], parameters_keyed={"name": "b"}),
+    BatchJob(task=my_task, parameters_keyed={"id": 3, "name": "c"})
 ]
 queuer.add_jobs(batch)
 
@@ -292,6 +366,7 @@ worker_jobs = queuer.get_jobs_by_worker_rid(worker.rid)
 
 # ⭐ Features
 
+- **Keyword Arguments Support**: Python functions can use both positional arguments (`*args`) and keyword arguments (`**kwargs`), while maintaining compatibility with Go jobs that use only positional parameters.
 - **Async/Await Support**: Full asyncio integration with threading fallbacks.
 - **PostgreSQL NOTIFY/LISTEN**: Real-time job notifications without polling overhead.
 - **Batch Job Processing**: Insert job batches efficiently using PostgreSQL's `COPY FROM` feature.

{queuerpy-0.16.0 → queuerpy-0.17.0}/_version.py

@@ -1,6 +1,6 @@
 """Version information for queuerPy package."""
 
-__version__ = "0.16.0"
+__version__ = "0.17.0"
 __version_info__ = tuple(int(part) for part in __version__.split("."))
 
 # For compatibility

{queuerpy-0.16.0 → queuerpy-0.17.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "queuerPy"
-version = "0.16.0"
+version = "0.17.0"
 description = "A Python implementation of the queuer system - a job queuing and processing system with PostgreSQL backend"
 readme = "README.md"
 license = "Apache-2.0"
@@ -92,7 +92,7 @@ pythonVersion = "3.8"
 pythonPlatform = "All"
 
 [tool.mypy]
-python_version = "0.16.0"
+python_version = "0.17.0"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{queuerpy-0.16.0 → queuerpy-0.17.0/queuerPy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: queuerPy
-Version: 0.16.0
+Version: 0.17.0
 Summary: A Python implementation of the queuer system - a job queuing and processing system with PostgreSQL backend
 Author-email: Simon Herrmann <siherrmann@users.noreply.github.com>
 Maintainer-email: Simon Herrmann <siherrmann@users.noreply.github.com>
@@ -43,9 +43,10 @@ Dynamic: license-file
 
 # queuerPy
 
+[![PyPi](https://pythonico.leapcell.app/pypi/queuerPy.svg?style=shields&data=n,v,d)](https://pypi.org/project/queuerPy/)
 [![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/siherrmann/queuer/blob/master/LICENSE)
 ![Coverage](https://raw.githubusercontent.com/siherrmann/queuerPy/refs/heads/main/coverage-badge.svg)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/siherrmann/queuer/blob/master/LICENSE)
 
 Python port of the queuer package - a queueing system based on PostgreSQL.
 
@@ -97,9 +98,15 @@ def example_task():
 That's easy, right? Adding a job is just as easy:
 
 ```python
-# Add a job to the queue
+# Add a job to the queue with positional arguments
 job = q.add_job(example_task, 5, "12")
 print(f"Job added: {job.rid}")
+
+# Add a job with keyword arguments (kwargs)
+job = q.add_job(example_task, paramKeyed1="test", debug=True)
+
+# Add a job with both positional and keyword arguments
+job = q.add_job(example_task, 5, "12", paramKeyed1="test", debug=True)
 ```
 
 In the initialisation of the queuer the existence of the necessary database tables is checked and if they don't exist they get created. The database is configured with these environment variables:
@@ -199,6 +206,72 @@ This method handles the registration of a task, making the worker able to pick u
 
 ---
 
+## add_job
+
+The `add_job` method adds a new job to the queue for execution. Jobs are units of work that will be processed by the queuer.
+
+```python
+def add_job(
+    self, 
+    task: Union[Callable, str], 
+    *parameters: Any,
+    **parameters_keyed: Any
+) -> Job
+
+def add_job_with_options(
+    self,
+    options: Optional[Options],
+    task: Union[Callable, str],
+    *parameters: Any,
+    **parameters_keyed: Any
+) -> Job
+```
+
+- `task`: A `Callable` or `str` representing the task to execute. If a callable, it must be registered with `add_task` first.
+- `options`: Optional `Options` for custom error handling or scheduling behavior. Only available in `add_job_with_options()`.
+- `*parameters`: Positional arguments to pass to the task function.
+- `**parameters_keyed`: Keyword arguments to pass to the task function (Python-specific feature).
+
+**Examples:**
+
+```python
+# Job with both positional and keyword arguments
+job = queuer.add_job(my_task, "arg1", paramKeyed1="test", paramKeyed2=1)
+
+# Job with custom options (requires add_job_with_options)
+options = Options(on_error=OnError(max_retries=5))
+job = queuer.add_job_with_options(options, my_task, "arg1", debug=True)
+```
+
+**Note:** Keyword arguments (`**parameters_keyed`) are stored separately in the database and enable Python functions to be called with named parameters. This is useful for optional parameters, default values, and improved code clarity. Go jobs continue to use only positional parameters.
+
+---
+
+## add_jobs
+
+The `add_jobs` method allows efficient batch insertion of multiple jobs at once.
+
+```python
+def add_jobs(self, batch_jobs: List[BatchJob]) -> List[UUID]
+```
+
+- `batch_jobs`: A list of `BatchJob` instances to insert.
+
+**Example:**
+
+```python
+from model.batch_job import BatchJob
+
+batch = [
+    BatchJob(task=my_task, parameters=[1, "a"]),
+    BatchJob(task=my_task, parameters=[2], parameters_keyed={"name": "b"}),
+    BatchJob(task=my_task, parameters_keyed={"id": 3, "name": "c"})
+]
+job_rids = queuer.add_jobs(batch)
+```
+
+---
+
 ## add_next_interval_func
 
 The `add_next_interval_func` method registers a custom function that determines the next execution time for scheduled jobs. This is useful for implementing complex scheduling logic beyond simple fixed intervals.
@@ -296,19 +369,20 @@ class Schedule:
 ### Job Management
 
 ```python
-# Add a single job
-job = queuer.add_job(my_task, param1, param2)
+# Add a job with both positional and keyword arguments
+job = queuer.add_job(my_task, param1, param2, paramKeyed1="test", paramKeyed2=1)
 
 # Add a job with custom options
 from model.options import Options, OnError
 options = Options(on_error=OnError(max_retries=5, timeout=60.0))
-job = queuer.add_job_with_options(options, my_task, param1)
+job = queuer.add_job_with_options(options, my_task, param1, paramKeyed1="test")
 
 # Add multiple jobs as a batch
 from model.batch_job import BatchJob
 batch = [
     BatchJob(task=my_task, parameters=[1, "a"]),
-    BatchJob(task=my_task, parameters=[2, "b"])
+    BatchJob(task=my_task, parameters=[2], parameters_keyed={"name": "b"}),
+    BatchJob(task=my_task, parameters_keyed={"id": 3, "name": "c"})
 ]
 queuer.add_jobs(batch)
 
@@ -335,6 +409,7 @@ worker_jobs = queuer.get_jobs_by_worker_rid(worker.rid)
 
 # ⭐ Features
 
+- **Keyword Arguments Support**: Python functions can use both positional arguments (`*args`) and keyword arguments (`**kwargs`), while maintaining compatibility with Go jobs that use only positional parameters.
 - **Async/Await Support**: Full asyncio integration with threading fallbacks.
 - **PostgreSQL NOTIFY/LISTEN**: Real-time job notifications without polling overhead.
 - **Batch Job Processing**: Insert job batches efficiently using PostgreSQL's `COPY FROM` feature.