Merge remote-tracking branch 'origin/feature-wf-cr-rs' into feature-wf-cr-rs

Author: orkes-harshil

src/conductor/client/http/api/service_registry_resource_api.py

@@ -57,4 +57,9 @@
 from conductor.client.http.models.workflow_task import CacheConfig
 from conductor.client.http.models.schema_def import SchemaDef
 from conductor.client.http.models.schema_def import SchemaType
-from conductor.client.http.models.signal_response import SignalResponse, TaskStatus
+from conductor.client.http.models.service_registry import ServiceRegistry, OrkesCircuitBreakerConfig, Config, ServiceType
+from conductor.client.http.models.request_param import RequestParam, Schema
+from conductor.client.http.models.proto_registry_entry import ProtoRegistryEntry
+from conductor.client.http.models.service_method import ServiceMethod
+from conductor.client.http.models.circuit_breaker_transition_response import CircuitBreakerTransitionResponse
+from conductor.client.http.models.signal_response import SignalResponse, TaskStatus

src/conductor/client/http/models/__init__.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+from typing import Optional
+import six
+
+
+@dataclass
+class CircuitBreakerTransitionResponse:
+    """Circuit breaker transition response model."""
+
+    swagger_types = {
+        'service': 'str',
+        'previous_state': 'str',
+        'current_state': 'str',
+        'transition_timestamp': 'int',
+        'message': 'str'
+    }
+
+    attribute_map = {
+        'service': 'service',
+        'previous_state': 'previousState',
+        'current_state': 'currentState',
+        'transition_timestamp': 'transitionTimestamp',
+        'message': 'message'
+    }
+
+    service: Optional[str] = None
+    previous_state: Optional[str] = None
+    current_state: Optional[str] = None
+    transition_timestamp: Optional[int] = None
+    message: Optional[str] = None
+
+    def to_dict(self):
+        """Returns the model properties as a dict"""
+        result = {}
+        for attr, _ in six.iteritems(self.swagger_types):
+            value = getattr(self, attr)
+            if isinstance(value, list):
+                result[attr] = list(map(
+                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
+                    value
+                ))
+            elif hasattr(value, "to_dict"):
+                result[attr] = value.to_dict()
+            elif isinstance(value, dict):
+                result[attr] = dict(map(
+                    lambda item: (item[0], item[1].to_dict())
+                    if hasattr(item[1], "to_dict") else item,
+                    value.items()
+                ))
+            else:
+                result[attr] = value
+        return result
+
+    def __str__(self):
+        return f"CircuitBreakerTransitionResponse(service='{self.service}', previous_state='{self.previous_state}', current_state='{self.current_state}', transition_timestamp={self.transition_timestamp}, message='{self.message}')"

src/conductor/client/http/models/circuit_breaker_transition_response.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+from typing import Optional
+import six
+
+
+@dataclass
+class ProtoRegistryEntry:
+    """Protocol buffer registry entry for storing service definitions."""
+
+    swagger_types = {
+        'service_name': 'str',
+        'filename': 'str',
+        'data': 'bytes'
+    }
+
+    attribute_map = {
+        'service_name': 'serviceName',
+        'filename': 'filename',
+        'data': 'data'
+    }
+
+    service_name: str
+    filename: str
+    data: bytes
+
+    def to_dict(self):
+        """Returns the model properties as a dict"""
+        result = {}
+        for attr, _ in six.iteritems(self.swagger_types):
+            value = getattr(self, attr)
+            if isinstance(value, list):
+                result[attr] = list(map(
+                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
+                    value
+                ))
+            elif hasattr(value, "to_dict"):
+                result[attr] = value.to_dict()
+            elif isinstance(value, dict):
+                result[attr] = dict(map(
+                    lambda item: (item[0], item[1].to_dict())
+                    if hasattr(item[1], "to_dict") else item,
+                    value.items()
+                ))
+            else:
+                result[attr] = value
+        return result
+
+    def __str__(self):
+        return f"ProtoRegistryEntry(service_name='{self.service_name}', filename='{self.filename}', data_size={len(self.data)})"

src/conductor/client/http/models/proto_registry_entry.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+from typing import Optional, Any
+import six
+
+
+@dataclass
+class Schema:
+    """Schema definition for request parameters."""
+
+    swagger_types = {
+        'type': 'str',
+        'format': 'str',
+        'default_value': 'object'
+    }
+
+    attribute_map = {
+        'type': 'type',
+        'format': 'format',
+        'default_value': 'defaultValue'
+    }
+
+    type: Optional[str] = None
+    format: Optional[str] = None
+    default_value: Optional[Any] = None
+
+    def to_dict(self):
+        """Returns the model properties as a dict"""
+        result = {}
+        for attr, _ in six.iteritems(self.swagger_types):
+            value = getattr(self, attr)
+            if isinstance(value, list):
+                result[attr] = list(map(
+                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
+                    value
+                ))
+            elif hasattr(value, "to_dict"):
+                result[attr] = value.to_dict()
+            elif isinstance(value, dict):
+                result[attr] = dict(map(
+                    lambda item: (item[0], item[1].to_dict())
+                    if hasattr(item[1], "to_dict") else item,
+                    value.items()
+                ))
+            else:
+                result[attr] = value
+        return result
+
+    def __str__(self):
+        return f"Schema(type='{self.type}', format='{self.format}', default_value={self.default_value})"
+
+
+@dataclass
+class RequestParam:
+    """Request parameter model for API endpoints."""
+
+    swagger_types = {
+        'name': 'str',
+        'type': 'str',
+        'required': 'bool',
+        'schema': 'Schema'
+    }
+
+    attribute_map = {
+        'name': 'name',
+        'type': 'type',
+        'required': 'required',
+        'schema': 'schema'
+    }
+
+    name: Optional[str] = None
+    type: Optional[str] = None  # Query, Header, Path, etc.
+    required: bool = False
+    schema: Optional[Schema] = None
+
+    def to_dict(self):
+        """Returns the model properties as a dict"""
+        result = {}
+        for attr, _ in six.iteritems(self.swagger_types):
+            value = getattr(self, attr)
+            if isinstance(value, list):
+                result[attr] = list(map(
+                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
+                    value
+                ))
+            elif hasattr(value, "to_dict"):
+                result[attr] = value.to_dict()
+            elif isinstance(value, dict):
+                result[attr] = dict(map(
+                    lambda item: (item[0], item[1].to_dict())
+                    if hasattr(item[1], "to_dict") else item,
+                    value.items()
+                ))
+            else:
+                result[attr] = value
+        return result
+
+    def __str__(self):
+        return f"RequestParam(name='{self.name}', type='{self.type}', required={self.required})"

src/conductor/client/http/models/request_param.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+from typing import Optional, List, Dict, Any
+import six
+
+
+@dataclass
+class ServiceMethod:
+    """Service method model matching the Java ServiceMethod POJO."""
+
+    swagger_types = {
+        'id': 'int',
+        'operation_name': 'str',
+        'method_name': 'str',
+        'method_type': 'str',
+        'input_type': 'str',
+        'output_type': 'str',
+        'request_params': 'list[RequestParam]',
+        'example_input': 'dict'
+    }
+
+    attribute_map = {
+        'id': 'id',
+        'operation_name': 'operationName',
+        'method_name': 'methodName',
+        'method_type': 'methodType',
+        'input_type': 'inputType',
+        'output_type': 'outputType',
+        'request_params': 'requestParams',
+        'example_input': 'exampleInput'
+    }
+
+    id: Optional[int] = None
+    operation_name: Optional[str] = None
+    method_name: Optional[str] = None
+    method_type: Optional[str] = None  # GET, PUT, POST, UNARY, SERVER_STREAMING etc.
+    input_type: Optional[str] = None
+    output_type: Optional[str] = None
+    request_params: Optional[List[Any]] = None  # List of RequestParam objects
+    example_input: Optional[Dict[str, Any]] = None
+
+    def __post_init__(self):
+        """Initialize default values after dataclass creation."""
+        if self.request_params is None:
+            self.request_params = []
+        if self.example_input is None:
+            self.example_input = {}
+
+    def to_dict(self):
+        """Returns the model properties as a dict using the correct JSON field names."""
+        result = {}
+        for attr, json_key in six.iteritems(self.attribute_map):
+            value = getattr(self, attr)
+            if value is not None:
+                if isinstance(value, list):
+                    result[json_key] = list(map(
+                        lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
+                        value
+                    ))
+                elif hasattr(value, "to_dict"):
+                    result[json_key] = value.to_dict()
+                elif isinstance(value, dict):
+                    result[json_key] = dict(map(
+                        lambda item: (item[0], item[1].to_dict())
+                        if hasattr(item[1], "to_dict") else item,
+                        value.items()
+                    ))
+                else:
+                    result[json_key] = value
+        return result
+
+    def __str__(self):
+        return f"ServiceMethod(operation_name='{self.operation_name}', method_name='{self.method_name}', method_type='{self.method_type}')"
+
+
+# For backwards compatibility, add helper methods
+@dataclass
+class RequestParam:
+    """Request parameter model (placeholder - define based on actual Java RequestParam class)."""
+
+    name: Optional[str] = None
+    type: Optional[str] = None
+    required: Optional[bool] = False
+    description: Optional[str] = None
+
+    def to_dict(self):
+        return {
+            'name': self.name,
+            'type': self.type,
+            'required': self.required,
+            'description': self.description
+        }