mojentic 0.8.4__py3-none-any.whl → 1.0.0__py3-none-any.whl

mojentic/async_dispatcher.py

@@ -1,7 +1,6 @@
 import asyncio
 import logging
 from collections import deque
-from typing import Optional, Type
 from uuid import uuid4
 
 import structlog

mojentic/async_dispatcher_spec.py

@@ -1,7 +1,7 @@
 import asyncio
 import pytest
 import pytest_asyncio
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import MagicMock
 
 from mojentic.async_dispatcher import AsyncDispatcher
 from mojentic.event import Event, TerminateEvent

mojentic/context/__init__.py

@@ -1,5 +1,3 @@
 """
 Mojentic context module for managing shared working memory and context.
 """
-
-from .shared_working_memory import SharedWorkingMemory

mojentic/dispatcher.py

@@ -1,7 +1,6 @@
 import logging
 import threading
 from time import sleep
-from typing import Optional, Type
 from uuid import uuid4
 
 import structlog
@@ -18,7 +17,7 @@ class Dispatcher:
         self.event_queue = []
         self._stop_event = threading.Event()
         self._thread = threading.Thread(target=self._dispatch_events)
-        
+
         # Use null_tracer if no tracer is provided
         from mojentic.tracer import null_tracer
         self.tracer = tracer or null_tracer
@@ -49,16 +48,16 @@ class Dispatcher:
                     events = []
                     for agent in agents:
                         logger.debug(f"Sending event to agent {agent}")
-                        
+
                         # Record agent interaction in tracer system
                         self.tracer.record_agent_interaction(
                             from_agent=str(event.source),
                             to_agent=str(type(agent)),
-                                event_type=str(type(event).__name__),
-                                event_id=event.correlation_id,
-                                source=type(self)
-                            )
-                        
+                            event_type=str(type(event).__name__),
+                            event_id=event.correlation_id,
+                            source=type(self)
+                        )
+
                         # Process the event through the agent
                         received_events = agent.receive_event(event)
                         logger.debug(f"Agent {agent} returned {len(events)} events")

mojentic/llm/__init__.py

@@ -3,13 +3,13 @@ Mojentic LLM module for interacting with Large Language Models.
 """
 
 # Main LLM components
-from .llm_broker import LLMBroker
-from .chat_session import ChatSession
-from .message_composers import MessageBuilder, FileTypeSensor
-from .registry.llm_registry import LLMRegistry
+from .llm_broker import LLMBroker  # noqa: F401
+from .chat_session import ChatSession  # noqa: F401
+from .message_composers import MessageBuilder, FileTypeSensor  # noqa: F401
+from .registry.llm_registry import LLMRegistry  # noqa: F401
 
 # Re-export gateway components at the LLM level
-from .gateways.models import (
+from .gateways.models import (  # noqa: F401
     LLMMessage,
     LLMGatewayResponse,
     MessageRole

mojentic/llm/gateways/__init__.py

@@ -3,23 +3,24 @@ Mojentic LLM gateways module for connecting to various LLM providers.
 """
 
 # Gateway implementations
-from .llm_gateway import LLMGateway
-from .ollama import OllamaGateway
-from .openai import OpenAIGateway
-from .anthropic import AnthropicGateway
-from .file_gateway import FileGateway
-from .embeddings_gateway import EmbeddingsGateway
-from .tokenizer_gateway import TokenizerGateway
-
-# Message adapters
-from .anthropic_messages_adapter import adapt_messages_to_anthropic
-from .ollama_messages_adapter import adapt_messages_to_ollama
-from .openai_messages_adapter import adapt_messages_to_openai
+from mojentic.llm.gateways.llm_gateway import LLMGateway
+from mojentic.llm.gateways.ollama import OllamaGateway
+from mojentic.llm.gateways.openai import OpenAIGateway
+from mojentic.llm.gateways.anthropic import AnthropicGateway
+from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
+from mojentic.llm.gateways.embeddings_gateway import EmbeddingsGateway
 
 # Common models
-from .models import (
-    LLMMessage,
-    MessageRole,
-    LLMGatewayResponse,
-    LLMToolCall
-)
+from mojentic.llm.gateways.models import LLMMessage, LLMToolCall, LLMGatewayResponse
+
+__all__ = [
+    "LLMGateway",
+    "OllamaGateway",
+    "OpenAIGateway",
+    "AnthropicGateway",
+    "TokenizerGateway",
+    "EmbeddingsGateway",
+    "LLMMessage",
+    "LLMToolCall",
+    "LLMGatewayResponse",
+]

mojentic/llm/gateways/anthropic.py

@@ -9,6 +9,7 @@ from mojentic.llm.gateways.anthropic_messages_adapter import adapt_messages_to_a
 
 logger = structlog.get_logger()
 
+
 class AnthropicGateway(LLMGateway):
     def __init__(self, api_key: str):
         self.client = Anthropic(api_key=api_key)

mojentic/llm/gateways/anthropic_messages_adapter.py

@@ -1,5 +1,4 @@
 import base64
-import json
 import os
 from typing import List, Any
 

mojentic/llm/gateways/llm_gateway.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Type, Any
+from typing import List, Optional, Type
 
 from pydantic import BaseModel
 

mojentic/llm/gateways/ollama.py

@@ -1,4 +1,4 @@
-from typing import List, Iterator
+from typing import List, Iterator, Optional
 import structlog
 from ollama import Client, Options, ChatResponse
 from pydantic import BaseModel
@@ -9,9 +9,21 @@ from mojentic.llm.gateways.ollama_messages_adapter import adapt_messages_to_olla
 
 logger = structlog.get_logger()
 
+
 class StreamingResponse(BaseModel):
-    """Simple wrapper for streaming response content"""
-    content: str
+    """
+    Wrapper for streaming response chunks.
+
+    Attributes
+    ----------
+    content : Optional[str]
+        Text content chunk from the LLM response.
+    tool_calls : Optional[List]
+        Tool calls from the LLM response (raw ollama format).
+    """
+    content: Optional[str] = None
+    tool_calls: Optional[List] = None
+
 
 class OllamaGateway(LLMGateway):
     """
@@ -144,28 +156,21 @@ class OllamaGateway(LLMGateway):
             'stream': True
         }
 
-        #
-        # This is here 2025-02-21 to demonstrate a deficiency in Ollama tool calling
-        # using the Stream option. We can't get chunk by chunk responses from the LLM
-        # when using tools. This limits our ability to explore streaming capabilities
-        # in the mojentic API, so I'm pausing this work for now until this is resolved.
-        # https://github.com/ollama/ollama/issues/7886
-        #
-
-        # if 'tools' in args and args['tools'] is not None:
-        #     ollama_args['tools'] = [t.descriptor for t in args['tools']]
+        # Enable tool support if tools are provided
+        if 'tools' in args and args['tools'] is not None:
+            ollama_args['tools'] = [t.descriptor for t in args['tools']]
 
         stream = self.client.chat(**ollama_args)
 
         for chunk in stream:
             if chunk.message:
+                # Yield content chunks as they arrive
                 if chunk.message.content:
                     yield StreamingResponse(content=chunk.message.content)
-                # if chunk.message.tool_calls:
-                #     for tool_call in chunk.message.tool_calls:
-                #         yield StreamingResponse(
-                #             content=f"\nTOOL CALL: {tool_call.function.name}({tool_call.function.arguments})\n"
-                #         )
+
+                # Yield tool calls when they arrive
+                if chunk.message.tool_calls:
+                    yield StreamingResponse(tool_calls=chunk.message.tool_calls)
 
     def get_available_models(self) -> List[str]:
         """

mojentic/llm/gateways/openai.py

@@ -1,19 +1,18 @@
 import json
 import os
 from itertools import islice
-from typing import Type, List, Iterable, Optional
+from typing import List, Iterable, Optional, Iterator, Dict
 
 import numpy as np
 import structlog
 from openai import OpenAI, BadRequestError
-from pydantic import BaseModel
 
 from mojentic.llm.gateways.llm_gateway import LLMGateway
-from mojentic.llm.gateways.models import LLMToolCall, LLMGatewayResponse, LLMMessage
+from mojentic.llm.gateways.models import LLMToolCall, LLMGatewayResponse
 from mojentic.llm.gateways.openai_messages_adapter import adapt_messages_to_openai
 from mojentic.llm.gateways.openai_model_registry import get_model_registry, ModelType
 from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
-from mojentic.llm.tools.llm_tool import LLMTool
+from mojentic.llm.gateways.ollama import StreamingResponse
 
 logger = structlog.get_logger()
 
@@ -76,10 +75,10 @@ class OpenAIGateway(LLMGateway):
         capabilities = self.model_registry.get_model_capabilities(model)
 
         logger.debug("Adapting parameters for model",
-                    model=model,
-                    model_type=capabilities.model_type.value,
-                    supports_tools=capabilities.supports_tools,
-                    supports_streaming=capabilities.supports_streaming)
+                     model=model,
+                     model_type=capabilities.model_type.value,
+                     supports_tools=capabilities.supports_tools,
+                     supports_streaming=capabilities.supports_streaming)
 
         # Handle token limit parameter conversion
         if 'max_tokens' in adapted_args:
@@ -88,16 +87,16 @@ class OpenAIGateway(LLMGateway):
                 # Convert max_tokens to max_completion_tokens for reasoning models
                 adapted_args[token_param] = adapted_args.pop('max_tokens')
                 logger.info("Converted token limit parameter for model",
-                           model=model,
-                           from_param='max_tokens',
-                           to_param=token_param,
-                           value=adapted_args[token_param])
+                            model=model,
+                            from_param='max_tokens',
+                            to_param=token_param,
+                            value=adapted_args[token_param])
 
         # Validate tool usage for models that don't support tools
         if 'tools' in adapted_args and adapted_args['tools'] and not capabilities.supports_tools:
             logger.warning("Model does not support tools, removing tool configuration",
-                          model=model,
-                          num_tools=len(adapted_args['tools']))
+                           model=model,
+                           num_tools=len(adapted_args['tools']))
             adapted_args['tools'] = None  # Set to None instead of removing the key
 
         # Handle temperature restrictions for specific models
@@ -107,18 +106,19 @@ class OpenAIGateway(LLMGateway):
             # Check if model supports temperature parameter at all
             if capabilities.supported_temperatures == []:
                 # Model doesn't support temperature parameter at all - remove it
-                logger.warning("Model does not support temperature parameter, removing it",
-                              model=model,
-                              requested_temperature=temperature)
+                logger.warning("Model does not support temperature parameter at all",
+                               model=model,
+                               requested_temperature=temperature)
                 adapted_args.pop('temperature', None)
             elif not capabilities.supports_temperature(temperature):
                 # Model supports temperature but not this specific value - use default
                 default_temp = 1.0
-                logger.warning("Model does not support requested temperature, using default",
-                              model=model,
-                              requested_temperature=temperature,
-                              default_temperature=default_temp,
-                              supported_temperatures=capabilities.supported_temperatures)
+                logger.warning(
+                    "Model does not support requested temperature, using default",
+                    model=model,
+                    requested_temperature=temperature,
+                    default_temperature=default_temp,
+                    supported_temperatures=capabilities.supported_temperatures)
                 adapted_args['temperature'] = default_temp
 
         return adapted_args
@@ -138,13 +138,12 @@ class OpenAIGateway(LLMGateway):
 
         # Warning for tools on reasoning models that don't support them
         if (capabilities.model_type == ModelType.REASONING and
-            not capabilities.supports_tools and
-            'tools' in args and args['tools']):
+                not capabilities.supports_tools and
+                'tools' in args and args['tools']):
             logger.warning(
                 "Reasoning model may not support tools",
                 model=model,
-                num_tools=len(args['tools'])
-            )
+                num_tools=len(args['tools']))
 
         # Validate token limits (check both possible parameter names)
         token_value = args.get('max_tokens') or args.get('max_completion_tokens')
@@ -154,8 +153,7 @@ class OpenAIGateway(LLMGateway):
                     "Requested token limit exceeds model maximum",
                     model=model,
                     requested=token_value,
-                    max_allowed=capabilities.max_output_tokens
-                )
+                    max_allowed=capabilities.max_output_tokens)
 
     def complete(self, **kwargs) -> LLMGatewayResponse:
         """
@@ -218,8 +216,8 @@ class OpenAIGateway(LLMGateway):
             adapted_args = self._adapt_parameters_for_model(model, args)
         except Exception as e:
             logger.error("Failed to adapt parameters for model",
-                        model=model,
-                        error=str(e))
+                         model=model,
+                         error=str(e))
             raise
 
         # Validate parameters after adaptation
@@ -250,25 +248,26 @@ class OpenAIGateway(LLMGateway):
             openai_args['max_completion_tokens'] = adapted_args['max_completion_tokens']
 
         logger.debug("Making OpenAI API call",
-                    model=openai_args['model'],
-                    has_tools='tools' in openai_args,
-                    has_object_model='response_format' in openai_args,
-                    token_param='max_completion_tokens' if 'max_completion_tokens' in openai_args else 'max_tokens')
+                     model=openai_args['model'],
+                     has_tools='tools' in openai_args,
+                     has_object_model='response_format' in openai_args,
+                     token_param='max_completion_tokens' if 'max_completion_tokens' in openai_args else 'max_tokens')
 
         try:
             response = completion(**openai_args)
         except BadRequestError as e:
             # Enhanced error handling for parameter issues
             if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
-                logger.error("Parameter error detected - model may require different token parameter",
-                            model=model,
-                            error=str(e),
-                            suggestion="This model may be a reasoning model requiring max_completion_tokens")
+                logger.error(
+                    "Parameter error detected - model may require different token parameter",
+                    model=model,
+                    error=str(e),
+                    suggestion="This model may be a reasoning model requiring max_completion_tokens")
             raise e
         except Exception as e:
             logger.error("OpenAI API call failed",
-                        model=model,
-                        error=str(e))
+                         model=model,
+                         error=str(e))
             raise e
 
         object = None
@@ -280,11 +279,16 @@ class OpenAIGateway(LLMGateway):
                 if response_content is not None:
                     object = adapted_args['object_model'].model_validate_json(response_content)
                 else:
-                    logger.error("No response content available for object validation", object_model=adapted_args['object_model'])
+                    logger.error(
+                        "No response content available for object validation",
+                        object_model=adapted_args['object_model'])
             except Exception as e:
-                response_content = response.choices[0].message.content if response.choices else "No response content"
-                logger.error("Failed to validate model", error=str(e), response=response_content,
-                           object_model=adapted_args['object_model'])
+                response_content = (response.choices[0].message.content
+                                    if response.choices else "No response content")
+                logger.error("Failed to validate model",
+                             error=str(e),
+                             response=response_content,
+                             object_model=adapted_args['object_model'])
 
         if response.choices[0].message.tool_calls is not None:
             for t in response.choices[0].message.tool_calls:
@@ -301,6 +305,201 @@ class OpenAIGateway(LLMGateway):
             tool_calls=tool_calls,
         )
 
+    def complete_stream(self, **kwargs) -> Iterator[StreamingResponse]:
+        """
+        Stream the LLM response from OpenAI service.
+
+        OpenAI streams tool call arguments incrementally, so we need to accumulate them
+        and yield complete tool calls only when the stream finishes.
+
+        Keyword Arguments
+        ----------------
+        model : str
+            The name of the model to use.
+        messages : List[LLMMessage]
+            A list of messages to send to the LLM.
+        tools : Optional[List[LLMTool]]
+            A list of tools to use with the LLM. Tool calls will be accumulated and yielded when complete.
+        temperature : float, optional
+            The temperature to use for the response. Defaults to 1.0.
+        num_ctx : int, optional
+            The number of context tokens to use. Defaults to 32768.
+        max_tokens : int, optional
+            The maximum number of tokens to generate. Defaults to 16384.
+        num_predict : int, optional
+            The number of tokens to predict. Defaults to no limit.
+
+        Returns
+        -------
+        Iterator[StreamingResponse]
+            An iterator of StreamingResponse objects containing response chunks.
+        """
+        # Extract parameters from kwargs with defaults
+        model = kwargs.get('model')
+        messages = kwargs.get('messages')
+        object_model = kwargs.get('object_model', None)
+        tools = kwargs.get('tools', None)
+        temperature = kwargs.get('temperature', 1.0)
+        num_ctx = kwargs.get('num_ctx', 32768)
+        max_tokens = kwargs.get('max_tokens', 16384)
+        num_predict = kwargs.get('num_predict', -1)
+
+        if not model:
+            raise ValueError("'model' parameter is required")
+        if not messages:
+            raise ValueError("'messages' parameter is required")
+
+        # Convert parameters to dict for processing
+        args = {
+            'model': model,
+            'messages': messages,
+            'object_model': object_model,
+            'tools': tools,
+            'temperature': temperature,
+            'num_ctx': num_ctx,
+            'max_tokens': max_tokens,
+            'num_predict': num_predict
+        }
+
+        # Adapt parameters based on model type
+        try:
+            adapted_args = self._adapt_parameters_for_model(model, args)
+        except Exception as e:
+            logger.error("Failed to adapt parameters for model",
+                         model=model,
+                         error=str(e))
+            raise
+
+        # Validate parameters after adaptation
+        self._validate_model_parameters(model, adapted_args)
+
+        # Check if model supports streaming
+        capabilities = self.model_registry.get_model_capabilities(model)
+        if not capabilities.supports_streaming:
+            raise NotImplementedError(f"Model {model} does not support streaming")
+
+        # Structured output doesn't work with streaming
+        if adapted_args['object_model'] is not None:
+            raise NotImplementedError("Streaming with structured output (object_model) is not supported")
+
+        openai_args = {
+            'model': adapted_args['model'],
+            'messages': adapt_messages_to_openai(adapted_args['messages']),
+            'stream': True,
+        }
+
+        # Add temperature if specified
+        if 'temperature' in adapted_args:
+            openai_args['temperature'] = adapted_args['temperature']
+
+        if adapted_args.get('tools') is not None:
+            openai_args['tools'] = [t.descriptor for t in adapted_args['tools']]
+
+        # Handle both max_tokens (for chat models) and max_completion_tokens (for reasoning models)
+        if 'max_tokens' in adapted_args:
+            openai_args['max_tokens'] = adapted_args['max_tokens']
+        elif 'max_completion_tokens' in adapted_args:
+            openai_args['max_completion_tokens'] = adapted_args['max_completion_tokens']
+
+        logger.debug("Making OpenAI streaming API call",
+                     model=openai_args['model'],
+                     has_tools='tools' in openai_args,
+                     token_param='max_completion_tokens' if 'max_completion_tokens' in openai_args else 'max_tokens')
+
+        try:
+            stream = self.client.chat.completions.create(**openai_args)
+        except BadRequestError as e:
+            if "max_tokens" in str(e) and "max_completion_tokens" in str(e):
+                logger.error(
+                    "Parameter error detected - model may require different token parameter",
+                    model=model,
+                    error=str(e),
+                    suggestion="This model may be a reasoning model requiring max_completion_tokens")
+            raise e
+        except Exception as e:
+            logger.error("OpenAI streaming API call failed",
+                         model=model,
+                         error=str(e))
+            raise e
+
+        # Accumulate tool calls as they stream in
+        # OpenAI streams tool arguments incrementally, indexed by tool call index
+        tool_calls_accumulator: Dict[int, Dict] = {}
+
+        for chunk in stream:
+            if not chunk.choices:
+                continue
+
+            delta = chunk.choices[0].delta
+            finish_reason = chunk.choices[0].finish_reason
+
+            # Yield content chunks as they arrive
+            if delta.content:
+                yield StreamingResponse(content=delta.content)
+
+            # Accumulate tool call chunks
+            if delta.tool_calls:
+                for tool_call_delta in delta.tool_calls:
+                    index = tool_call_delta.index
+
+                    # Initialize accumulator for this tool call if needed
+                    if index not in tool_calls_accumulator:
+                        tool_calls_accumulator[index] = {
+                            'id': None,
+                            'name': None,
+                            'arguments': ''
+                        }
+
+                    # First chunk has id and name
+                    if tool_call_delta.id:
+                        tool_calls_accumulator[index]['id'] = tool_call_delta.id
+
+                    if tool_call_delta.function.name:
+                        tool_calls_accumulator[index]['name'] = tool_call_delta.function.name
+
+                    # All chunks may have argument fragments
+                    if tool_call_delta.function.arguments:
+                        tool_calls_accumulator[index]['arguments'] += tool_call_delta.function.arguments
+
+            # When stream is complete, yield accumulated tool calls
+            if finish_reason == 'tool_calls' and tool_calls_accumulator:
+                # Parse and yield complete tool calls
+                complete_tool_calls = []
+                for index in sorted(tool_calls_accumulator.keys()):
+                    tc = tool_calls_accumulator[index]
+                    try:
+                        # Parse the accumulated JSON arguments
+                        args_dict = json.loads(tc['arguments'])
+                        # Convert to string values as per LLMToolCall format
+                        arguments = {str(k): str(v) for k, v in args_dict.items()}
+
+                        tool_call = LLMToolCall(
+                            id=tc['id'],
+                            name=tc['name'],
+                            arguments=arguments
+                        )
+                        complete_tool_calls.append(tool_call)
+                    except json.JSONDecodeError as e:
+                        logger.error("Failed to parse tool call arguments",
+                                     tool_name=tc['name'],
+                                     arguments=tc['arguments'],
+                                     error=str(e))
+
+                if complete_tool_calls:
+                    # Convert to the format expected by ollama's tool calls for compatibility
+                    # We need to create mock objects that match ollama's structure
+                    from types import SimpleNamespace
+                    ollama_format_calls = []
+                    for tc in complete_tool_calls:
+                        ollama_format_calls.append(SimpleNamespace(
+                            id=tc.id,  # Include ID for proper OpenAI message formatting
+                            function=SimpleNamespace(
+                                name=tc.name,
+                                arguments=tc.arguments
+                            )
+                        ))
+                    yield StreamingResponse(tool_calls=ollama_format_calls)
+
     def get_available_models(self) -> list[str]:
         """
         Get the list of available OpenAI models, sorted alphabetically.

mojentic/llm/gateways/openai_message_adapter_spec.py

@@ -93,11 +93,11 @@ class DescribeOpenAIMessagesAdapter:
             Then it should convert to the correct format with structured content array
             """
             # Patch our own methods that encapsulate external library calls
-            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.read_file_as_binary', 
+            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.read_file_as_binary',
                          return_value=b'fake_image_data')
-            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.encode_base64', 
+            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.encode_base64',
                          return_value='ZmFrZV9pbWFnZV9kYXRhX2VuY29kZWQ=')
-            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.get_image_type', 
+            mocker.patch('mojentic.llm.gateways.openai_messages_adapter.get_image_type',
                          side_effect=lambda path: 'jpg' if path.endswith('.jpg') else 'png')
 
             image_paths = ["/path/to/image1.jpg", "/path/to/image2.png"]

mojentic/llm/gateways/openai_model_registry.py

@@ -6,13 +6,13 @@ their specific parameter requirements and capabilities.
 """
 
 from enum import Enum
-from typing import Dict, Set, Optional, List, TYPE_CHECKING
+from typing import Dict, Optional, List, TYPE_CHECKING
 from dataclasses import dataclass
 
 import structlog
 
 if TYPE_CHECKING:
-    from mojentic.llm.gateways.openai import OpenAIGateway
+    pass
 
 logger = structlog.get_logger()
 
@@ -20,9 +20,9 @@ logger = structlog.get_logger()
 class ModelType(Enum):
     """Classification of OpenAI model types based on their capabilities and parameters."""
     REASONING = "reasoning"  # Models like o1, o3 that use max_completion_tokens
-    CHAT = "chat"           # Standard chat models that use max_tokens
-    EMBEDDING = "embedding" # Text embedding models
-    MODERATION = "moderation" # Content moderation models
+    CHAT = "chat"  # Standard chat models that use max_tokens
+    EMBEDDING = "embedding"  # Text embedding models
+    MODERATION = "moderation"  # Content moderation models
 
 
 @dataclass
@@ -346,6 +346,7 @@ class OpenAIModelRegistry:
 # Global registry instance
 _registry = OpenAIModelRegistry()
 
+
 def get_model_registry() -> OpenAIModelRegistry:
     """Get the global OpenAI model registry instance."""
-    return _registry
+    return _registry