zeroc-ice 3.8.0__cp312-cp312-macosx_10_13_universal2.whl

Ice/ServantLocator.py

@@ -0,0 +1,93 @@
+# Copyright (c) ZeroC, Inc.
+
+from abc import ABC, abstractmethod
+
+from .Current import Current
+from .Object import Object
+
+
+class ServantLocator(ABC):
+    """
+    A servant locator is called by an object adapter to locate a servant that is not found in its active servant map.
+    """
+
+    @abstractmethod
+    def locate(self, current: Current) -> tuple[Object | None, object | None]:
+        """
+        Called before a request is dispatched if a servant cannot be found in the object adapter's active servant map.
+
+        Note that the object adapter does not automatically insert the returned servant into its active servant map.
+        This must be done by the servant locator implementation, if desired. The `locate` method can throw any user
+        exception. If it does, that exception is marshaled back to the client. If the Slice definition for the corresponding
+        operation includes that user exception, the client receives that user exception; otherwise, the client receives
+        `UnknownUserException`.
+
+        If `locate` throws any exception, the Ice runtime does not call `finished`. If you call `locate` from your own code,
+        you must also call `finished` when you have finished using the servant, provided that `locate` returned a non-null
+        servant.
+
+        Parameters
+        ----------
+        current : Current
+            Information about the current operation for which a servant is required.
+
+        Returns
+        -------
+        tuple[Object | None, object | None]
+
+            A tuple containing the following:
+                - retval : Object or None
+                    The located servant, or None if no suitable servant has been found.
+                - cookie : object | None
+                    A "cookie" that will be passed to `finished`.
+
+        Raises
+        ------
+        UserException
+            The implementation can raise a `UserException` and the runtime will marshal it as the result of the invocation.
+        """
+        pass
+
+    @abstractmethod
+    def finished(self, current: Current, servant: Object, cookie: object | None):
+        """
+        Called by the object adapter after a request has been made.
+
+        This operation is only called if `locate` was called prior to the request and returned a non-null servant.
+        This operation can be used for cleanup purposes after a request.
+
+        The `finished` method can throw any user exception. If it does, that exception is marshaled back to the client.
+        If the Slice definition for the corresponding operation includes that user exception, the client receives that user
+        exception; otherwise, the client receives `UnknownUserException`. If both the operation and `finished` throw an
+        exception, the exception thrown by `finished` is marshaled back to the client.
+
+        Parameters
+        ----------
+        current : Current
+            Information about the current operation call for which a servant was located by `locate`.
+        servant : Object
+            The servant that was returned by `locate`.
+        cookie : object | None
+            The cookie that was returned by `locate`.
+
+        Raises
+        ------
+        UserException
+            The implementation can raise a `UserException` and the runtime will marshal it as the result of the invocation.
+        """
+        pass
+
+    @abstractmethod
+    def deactivate(self, category: str):
+        """
+        Called when the object adapter in which this servant locator is installed is destroyed.
+
+        Parameters
+        ----------
+        category : str
+            Indicates for which category the servant locator is being deactivated.
+        """
+        pass
+
+
+__all__ = ["ServantLocator"]

Ice/ServerNotFoundException.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 ServerNotFoundException(UserException):
+    """
+    The exception that is thrown when a server was not found.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Ice::ServerNotFoundException``.
+    """
+
+    _ice_id = "::Ice::ServerNotFoundException"
+
+_Ice_ServerNotFoundException_t = IcePy.defineException(
+    "::Ice::ServerNotFoundException",
+    ServerNotFoundException,
+    (),
+    None,
+    ())
+
+setattr(ServerNotFoundException, '_ice_type', _Ice_ServerNotFoundException_t)
+
+__all__ = ["ServerNotFoundException", "_Ice_ServerNotFoundException_t"]

Ice/ShortSeq.py

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

Ice/SliceChecksumDict.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+_Ice_SliceChecksumDict_t = IcePy.defineDictionary("::Ice::SliceChecksumDict", (), IcePy._t_string, IcePy._t_string)
+
+__all__ = ["_Ice_SliceChecksumDict_t"]

Ice/SliceInfo.py

@@ -0,0 +1,22 @@
+# Copyright (c) ZeroC, Inc.
+
+
+class SliceInfo:
+    """
+    Encapsulates the details of a slice with an unknown type.
+
+    Attributes
+    ----------
+    typeId : str
+        The Slice type ID for this slice.
+    compactId : int
+        The Slice compact type ID for this slice.
+    bytes : bytes
+        The encoded bytes for this slice, including the leading size integer.
+    hasOptionalMembers : bool
+        Whether or not the slice contains optional members.
+    isLastSlice : bool
+        Whether or not this is the last slice.
+    """
+
+    pass

Ice/SlicedData.py

@@ -0,0 +1,14 @@
+# Copyright (c) ZeroC, Inc.
+
+
+class SlicedData:
+    """
+    Holds class slices that cannot be unmarshaled because their types are not known locally.
+
+    Attributes
+    ----------
+    slices : tuple[SliceInfo, ...]
+        The details of each slice, in order of most-derived to least-derived.
+    """
+
+    pass

Ice/StringSeq.py

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

Ice/TCPEndpointType.py

@@ -0,0 +1,11 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+TCPEndpointType = 1
+
+__all__ = ["TCPEndpointType"]

Ice/ToStringMode.py

@@ -0,0 +1,34 @@
+# Copyright (c) ZeroC, Inc.
+
+from enum import Enum
+
+
+class ToStringMode(Enum):
+    """
+    The output mode for xxxToString methods such as identityToString and proxyToString. The actual encoding format for
+    the string is the same for all modes: you don't need to specify an encoding format or mode when reading such a
+    string.
+
+    Enumerators:
+
+    - Unicode:
+          Characters with ordinal values greater than 127 are kept as-is in the resulting string. Non-printable ASCII
+          characters with ordinal values 127 and below are encoded as \\t, \\n (etc.) or \\unnnn.
+
+    - ASCII:
+          Characters with ordinal values greater than 127 are encoded as universal character names in the resulting
+          string \\unnnn for BMP characters and \\Unnnnnnnn for non-BMP characters. Non-printable ASCII characters
+          with ordinal values 127 and below are encoded as \\t, \\n (etc.) or \\unnnn.
+
+    - Compat:
+          Characters with ordinal values greater than 127 are encoded as a sequence of UTF-8 bytes using octal escapes.
+          Characters with ordinal values 127 and below are encoded as \\t, \\n (etc.) or an octal escape. Use this mode
+          to generate strings compatible with Ice 3.6 and earlier.
+    """
+
+    Unicode = 0
+    ASCII = 1
+    Compat = 2
+
+
+__all__ = ["ToStringMode"]

Ice/UDPEndpointType.py

@@ -0,0 +1,11 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+UDPEndpointType = 3
+
+__all__ = ["UDPEndpointType"]

Ice/URIEndpointType.py

@@ -0,0 +1,11 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+URIEndpointType = 0
+
+__all__ = ["URIEndpointType"]

Ice/UnknownSlicedValue.py

@@ -0,0 +1,31 @@
+# Copyright (c) ZeroC, Inc.
+
+import IcePy
+
+from .Value import Value
+
+
+class UnknownSlicedValue(Value):
+    """
+    Unknown sliced value holds an instance of an unknown Slice class type.
+
+    Attributes
+    ----------
+    unknownTypeId : str
+        The type ID of the unknown Slice class type.
+    """
+
+    _ice_type = None  # Will be set after class definition
+    unknownTypeId: str
+
+    def ice_id(self):
+        return self.unknownTypeId
+
+
+IcePy._t_UnknownSlicedValue = IcePy.defineValue(
+    "::Ice::UnknownSlicedValue", UnknownSlicedValue, -1, (), False, None, ()
+)
+
+UnknownSlicedValue._ice_type = IcePy._t_UnknownSlicedValue
+
+__all__ = ["UnknownSlicedValue"]

Ice/UserException.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+from .Exception import Exception as IceException
+
+
+class UserException(IceException):
+    """
+    The base class for all user-defined exceptions.
+    """
+
+    def __str__(self):
+        # Types derived from UserException are data classes. We override __str__ to delegate to the generated __repr__,
+        # since the built-in __str__ from BaseException only works when all arguments are passed to the constructor,
+        # which is not the case for exceptions unmarshalled from the wire.
+        return self.__repr__()
+
+
+__all__ = ["UserException"]

Ice/Util.py

@@ -0,0 +1,170 @@
+# Copyright (c) ZeroC, Inc.
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from typing import TYPE_CHECKING, overload
+
+import IcePy
+
+from .asyncio.EventLoopAdapter import EventLoopAdapter as AsyncIOEventLoopAdapter
+from .Communicator import Communicator
+from .InitializationData import InitializationData
+from .Properties import Properties
+
+if TYPE_CHECKING:
+    import asyncio
+
+    from Ice import Communicator, Identity, InitializationData, Properties, ToStringMode
+
+__name__ = "Ice"
+
+
+@overload
+def initialize(args: list[str] | None = None, eventLoop: asyncio.AbstractEventLoop | None = None) -> Communicator: ...
+
+
+@overload
+def initialize(*, initData: InitializationData | None = None) -> Communicator: ...
+
+
+def initialize(
+    args: list[str] | None = None,
+    eventLoop: asyncio.AbstractEventLoop | None = None,
+    initData: InitializationData | None = None,
+) -> Communicator:
+    """
+    Creates a new communicator. This function is provided for backwards compatibility. New code should call the
+    :class:`Communicator` constructor directly.
+
+    Parameters
+    ----------
+    args : list of str, optional
+        The command-line arguments.
+    eventLoop : asyncio.AbstractEventLoop, optional
+        An asyncio event loop used to run coroutines and wrap futures. This argument and the `initData` argument are
+        mutually exclusive.
+    initData : InitializationData, optional
+        Options for the new communicator. This argument and the `args` argument are mutually exclusive.
+
+    Returns
+    -------
+    Communicator
+        The new communicator.
+    """
+    return Communicator(initData=initData) if initData is not None else Communicator(args, eventLoop)
+
+
+def identityToString(identity: Identity, toStringMode: ToStringMode | None = None) -> str:
+    """
+    Convert an object identity to a string.
+
+    Parameters
+    ----------
+    identity : Ice.Identity
+        The object identity to convert.
+    toStringMode : Ice.ToStringMode, optional
+        Specifies if and how non-printable ASCII characters are escaped in the result.
+
+    Returns
+    -------
+    str
+        The string representation of the object identity.
+    """
+    return IcePy.identityToString(identity, toStringMode)
+
+
+def stringToIdentity(str: str) -> Identity:
+    """
+    Convert a string to an object identity.
+
+    Parameters
+    ----------
+    str : str
+        The string to convert.
+
+    Returns
+    -------
+    Identity
+        The converted object identity.
+
+    Raises
+    ------
+    ParseException
+        If the string cannot be converted to an object identity.
+    """
+    return IcePy.stringToIdentity(str)
+
+
+def createProperties(args: list[str] | None = None, defaults: Properties | None = None) -> Properties:
+    """
+    Creates a property set initialized from command-line arguments and a default property set.
+
+    This function is provided for backwards compatibility. New code should call the :class:`Properties` constructor
+    directly.
+
+    Parameters
+    ----------
+    args : list[str], optional
+        The command-line arguments.
+    defaults : Properties, optional
+        Default values for the new property set.
+
+    Returns
+    -------
+    Properties
+        A new property set.
+    """
+    return Properties(args, defaults)
+
+
+def getSliceDir() -> str | None:
+    """
+    Returns the path to the directory where the Ice Slice files are installed.
+
+    This helper function locates the installation directory for the Ice Slice files,
+    typically used to configure include paths for Slice compilers.
+
+    Returns
+    -------
+    str or None
+        The absolute path to the directory containing the Ice Slice files, or ``None`` if the directory cannot be found.
+    """
+
+    # Get the parent of the directory containing this file (__init__.py).
+    pyHome = os.path.join(os.path.dirname(__file__), "..")
+
+    # Detect setup.py installation in site-packages. The slice files live one level above this file.
+    dir = os.path.join(pyHome, "slice")
+    if os.path.isdir(dir):
+        return dir
+
+    # For an installation from a source distribution the "slice" directory is a sibling of the "python"
+    # directory.
+    dir = os.path.join(pyHome, "..", "slice")
+    if os.path.exists(dir):
+        return os.path.normpath(dir)
+
+    # In a source distribution, the "slice" directory is an extra level higher.
+    dir = os.path.join(pyHome, "..", "..", "slice")
+    if os.path.exists(dir):
+        return os.path.normpath(dir)
+
+    if sys.platform[:5] == "linux":
+        # Check the default Linux location.
+        dir = os.path.join("/", "usr", "share", "ice", "slice")
+        if os.path.exists(dir):
+            return dir
+
+    elif sys.platform == "darwin":
+        # Check the default macOS homebrew location.
+        dir = os.path.join("/", "usr", "local", "share", "ice", "slice")
+        if os.path.exists(dir):
+            return dir
+
+    return None
+
+
+__all__ = ["initialize", "identityToString", "stringToIdentity", "createProperties", "getSliceDir"]

Ice/Value.py

@@ -0,0 +1,59 @@
+# Copyright (c) ZeroC, Inc.
+
+import IcePy
+
+from .SlicedData import SlicedData
+
+
+class Value:
+    """
+    The base class for instances of Slice-defined classes.
+    """
+
+    def ice_id(self) -> str:
+        """
+        Obtain the type ID corresponding to the most-derived Slice interface supported by the target object.
+
+        Returns
+        -------
+        str
+            The type ID.
+        """
+        # Call ice_staticId() on self to get the value from the most-derived class.
+        return self.ice_staticId()
+
+    @staticmethod
+    def ice_staticId() -> str:
+        """
+        Obtain the type ID of this Slice class or interface.
+
+        Returns
+        -------
+        str
+            The type ID.
+        """
+        return "::Ice::Object"
+
+    #
+    # Do not define these here. They will be invoked if defined by a subclass.
+    #
+    # def ice_preMarshal(self):
+    #    pass
+    #
+    # def ice_postUnmarshal(self):
+    #    pass
+
+    def ice_getSlicedData(self) -> SlicedData | None:
+        """
+        Return the sliced data if the value has a preserved-slice base class and has been sliced during
+        un-marshaling of the value. Return None otherwise.
+
+        Returns
+        -------
+        SlicedData | None
+            The sliced data or None.
+        """
+        return getattr(self, "_ice_slicedData", None)
+
+
+IcePy._t_Value = IcePy.defineValue("::Ice::Object", Value, -1, (), False, None, ())

Ice/Value_forward.py

@@ -0,0 +1,7 @@
+# Copyright (c) ZeroC, Inc.
+
+import IcePy
+
+_Ice_Value_t = IcePy.declareValue("::Ice::Object")
+
+__all__ = ["_Ice_Value_t"]

Ice/WSEndpointType.py

@@ -0,0 +1,11 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+WSEndpointType = 4
+
+__all__ = ["WSEndpointType"]

Ice/WSSEndpointType.py

@@ -0,0 +1,11 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+WSSEndpointType = 5
+
+__all__ = ["WSSEndpointType"]

Ice/_ArrayUtil.py

@@ -0,0 +1,51 @@
+# Copyright (c) ZeroC, Inc.
+
+import array
+
+from .Builtin import BuiltinBool, BuiltinByte, BuiltinDouble, BuiltinFloat, BuiltinInt, BuiltinLong, BuiltinShort
+
+BuiltinTypes = [
+    BuiltinBool,
+    BuiltinByte,
+    BuiltinShort,
+    BuiltinInt,
+    BuiltinLong,
+    BuiltinFloat,
+    BuiltinDouble,
+]
+BuiltinArrayTypes = ["b", "b", "h", "i", "q", "f", "d"]
+
+
+def createArray(view: memoryview | None, t: int) -> array.array:
+    if t not in BuiltinTypes:
+        raise ValueError(f"'{t}' is not an array builtin type")
+
+    a = array.array(BuiltinArrayTypes[t])
+    if view is not None:
+        a.frombytes(view)
+    return a
+
+
+try:
+    import numpy
+
+    BuiltinNumpyTypes = [
+        numpy.bool,
+        numpy.int8,
+        numpy.int16,
+        numpy.int32,
+        numpy.int64,
+        numpy.float32,
+        numpy.float64,
+    ]
+
+    def createNumPyArray(view: memoryview | None, t: int) -> numpy.ndarray:
+        if t not in BuiltinTypes:
+            raise ValueError(f"'{t}' is not an array builtin type")
+        if view is not None:
+            return numpy.frombuffer(view.tobytes(), BuiltinNumpyTypes[t])
+        else:
+            return numpy.empty(0, BuiltinNumpyTypes[t])
+
+except ImportError:
+    pass

Ice/_LoggerI.py

@@ -0,0 +1,32 @@
+# Copyright (c) ZeroC, Inc.
+
+from typing import Self, final
+
+import IcePy
+
+from .Logger import Logger
+
+
+@final
+class LoggerI(Logger):
+    def __init__(self, impl: IcePy.Logger):
+        self._impl = impl
+
+    def print(self, message: str):
+        return self._impl.print(message)
+
+    def trace(self, category: str, message: str):
+        return self._impl.trace(category, message)
+
+    def warning(self, message: str):
+        return self._impl.warning(message)
+
+    def error(self, message: str):
+        return self._impl.error(message)
+
+    def getPrefix(self) -> str:
+        return self._impl.getPrefix()
+
+    def cloneWithPrefix(self, prefix: str) -> Logger:
+        logger: IcePy.Logger = self._impl.cloneWithPrefix(prefix)
+        return LoggerI(logger)