zeroc-ice 3.8.0__cp313-cp313-win_amd64.whl → 3.8.0.post1__cp313-cp313-win_amd64.whl

Ice/InitializationData.py

@@ -8,9 +8,8 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from IcePy import BatchRequest, Connection
-
     from .EventLoopAdapter import EventLoopAdapter
+    from .IcePyTypes import BatchRequest, Connection
     from .Logger import Logger
     from .Properties import Properties
     from .UserException import UserException
@@ -20,35 +19,37 @@ if TYPE_CHECKING:
 @dataclass
 class InitializationData:
     """
-    The attributes of this class are used to initialize a new communicator instance.
+    Represents a set of options that you can specify when initializing a communicator.
 
     Attributes
     ----------
     properties : Ice.Properties | None
-        The properties to use for the communicator.
-    logger : Logger | None
-        The logger to use for the communicator.
+        The properties for the communicator.
+        If not ``None``, this corresponds to the object returned by the :func:`Communicator.getProperties` function.
+    logger : Ice.Logger | None
+        The logger for the communicator.
     threadStart : Callable[[], None] | None
-        A callable that is invoked for each new Ice thread that is started.
+        A :class:`Callable` that is invoked whenever the communicator starts a new thread.
     threadStop : Callable[[], None] | None
-        A callable that is invoked when an Ice thread is stopped.
+        A :class:`Callable` that is invoked whenever a thread created by the communicator is about to be destroyed.
     executor : Callable[[Callable[[], None], Connection], None] | None
-        A callable that is invoked when Ice needs to execute an activity. The callable
-        receives two arguments: a callable and an Ice.Connection object. The executor must
-        eventually invoke the callable with no arguments.
-    batchRequestInterceptor : Callable[[BatchRequest, int, int], None] | None
-        A callable that will be invoked when a batch request is queued. The callable receives
-        three arguments: a BatchRequest object, an integer representing the number of requests
-        in the queue, and an integer representing the number of bytes consumed by the requests
-        in the queue. The interceptor must eventually invoke the enqueue method on the BatchRequest object.
+        A :class:`Callable` that the communicator invokes to execute dispatches and async invocation callbacks.
+        The callable receives two arguments: a callable and an Ice.Connection object.
+        The executor must eventually invoke the callable with no arguments.
+    batchRequestInterceptor : Callable[[Ice.BatchRequest, int, int], None] | None
+        A :class:`Callable` that is invoked by the Ice runtime to enqueue a batch request.
+        The callable receives three arguments: a BatchRequest object, an integer representing the number of requests
+        currently in the queue, and an integer representing the number of bytes consumed by the requests in the queue.
+        The interceptor must eventually invoke the enqueue function on the BatchRequest object.
     eventLoopAdapter : Ice.EventLoopAdapter | None
-        An event loop adapter used to run coroutines and wrap futures. If provided. This adapter is responsible for
-        executing coroutines returned by Ice asynchronous dispatch methods and for wrapping Ice futures (from Ice
+        An event loop adapter used to run coroutines and wrap futures. If provided, this adapter is responsible for
+        executing coroutines returned by Ice asynchronous dispatch functions and for wrapping Ice futures (from Ice
         Async APIs) into futures that can be awaited in the application's event loop.
-    sliceLoader : Callable[[str], Value | UserException | None] | None
-        A callable that creates class and exception instances from Slice type IDs. The callable receives a type ID
-        or compact type ID as a string argument and returns a new instance of the class or exception identified by this
-        ID. The implementation returns None when it cannot find the corresponding class.
+    sliceLoader : Callable[[str], Ice.Value | Ice.UserException | None] | None
+        A :class:`Callable` used to create instances of Slice classes and user exceptions.
+        Applications can supply a custom slice loader that the Ice runtime will use during unmarshaling.
+        The callable receives one argument: a type ID or compact type ID (as a string) and returns a new instance of the
+        corresponding class or exception, or ``None`` if no such class or exception could be found.
     """
 
     properties: Properties | None = None

Ice/InvocationFuture.py

@@ -13,12 +13,13 @@ class InvocationFuture(Future):
     """
     A Future object representing the result of an AMI (Asynchronous Method Invocation) request.
 
-    InvocationFuture objects are returned by AMI requests. The application can use an InvocationFuture object to
-    wait for the result of the AMI request or register a callback that will be invoked when the result becomes
-    available.
+    Instances of ``InvocationFuture`` are returned by AMI requests, and applications can either wait for the result
+    of the request to become available, or register a callback which will be invoked when the result becomes available.
 
-    This class provides the same functionality as `Future`, with the addition of "sent callbacks," which are invoked
-    when the request is sent.
+    Notes
+    -----
+    This class provides the same functionality as :class:`Ice.Future` with the addition of "sent callbacks";
+    callbacks which are invoked when the request has been sent.
     """
 
     def __init__(self, asyncInvocationContext: IcePy.AsyncInvocationContext):
@@ -33,16 +34,18 @@ class InvocationFuture(Future):
         """
         Cancels the invocation.
 
-        This method invokes :py:meth:`Future.cancel` to cancel the underlying future. If the cancellation is
-        successful, the associated invocation is also cancelled.
+        This function invokes :func:`Future.cancel` to cancel the underlying future.
+        If the cancellation is successful, the associated invocation is also cancelled.
 
-        Cancelling an invocation prevents a queued invocation from being sent. If the invocation has already been sent,
-        cancellation ensures that any reply from the server is ignored.
+        Cancelling an invocation prevents a queued invocation from being sent.
+        If the invocation has already been sent, cancellation ensures that any reply from the server is ignored.
 
-        Cancellation is a local operation with no effect on the server.
+        After cancellation, :func:`done` returns ``True``, and attempting to retrieve the result raises an
+        :class:`Ice.InvocationCanceledException`.
 
-        After cancellation, :py:meth:`done` returns ``True``, and attempting to retrieve the result raises an
-        :py:exc:`Ice.InvocationCanceledException`.
+        Notes
+        -----
+        Cancellation is a local operation with no effect on the server.
 
         Returns
         -------
@@ -56,40 +59,38 @@ class InvocationFuture(Future):
 
     def is_sent(self) -> bool:
         """
-        Check if the request has been sent.
+        Checks if the request has been sent.
 
         Returns
         -------
         bool
-            True if the request has been sent, otherwise False.
+            ``True`` if the request has been sent, otherwise ``False``.
         """
         with self._condition:
             return self._sent
 
     def is_sent_synchronously(self) -> bool:
         """
-        Check if the request was sent synchronously.
+        Checks if the request was sent synchronously.
 
         Returns
         -------
         bool
-            True if the request was sent synchronously, otherwise False.
+            ``True`` if the request was sent synchronously, otherwise ``False``.
         """
         with self._condition:
             return self._sentSynchronously
 
     def add_sent_callback(self, fn: Callable[[bool], None]) -> None:
         """
-        Attach a callback to be executed when the invocation is sent.
-
-        The callback `fn` is called with a boolean argument, indicating whether the invocation was sent synchronously.
-
-        If the future has already been sent, `fn` is called immediately from the calling thread.
+        Attaches a callback function which will be called when the invocation is sent.
+        If the invocation has already been sent, ``fn`` is called immediately from the calling thread.
 
         Parameters
         ----------
-        fn : Callable
+        fn : Callable[[bool], None]
             The function to execute when the invocation is sent.
+            It accepts a single boolean argument which is only ``True`` if the invocation was sent synchronously.
         """
         with self._condition:
             if not self._sent:
@@ -99,31 +100,27 @@ class InvocationFuture(Future):
 
     def sent(self, timeout: int | float | None = None) -> bool:
         """
-        Wait for the operation to be sent.
-
-        This method waits up to `timeout` seconds for the operation to be sent and then returns
-        whether it was sent synchronously.
+        Waits until the invocation has been sent.
 
-        If the operation has not been sent within the specified time, a `TimeoutException` is raised.
-        If the future was cancelled before being sent, an `InvocationCanceledException` is raised.
+        If the invocation has not been sent, this function will wait up to ``timeout``-many seconds for it to send.
 
         Parameters
         ----------
-        timeout : int | float, optional
-            Maximum time (in seconds) to wait for the operation to be sent. If `None`, the method waits
-            indefinitely.
+        timeout : int | float | None, optional
+            Maximum time (in seconds) to wait for the invocation to be sent.
+            If ``None`` (the default), this function waits indefinitely.
 
         Returns
         -------
         bool
-            True if the operation was sent synchronously, otherwise False.
+            ``True`` if the invocation was sent synchronously, otherwise ``False``.
 
         Raises
         ------
         TimeoutException
-            If the operation was not sent within the specified timeout.
+            If the invocation was not sent within the specified timeout.
         InvocationCanceledException
-            If the operation was cancelled before it was sent.
+            If the invocation was cancelled before it was sent.
         """
         with self._condition:
             if not self._wait(timeout, lambda: not self._sent):

Ice/LocalException.py

@@ -4,7 +4,7 @@ from .Exception import Exception as IceException
 
 
 class LocalException(IceException):
-    """The base class for Ice run-time exceptions."""
+    """Base class for all Ice exceptions not defined in Slice."""
 
     pass