conductor-python 1.1.4__tar.gz → 1.1.6__tar.gz

conductor_python-1.1.6/PKG-INFO

@@ -0,0 +1,271 @@
+Metadata-Version: 2.1
+Name: conductor-python
+Version: 1.1.6
+Summary: Netflix Conductor Python SDK
+Home-page: https://github.com/conductor-sdk/conductor-python
+Author: Orkes
+Author-email: developers@orkes.io
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: certifi>=14.05.14
+Requires-Dist: prometheus-client>=0.13.1
+Requires-Dist: six>=1.10
+Requires-Dist: requests>=2.31.0
+Requires-Dist: typing-extensions>=4.2.0
+Requires-Dist: astor>=0.8.1
+Requires-Dist: shortuuid>=1.0.11
+Requires-Dist: dacite>=1.8.1
+
+# Conductor OSS Python SDK
+
+Python SDK for working with https://github.com/conductor-oss/conductor.
+
+[Conductor](https://www.conductor-oss.org/) is the leading open-source orchestration platform allowing developers to build highly scalable distributed applications.
+
+Check out the [official documentation for Conductor](https://orkes.io/content).
+
+## ⭐ Conductor OSS
+
+Show support for the Conductor OSS.  Please help spread the awareness by starring Conductor repo.
+
+[![GitHub stars](https://img.shields.io/github/stars/conductor-oss/conductor.svg?style=social&label=Star&maxAge=)](https://GitHub.com/conductor-oss/conductor/)
+
+## Content
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+- [Install Conductor Python SDK](#install-conductor-python-sdk)
+  - [Get Conductor Python SDK](#get-conductor-python-sdk)
+- [Hello World Application Using Conductor](#hello-world-application-using-conductor)
+  - [Step 1: Create Workflow](#step-1-create-workflow)
+    - [Creating Workflows by Code](#creating-workflows-by-code)
+    - [(Alternatively) Creating Workflows in JSON](#alternatively-creating-workflows-in-json)
+  - [Step 2: Write Task Worker](#step-2-write-task-worker)
+  - [Step 3: Write _Hello World_ Application](#step-3-write-_hello-world_-application)
+- [Running Workflows on Conductor Standalone (Installed Locally)](#running-workflows-on-conductor-standalone-installed-locally)
+  - [Setup Environment Variable](#setup-environment-variable)
+  - [Start Conductor Server](#start-conductor-server)
+  - [Execute Hello World Application](#execute-hello-world-application)
+- [Running Workflows on Orkes Conductor](#running-workflows-on-orkes-conductor)
+- [Learn More about Conductor Python SDK](#learn-more-about-conductor-python-sdk)
+  - [Create and Run Conductor Workers](#create-and-run-conductor-workers)
+  - [Create Conductor Workflows](#create-conductor-workflows)
+  - [Using Conductor in your Application](#using-conductor-in-your-application)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Install Conductor Python SDK
+
+Before installing Conductor Python SDK, it is a good practice to set up a dedicated virtual environment as follows:
+
+```shell
+virtualenv conductor
+source conductor/bin/activate
+```
+
+### Get Conductor Python SDK
+
+The SDK requires Python 3.9+. To install the SDK, use the following command:
+
+```shell
+python3 -m pip install conductor-python
+```
+
+## Hello World Application Using Conductor
+
+In this section, we will create a simple "Hello World" application that executes a "greetings" workflow managed by Conductor.
+
+### Step 1: Create Workflow
+
+#### Creating Workflows by Code
+
+Create [greetings_workflow.py](examples/helloworld/greetings_workflow.py) with the following:
+
+```python
+from conductor.client.workflow.conductor_workflow import ConductorWorkflow
+from conductor.client.workflow.executor.workflow_executor import WorkflowExecutor
+from greetings_worker import greet
+
+def greetings_workflow(workflow_executor: WorkflowExecutor) -> ConductorWorkflow:
+    name = 'greetings'
+    workflow = ConductorWorkflow(name=name, executor=workflow_executor)
+    workflow.version = 1
+    workflow >> greet(task_ref_name='greet_ref', name=workflow.input('name'))
+    return workflow
+
+
+```
+
+#### (Alternatively) Creating Workflows in JSON
+
+Create `greetings_workflow.json` with the following:
+
+```json
+{
+  "name": "greetings",
+  "description": "Sample greetings workflow",
+  "version": 1,
+  "tasks": [
+    {
+      "name": "greet",
+      "taskReferenceName": "greet_ref",
+      "type": "SIMPLE",
+      "inputParameters": {
+        "name": "${workflow.input.name}"
+      }
+    }
+  ],
+  "timeoutPolicy": "TIME_OUT_WF",
+  "timeoutSeconds": 60
+}
+```
+
+Workflows must be registered to the Conductor server. Use the API to register the greetings workflow from the JSON file above:
+```shell
+curl -X POST -H "Content-Type:application/json" \
+http://localhost:8080/api/metadata/workflow -d @greetings_workflow.json
+```
+> [!note]
+> To use the Conductor API, the Conductor server must be up and running (see [Running over Conductor standalone (installed locally)](#running-over-conductor-standalone-installed-locally)).
+
+### Step 2: Write Task Worker
+
+Using Python, a worker represents a function with the worker_task decorator. Create [greetings_worker.py](examples/helloworld/greetings_worker.py) file as illustrated below:
+
+> [!note]
+> A single workflow can have task workers written in different languages and deployed anywhere, making your workflow polyglot and distributed!
+
+```python
+from conductor.client.worker.worker_task import worker_task
+
+
+@worker_task(task_definition_name='greet')
+def greet(name: str) -> str:
+    return f'Hello {name}'
+
+```
+Now, we are ready to write our main application, which will execute our workflow.
+
+### Step 3: Write _Hello World_ Application
+
+Let's add [helloworld.py](examples/helloworld/helloworld.py) with a `main` method:
+
+```python
+from conductor.client.automator.task_handler import TaskHandler
+from conductor.client.configuration.configuration import Configuration
+from conductor.client.workflow.conductor_workflow import ConductorWorkflow
+from conductor.client.workflow.executor.workflow_executor import WorkflowExecutor
+from greetings_workflow import greetings_workflow
+
+
+def register_workflow(workflow_executor: WorkflowExecutor) -> ConductorWorkflow:
+    workflow = greetings_workflow(workflow_executor=workflow_executor)
+    workflow.register(True)
+    return workflow
+
+
+def main():
+    # The app is connected to http://localhost:8080/api by default
+    api_config = Configuration()
+
+    workflow_executor = WorkflowExecutor(configuration=api_config)
+
+    # Registering the workflow (Required only when the app is executed the first time)
+    workflow = register_workflow(workflow_executor)
+
+    # Starting the worker polling mechanism
+    task_handler = TaskHandler(configuration=api_config)
+    task_handler.start_processes()
+
+    workflow_run = workflow_executor.execute(name=workflow.name, version=workflow.version,
+                                             workflow_input={'name': 'Orkes'})
+
+    print(f'\nworkflow result: {workflow_run.output["result"]}\n')
+    print(f'see the workflow execution here: {api_config.ui_host}/execution/{workflow_run.workflow_id}\n')
+    task_handler.stop_processes()
+
+
+if __name__ == '__main__':
+    main()
+```
+## Running Workflows on Conductor Standalone (Installed Locally)
+
+### Setup Environment Variable
+
+Set the following environment variable to point the SDK to the Conductor Server API endpoint:
+
+```shell
+export CONDUCTOR_SERVER_URL=http://localhost:8080/api
+```
+### Start Conductor Server
+
+To start the Conductor server in a standalone mode from a Docker image, type the command below:
+
+```shell
+docker run --init -p 8080:8080 -p 5000:5000 conductoross/conductor-standalone:3.15.0
+```
+To ensure the server has started successfully, open Conductor UI on http://localhost:5000.
+
+### Execute Hello World Application
+
+To run the application, type the following command:
+
+```
+python helloworld.py
+```
+
+Now, the workflow is executed, and its execution status can be viewed from Conductor UI (http://localhost:5000).
+
+Navigate to the **Executions** tab to view the workflow execution.
+
+<img width="1434" alt="Screenshot 2024-03-18 at 12 30 07" src="https://github.com/Srividhya-S-Subramanian/conductor-python-v1/assets/163816773/11e829b6-d46a-4b47-b2cf-0bf524a6ebdc">
+
+## Running Workflows on Orkes Conductor
+
+For running the workflow in Orkes Conductor,
+
+- Update the Conductor server URL to your cluster name.
+
+```shell
+export CONDUCTOR_SERVER_URL=https://[cluster-name].orkesconductor.io/api
+```
+
+- If you want to run the workflow on the Orkes Conductor Playground, set the Conductor Server variable as follows:
+
+```shell
+export CONDUCTOR_SERVER_URL=https://play.orkes.io/api
+```
+
+- Orkes Conductor requires authentication. [Obtain the key and secret from the Conductor server](https://orkes.io/content/how-to-videos/access-key-and-secret) and set the following environment variables.
+
+```shell
+export CONDUCTOR_AUTH_KEY=your_key
+export CONDUCTOR_AUTH_SECRET=your_key_secret
+```
+
+Run the application and view the execution status from Conductor's UI Console.
+
+> [!NOTE]
+> That's it - you just created and executed your first distributed Python app!
+
+## Learn More about Conductor Python SDK
+
+There are three main ways you can use Conductor when building durable, resilient, distributed applications.
+
+1. Write service workers that implement business logic to accomplish a specific goal - such as initiating payment transfer, getting user information from the database, etc.
+2. Create Conductor workflows that implement application state - A typical workflow implements the saga pattern.
+3. Use Conductor SDK and APIs to manage workflows from your application.
+
+### [Create and Run Conductor Workers](workers.md)
+### [Create Conductor Workflows](workflows.md)
+### [Using Conductor in your Application](conductor_apps.md)

conductor_python-1.1.6/README.md

@@ -0,0 +1,244 @@
+# Conductor OSS Python SDK
+
+Python SDK for working with https://github.com/conductor-oss/conductor.
+
+[Conductor](https://www.conductor-oss.org/) is the leading open-source orchestration platform allowing developers to build highly scalable distributed applications.
+
+Check out the [official documentation for Conductor](https://orkes.io/content).
+
+## ⭐ Conductor OSS
+
+Show support for the Conductor OSS.  Please help spread the awareness by starring Conductor repo.
+
+[![GitHub stars](https://img.shields.io/github/stars/conductor-oss/conductor.svg?style=social&label=Star&maxAge=)](https://GitHub.com/conductor-oss/conductor/)
+
+## Content
+
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+- [Install Conductor Python SDK](#install-conductor-python-sdk)
+  - [Get Conductor Python SDK](#get-conductor-python-sdk)
+- [Hello World Application Using Conductor](#hello-world-application-using-conductor)
+  - [Step 1: Create Workflow](#step-1-create-workflow)
+    - [Creating Workflows by Code](#creating-workflows-by-code)
+    - [(Alternatively) Creating Workflows in JSON](#alternatively-creating-workflows-in-json)
+  - [Step 2: Write Task Worker](#step-2-write-task-worker)
+  - [Step 3: Write _Hello World_ Application](#step-3-write-_hello-world_-application)
+- [Running Workflows on Conductor Standalone (Installed Locally)](#running-workflows-on-conductor-standalone-installed-locally)
+  - [Setup Environment Variable](#setup-environment-variable)
+  - [Start Conductor Server](#start-conductor-server)
+  - [Execute Hello World Application](#execute-hello-world-application)
+- [Running Workflows on Orkes Conductor](#running-workflows-on-orkes-conductor)
+- [Learn More about Conductor Python SDK](#learn-more-about-conductor-python-sdk)
+  - [Create and Run Conductor Workers](#create-and-run-conductor-workers)
+  - [Create Conductor Workflows](#create-conductor-workflows)
+  - [Using Conductor in your Application](#using-conductor-in-your-application)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+## Install Conductor Python SDK
+
+Before installing Conductor Python SDK, it is a good practice to set up a dedicated virtual environment as follows:
+
+```shell
+virtualenv conductor
+source conductor/bin/activate
+```
+
+### Get Conductor Python SDK
+
+The SDK requires Python 3.9+. To install the SDK, use the following command:
+
+```shell
+python3 -m pip install conductor-python
+```
+
+## Hello World Application Using Conductor
+
+In this section, we will create a simple "Hello World" application that executes a "greetings" workflow managed by Conductor.
+
+### Step 1: Create Workflow
+
+#### Creating Workflows by Code
+
+Create [greetings_workflow.py](examples/helloworld/greetings_workflow.py) with the following:
+
+```python
+from conductor.client.workflow.conductor_workflow import ConductorWorkflow
+from conductor.client.workflow.executor.workflow_executor import WorkflowExecutor
+from greetings_worker import greet
+
+def greetings_workflow(workflow_executor: WorkflowExecutor) -> ConductorWorkflow:
+    name = 'greetings'
+    workflow = ConductorWorkflow(name=name, executor=workflow_executor)
+    workflow.version = 1
+    workflow >> greet(task_ref_name='greet_ref', name=workflow.input('name'))
+    return workflow
+
+
+```
+
+#### (Alternatively) Creating Workflows in JSON
+
+Create `greetings_workflow.json` with the following:
+
+```json
+{
+  "name": "greetings",
+  "description": "Sample greetings workflow",
+  "version": 1,
+  "tasks": [
+    {
+      "name": "greet",
+      "taskReferenceName": "greet_ref",
+      "type": "SIMPLE",
+      "inputParameters": {
+        "name": "${workflow.input.name}"
+      }
+    }
+  ],
+  "timeoutPolicy": "TIME_OUT_WF",
+  "timeoutSeconds": 60
+}
+```
+
+Workflows must be registered to the Conductor server. Use the API to register the greetings workflow from the JSON file above:
+```shell
+curl -X POST -H "Content-Type:application/json" \
+http://localhost:8080/api/metadata/workflow -d @greetings_workflow.json
+```
+> [!note]
+> To use the Conductor API, the Conductor server must be up and running (see [Running over Conductor standalone (installed locally)](#running-over-conductor-standalone-installed-locally)).
+
+### Step 2: Write Task Worker
+
+Using Python, a worker represents a function with the worker_task decorator. Create [greetings_worker.py](examples/helloworld/greetings_worker.py) file as illustrated below:
+
+> [!note]
+> A single workflow can have task workers written in different languages and deployed anywhere, making your workflow polyglot and distributed!
+
+```python
+from conductor.client.worker.worker_task import worker_task
+
+
+@worker_task(task_definition_name='greet')
+def greet(name: str) -> str:
+    return f'Hello {name}'
+
+```
+Now, we are ready to write our main application, which will execute our workflow.
+
+### Step 3: Write _Hello World_ Application
+
+Let's add [helloworld.py](examples/helloworld/helloworld.py) with a `main` method:
+
+```python
+from conductor.client.automator.task_handler import TaskHandler
+from conductor.client.configuration.configuration import Configuration
+from conductor.client.workflow.conductor_workflow import ConductorWorkflow
+from conductor.client.workflow.executor.workflow_executor import WorkflowExecutor
+from greetings_workflow import greetings_workflow
+
+
+def register_workflow(workflow_executor: WorkflowExecutor) -> ConductorWorkflow:
+    workflow = greetings_workflow(workflow_executor=workflow_executor)
+    workflow.register(True)
+    return workflow
+
+
+def main():
+    # The app is connected to http://localhost:8080/api by default
+    api_config = Configuration()
+
+    workflow_executor = WorkflowExecutor(configuration=api_config)
+
+    # Registering the workflow (Required only when the app is executed the first time)
+    workflow = register_workflow(workflow_executor)
+
+    # Starting the worker polling mechanism
+    task_handler = TaskHandler(configuration=api_config)
+    task_handler.start_processes()
+
+    workflow_run = workflow_executor.execute(name=workflow.name, version=workflow.version,
+                                             workflow_input={'name': 'Orkes'})
+
+    print(f'\nworkflow result: {workflow_run.output["result"]}\n')
+    print(f'see the workflow execution here: {api_config.ui_host}/execution/{workflow_run.workflow_id}\n')
+    task_handler.stop_processes()
+
+
+if __name__ == '__main__':
+    main()
+```
+## Running Workflows on Conductor Standalone (Installed Locally)
+
+### Setup Environment Variable
+
+Set the following environment variable to point the SDK to the Conductor Server API endpoint:
+
+```shell
+export CONDUCTOR_SERVER_URL=http://localhost:8080/api
+```
+### Start Conductor Server
+
+To start the Conductor server in a standalone mode from a Docker image, type the command below:
+
+```shell
+docker run --init -p 8080:8080 -p 5000:5000 conductoross/conductor-standalone:3.15.0
+```
+To ensure the server has started successfully, open Conductor UI on http://localhost:5000.
+
+### Execute Hello World Application
+
+To run the application, type the following command:
+
+```
+python helloworld.py
+```
+
+Now, the workflow is executed, and its execution status can be viewed from Conductor UI (http://localhost:5000).
+
+Navigate to the **Executions** tab to view the workflow execution.
+
+<img width="1434" alt="Screenshot 2024-03-18 at 12 30 07" src="https://github.com/Srividhya-S-Subramanian/conductor-python-v1/assets/163816773/11e829b6-d46a-4b47-b2cf-0bf524a6ebdc">
+
+## Running Workflows on Orkes Conductor
+
+For running the workflow in Orkes Conductor,
+
+- Update the Conductor server URL to your cluster name.
+
+```shell
+export CONDUCTOR_SERVER_URL=https://[cluster-name].orkesconductor.io/api
+```
+
+- If you want to run the workflow on the Orkes Conductor Playground, set the Conductor Server variable as follows:
+
+```shell
+export CONDUCTOR_SERVER_URL=https://play.orkes.io/api
+```
+
+- Orkes Conductor requires authentication. [Obtain the key and secret from the Conductor server](https://orkes.io/content/how-to-videos/access-key-and-secret) and set the following environment variables.
+
+```shell
+export CONDUCTOR_AUTH_KEY=your_key
+export CONDUCTOR_AUTH_SECRET=your_key_secret
+```
+
+Run the application and view the execution status from Conductor's UI Console.
+
+> [!NOTE]
+> That's it - you just created and executed your first distributed Python app!
+
+## Learn More about Conductor Python SDK
+
+There are three main ways you can use Conductor when building durable, resilient, distributed applications.
+
+1. Write service workers that implement business logic to accomplish a specific goal - such as initiating payment transfer, getting user information from the database, etc.
+2. Create Conductor workflows that implement application state - A typical workflow implements the saga pattern.
+3. Use Conductor SDK and APIs to manage workflows from your application.
+
+### [Create and Run Conductor Workers](workers.md)
+### [Create Conductor Workflows](workflows.md)
+### [Using Conductor in your Application](conductor_apps.md)

{conductor-python-1.1.4 → conductor_python-1.1.6}/src/conductor/client/http/models/__init__.py

@@ -52,3 +52,4 @@ from conductor.client.http.models.workflow_tag import WorkflowTag
 from conductor.client.http.models.integration import Integration
 from conductor.client.http.models.integration_api import IntegrationApi
 from conductor.client.http.models.state_change_event import StateChangeEvent, StateChangeConfig, StateChangeEventType
+from conductor.client.http.models.workflow_task import CacheConfig

{conductor-python-1.1.4 → conductor_python-1.1.6}/src/conductor/client/http/models/workflow_status.py

@@ -3,6 +3,9 @@ import re  # noqa: F401
 
 import six
 
+terminal_status = ('COMPLETED', 'FAILED', 'TIMED_OUT', 'TERMINATED')
+successful_status = ('PAUSED', 'COMPLETED')
+running_status = ('RUNNING', 'PAUSED')
 
 class WorkflowStatus(object):
     """NOTE: This class is auto generated by the swagger code generator program.
@@ -189,6 +192,21 @@ class WorkflowStatus(object):
 
         return result
 
+    def is_completed(self) -> bool:
+        """Checks if the workflow has completed
+        :return: True if the workflow status is COMPLETED, FAILED or TERMINATED
+        """
+        return self._status in terminal_status
+
+    def is_successful(self) -> bool:
+        """Checks if the workflow has completed in successful state (ie COMPLETED)
+        :return: True if the workflow status is COMPLETED
+        """
+        return self._status in successful_status
+
+    def is_running(self) -> bool:
+        return self.status in running_status
+
     def to_str(self):
         """Returns the string representation of the model"""
         return pprint.pformat(self.to_dict())

{conductor-python-1.1.4 → conductor_python-1.1.6}/src/conductor/client/http/models/workflow_task.py

@@ -7,11 +7,39 @@ import six
 from conductor.client.http.models.state_change_event import StateChangeConfig, StateChangeEventType, StateChangeEvent
 
 
-class WorkflowTask(object):
-    """NOTE: This class is auto generated by the swagger code generator program.
+class CacheConfig(object):
+    swagger_types = {
+        'key': 'str',
+        'ttl_in_second': 'int'
+    }
 
-    Do not edit the class manually.
-    """
+    attribute_map = {
+        'key': 'key',
+        'ttl_in_second': 'ttlInSecond'
+    }
+
+    def __init__(self, key: str, ttl_in_second: int):
+        self._key = key
+        self._ttl_in_second = ttl_in_second
+
+    @property
+    def key(self):
+        return self._key
+
+    @key.setter
+    def key(self, key):
+        self._key = key
+
+    @property
+    def ttl_in_second(self):
+        return self._ttl_in_second
+
+    @ttl_in_second.setter
+    def ttl_in_second(self, ttl_in_second):
+        self._ttl_in_second = ttl_in_second
+
+
+class WorkflowTask(object):
     """
     Attributes:
       swagger_types (dict): The key is attribute name
@@ -50,7 +78,8 @@ class WorkflowTask(object):
         'evaluator_type': 'str',
         'expression': 'str',
         'workflow_task_type': 'str',
-        'on_state_change': 'dict(str, StateChangeConfig)'
+        'on_state_change': 'dict(str, StateChangeConfig)',
+        'cache_config': 'CacheConfig'
     }
 
     attribute_map = {
@@ -84,7 +113,8 @@ class WorkflowTask(object):
         'evaluator_type': 'evaluatorType',
         'expression': 'expression',
         'workflow_task_type': 'workflowTaskType',
-        'on_state_change': 'onStateChange'
+        'on_state_change': 'onStateChange',
+        'cache_config': 'cacheConfig'
     }
 
     def __init__(self, name=None, task_reference_name=None, description=None, input_parameters=None, type=None,
@@ -94,7 +124,8 @@ class WorkflowTask(object):
                  sub_workflow_param=None, join_on=None, sink=None, optional=None, task_definition=None,
                  rate_limited=None, default_exclusive_join_task=None, async_complete=None, loop_condition=None,
                  loop_over=None, retry_count=None, evaluator_type=None, expression=None,
-                 workflow_task_type=None, on_state_change: dict[str, StateChangeConfig] = None):  # noqa: E501
+                 workflow_task_type=None, on_state_change: dict[str, StateChangeConfig] = None,
+                 cache_config: CacheConfig = None):  # noqa: E501
         """WorkflowTask - a model defined in Swagger"""  # noqa: E501
         self._name = None
         self._task_reference_name = None
@@ -128,6 +159,7 @@ class WorkflowTask(object):
         self._workflow_task_type = None
         self.discriminator = None
         self._on_state_change = None
+        self._cache_config = None
         self.name = name
         self.task_reference_name = task_reference_name
         if description is not None:
@@ -188,6 +220,7 @@ class WorkflowTask(object):
             self.workflow_task_type = workflow_task_type
         if on_state_change is not None:
             self._on_state_change = on_state_change
+        self._cache_config = cache_config
 
     @property
     def name(self):
@@ -823,9 +856,17 @@ class WorkflowTask(object):
     @on_state_change.setter
     def on_state_change(self, state_change: StateChangeConfig):
         self._on_state_change = {
-            state_change.type : state_change.events
+            state_change.type: state_change.events
         }
 
+    @property
+    def cache_config(self) -> CacheConfig:
+        return self._cache_config
+
+    @cache_config.setter
+    def cache_config(self, cache_config: CacheConfig):
+        self._cache_config = cache_config
+
     def to_dict(self):
         """Returns the model properties as a dict"""
         result = {}