zeroc-ice 3.7.10__cp312-cp312-win_amd64.whl → 3.8.0__cp312-cp312-win_amd64.whl

Ice/IcePyTypes.py

@@ -0,0 +1,47 @@
+# Copyright (c) ZeroC, Inc.
+
+# These are the public types we re-export from IcePy.
+
+from IcePy import (
+    BatchRequest,
+    Connection,
+    ConnectionInfo,
+    EndpointInfo,
+    IPConnectionInfo,
+    IPEndpointInfo,
+    NativePropertiesAdmin,
+    OpaqueEndpointInfo,
+    SSLConnectionInfo,
+    SSLEndpointInfo,
+    TCPConnectionInfo,
+    TCPEndpointInfo,
+    UDPConnectionInfo,
+    UDPEndpointInfo,
+    WSConnectionInfo,
+    WSEndpointInfo,
+    intVersion,
+    loadSlice,
+    stringVersion,
+)
+
+__all__ = [
+    "BatchRequest",
+    "Connection",
+    "ConnectionInfo",
+    "EndpointInfo",
+    "IPConnectionInfo",
+    "IPEndpointInfo",
+    "NativePropertiesAdmin",
+    "OpaqueEndpointInfo",
+    "SSLConnectionInfo",
+    "SSLEndpointInfo",
+    "TCPConnectionInfo",
+    "TCPEndpointInfo",
+    "UDPConnectionInfo",
+    "UDPEndpointInfo",
+    "WSConnectionInfo",
+    "WSEndpointInfo",
+    "intVersion",
+    "loadSlice",
+    "stringVersion",
+]

Ice/Identity.py

@@ -0,0 +1,40 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from dataclasses import dataclass
+
+
+@dataclass(order=True, unsafe_hash=True)
+class Identity:
+    """
+    Represents the identity of an Ice object. It is comparable to the path of a URI. Its string representation is
+    ``name`` when the category is empty, and ``category/name`` when the category is not empty.
+    
+    Attributes
+    ----------
+    name : str
+        The name of the Ice object. An empty name is not valid.
+    category : str
+        The category of the object.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::Ice::Identity``.
+    """
+    name: str = ""
+    category: str = ""
+
+_Ice_Identity_t = IcePy.defineStruct(
+    "::Ice::Identity",
+    Identity,
+    (),
+    (
+        ("name", (), IcePy._t_string),
+        ("category", (), IcePy._t_string)
+    ))
+
+__all__ = ["Identity", "_Ice_Identity_t"]

Ice/IdentitySeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Identity import _Ice_Identity_t
+
+_Ice_IdentitySeq_t = IcePy.defineSequence("::Ice::IdentitySeq", (), _Ice_Identity_t)
+
+__all__ = ["_Ice_IdentitySeq_t"]

Ice/ImplicitContext.py

@@ -0,0 +1,126 @@
+# Copyright (c) ZeroC, Inc.
+
+from typing import final
+
+import IcePy
+
+
+@final
+class ImplicitContext:
+    """
+    An interface to associate implicit contexts with communicators.
+
+    When you make a remote invocation without an explicit context parameter, Ice uses the per-proxy context (if any)
+    combined with the ImplicitContext associated with the communicator.
+
+    Ice provides several implementations of ImplicitContext. The implementation used depends on the value of the
+    `Ice.ImplicitContext` property.
+
+    None (default)
+        No implicit context at all.
+    PerThread
+        The implementation maintains a context per thread.
+    Shared
+        The implementation maintains a single context shared by all threads.
+
+
+    ImplicitContext also provides a number of operations to create, update, or retrieve an entry in the underlying
+    context without first retrieving a copy of the entire context.
+    """
+
+    def __init__(self, impl: IcePy.ImplicitContext):
+        self._impl = impl
+
+    def getContext(self) -> dict[str, str]:
+        """
+        Get a copy of the underlying context.
+
+        Returns
+        -------
+        dict
+            A copy of the underlying context.
+        """
+        return self._impl.getContext()
+
+    def setContext(self, newContext: dict[str, str]):
+        """
+        Set the underlying context.
+
+        Parameters
+        ----------
+        newContext : dict
+            The new context to set.
+        """
+        self._impl.setContext(newContext)
+
+    def containsKey(self, key: str) -> bool:
+        """
+        Check if this key has an associated value in the underlying context.
+
+        Parameters
+        ----------
+        key : str
+            The key to check.
+
+        Returns
+        -------
+        bool
+            True if the key has an associated value, False otherwise.
+        """
+        return self._impl.containsKey(key)
+
+    def get(self, key: str) -> str:
+        """
+        Get the value associated with the given key in the underlying context.
+
+        Returns an empty string if no value is associated with the key. Use `containsKey` to distinguish between an
+        empty-string value and no value at all.
+
+        Parameters
+        ----------
+        key : str
+            The key to retrieve the value for.
+
+        Returns
+        -------
+        str
+            The value associated with the key, or an empty string if no value is associated with the key.
+        """
+        return self._impl.get(key)
+
+    def put(self, key: str, value: str) -> str | None:
+        """
+        Create or update a key/value entry in the underlying context.
+
+        Parameters
+        ----------
+        key : str
+            The key to create or update.
+        value : str
+            The value to associate with the key.
+
+        Returns
+        -------
+        str | None
+            The previous value associated with the key, if any, otherwise None.
+        """
+        return self._impl.put(key, value)
+
+    def remove(self, key: str) -> str | None:
+        """
+        Remove the entry for the given key in the underlying context.
+
+        Parameters
+        ----------
+        key : str
+            The key to remove.
+
+        Returns
+        -------
+        str | None
+            The value associated with the key, if any, otherwise None.
+        """
+        return self._impl.remove(key)
+
+
+__all__ = ["ImplicitContext"]

Ice/InitializationData.py

@@ -0,0 +1,64 @@
+# Copyright (c) ZeroC, Inc.
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from IcePy import BatchRequest, Connection
+
+    from .EventLoopAdapter import EventLoopAdapter
+    from .Logger import Logger
+    from .Properties import Properties
+    from .UserException import UserException
+    from .Value import Value
+
+
+@dataclass
+class InitializationData:
+    """
+    The attributes of this class are used to initialize a new communicator instance.
+
+    Attributes
+    ----------
+    properties : Ice.Properties | None
+        The properties to use for the communicator.
+    logger : Logger | None
+        The logger to use for the communicator.
+    threadStart : Callable[[], None] | None
+        A callable that is invoked for each new Ice thread that is started.
+    threadStop : Callable[[], None] | None
+        A callable that is invoked when an Ice thread is stopped.
+    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.
+    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
+        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.
+    """
+
+    properties: Properties | None = None
+    logger: Logger | None = None
+    threadStart: Callable[[], None] | None = None
+    threadStop: Callable[[], None] | None = None
+    executor: Callable[[Callable[[], None], Connection], None] | None = None
+    batchRequestInterceptor: Callable[[BatchRequest, int, int], None] | None = None
+    eventLoopAdapter: EventLoopAdapter | None = None
+    sliceLoader: Callable[[str], Value | UserException | None] | None = None
+
+
+__all__ = ["InitializationData"]

Ice/IntSeq.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+_Ice_IntSeq_t = IcePy.defineSequence("::Ice::IntSeq", (), IcePy._t_int)
+
+__all__ = ["_Ice_IntSeq_t"]

Ice/InvalidReplicaGroupIdException.py

@@ -0,0 +1,34 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.UserException import UserException
+
+from dataclasses import dataclass
+
+
+@dataclass
+class InvalidReplicaGroupIdException(UserException):
+    """
+    The exception that is thrown when the provided replica group is invalid.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Ice::InvalidReplicaGroupIdException``.
+    """
+
+    _ice_id = "::Ice::InvalidReplicaGroupIdException"
+
+_Ice_InvalidReplicaGroupIdException_t = IcePy.defineException(
+    "::Ice::InvalidReplicaGroupIdException",
+    InvalidReplicaGroupIdException,
+    (),
+    None,
+    ())
+
+setattr(InvalidReplicaGroupIdException, '_ice_type', _Ice_InvalidReplicaGroupIdException_t)
+
+__all__ = ["InvalidReplicaGroupIdException", "_Ice_InvalidReplicaGroupIdException_t"]

Ice/InvocationFuture.py

@@ -0,0 +1,158 @@
+# Copyright (c) ZeroC, Inc.
+
+import logging
+from collections.abc import Callable
+
+import IcePy
+
+from .Future import Future
+from .LocalExceptions import InvocationCanceledException, TimeoutException
+
+
+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.
+
+    This class provides the same functionality as `Future`, with the addition of "sent callbacks," which are invoked
+    when the request is sent.
+    """
+
+    def __init__(self, asyncInvocationContext: IcePy.AsyncInvocationContext):
+        Future.__init__(self)
+        assert asyncInvocationContext
+        self._asyncInvocationContext = asyncInvocationContext
+        self._sent = False
+        self._sentSynchronously = False
+        self._sentCallbacks = []
+
+    def cancel(self) -> bool:
+        """
+        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.
+
+        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, :py:meth:`done` returns ``True``, and attempting to retrieve the result raises an
+        :py:exc:`Ice.InvocationCanceledException`.
+
+        Returns
+        -------
+        bool
+            ``True`` if the operation was successfully cancelled, ``False`` otherwise.
+        """
+        cancelled = Future.cancel(self)
+        if cancelled:
+            self._asyncInvocationContext.cancel()
+        return cancelled
+
+    def is_sent(self) -> bool:
+        """
+        Check if the request has been sent.
+
+        Returns
+        -------
+        bool
+            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.
+
+        Returns
+        -------
+        bool
+            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.
+
+        Parameters
+        ----------
+        fn : Callable
+            The function to execute when the invocation is sent.
+        """
+        with self._condition:
+            if not self._sent:
+                self._sentCallbacks.append(fn)
+                return
+        fn(self._sentSynchronously)
+
+    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.
+
+        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.
+
+        Parameters
+        ----------
+        timeout : int | float, optional
+            Maximum time (in seconds) to wait for the operation to be sent. If `None`, the method waits
+            indefinitely.
+
+        Returns
+        -------
+        bool
+            True if the operation was sent synchronously, otherwise False.
+
+        Raises
+        ------
+        TimeoutException
+            If the operation was not sent within the specified timeout.
+        InvocationCanceledException
+            If the operation was cancelled before it was sent.
+        """
+        with self._condition:
+            if not self._wait(timeout, lambda: not self._sent):
+                raise TimeoutException()
+
+            if self._state == Future.StateCancelled:
+                raise InvocationCanceledException()
+            elif self._exception:
+                raise self._exception
+            else:
+                return self._sentSynchronously
+
+    def set_sent(self, sentSynchronously: bool):
+        callbacks = []
+        with self._condition:
+            if self._sent:
+                return
+
+            self._sent = True
+            self._sentSynchronously = sentSynchronously
+            callbacks = self._sentCallbacks
+            self._sentCallbacks = []
+            self._condition.notify_all()
+
+        for callback in callbacks:
+            try:
+                callback(sentSynchronously)
+            except Exception as ex:
+                logging.getLogger("Ice.Future").exception("sent callback raised exception: %s", ex)
+
+
+__all__ = ["InvocationFuture"]

Ice/LocalException.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+from .Exception import Exception as IceException
+
+
+class LocalException(IceException):
+    """The base class for Ice run-time exceptions."""
+
+    pass
+
+
+__all__ = ["LocalException"]