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

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 slices of the unknown class, 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,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+TCPEndpointType = 1
+"""
+Identifies TCP endpoints.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::Ice::TCPEndpointType``.
+"""
+
+__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 functions such as :func:`identityToString`.
+    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.
+    """
+
+    Unicode = 0
+    """
+    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 = 1
+    """
+    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 = 2
+    """
+    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.
+    """
+
+
+__all__ = ["ToStringMode"]

Ice/UDPEndpointType.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+UDPEndpointType = 3
+"""
+Identifies UDP endpoints.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::Ice::UDPEndpointType``.
+"""
+
+__all__ = ["UDPEndpointType"]

Ice/URIEndpointType.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+URIEndpointType = 0
+"""
+Identifies endpoints marshaled as URI strings.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::Ice::URIEndpointType``.
+"""
+
+__all__ = ["URIEndpointType"]

Ice/UnknownSlicedValue.py

@@ -0,0 +1,39 @@
+# Copyright (c) ZeroC, Inc.
+
+import IcePy
+
+from .Value import Value
+
+
+class UnknownSlicedValue(Value):
+    """
+    Represents an instance of an unknown class.
+
+    Attributes
+    ----------
+    unknownTypeId : str
+        The Slice type ID of the unknown value.
+    """
+
+    _ice_type = None  # Will be set after class definition
+    unknownTypeId: str
+
+    def ice_id(self) -> str:
+        """
+        Returns the Slice type ID associated with this instance.
+
+        Returns
+        -------
+        str
+            The Slice type ID of the unknown value.
+        """
+        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):
+    """
+    Base class for all exceptions defined in Slice.
+    """
+
+    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,171 @@
+# 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[str] | None, optional
+        The command-line arguments.
+    eventLoop : asyncio.AbstractEventLoop | None, optional
+        An asyncio event loop used to run coroutines and wrap futures.
+    initData : InitializationData | None, optional
+        Options for the new communicator.
+        This argument is mutually exclusive with both the ``args`` and ``eventLoop`` argument.
+
+    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:
+    """
+    Converts an Identity into a string using the specified mode.
+
+    Parameters
+    ----------
+    identity : Ice.Identity
+        The identity.
+    toStringMode : Ice.ToStringMode | None, optional
+        Specifies how to handle non-ASCII characters and non-printable ASCII characters.
+        The default is :const:`Ice.ToStringMode.Unicode`.
+
+    Returns
+    -------
+    str
+        The stringified identity.
+    """
+    return IcePy.identityToString(identity, toStringMode)
+
+
+def stringToIdentity(str: str) -> Identity:
+    """
+    Converts a stringified identity into an Identity.
+
+    Parameters
+    ----------
+    str : str
+        The stringified identity.
+
+    Returns
+    -------
+    Identity
+        An Identity created from the provided string.
+
+    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] | None, optional
+        The command-line arguments.
+    defaults : Properties | None, optional
+        Default values for the new property set.
+
+    Returns
+    -------
+    Properties
+        A new property set.
+    """
+    return Properties(args, defaults)
+
+
+def getSliceDir() -> str | None:
+    """
+    This helper function locates the installation directory for the Ice Slice files, and returns its path.
+    This path is typically used to configure include paths for Slice compilers.
+
+    Returns
+    -------
+    str | None
+        The absolute path of 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:
+        """
+        Returns the Slice type ID of the most-derived class supported by this object.
+
+        Returns
+        -------
+        str
+            The Slice 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:
+        """
+        Returns the Slice type ID of this type.
+
+        Returns
+        -------
+        str
+            The return value is always ``::Ice::Object``.
+        """
+        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:
+        """
+        Gets the sliced data associated with this instance.
+
+        Returns
+        -------
+        SlicedData | None
+            If this value has a preserved-slice base class and has been sliced during unmarshaling, this returns the
+            sliced data; otherwise this returns ``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,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+WSEndpointType = 4
+"""
+Identifies TCP-based WebSocket endpoints.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::Ice::WSEndpointType``.
+"""
+
+__all__ = ["WSEndpointType"]

Ice/WSSEndpointType.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+WSSEndpointType = 5
+"""
+Identifies SSL-based WebSocket endpoints.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::Ice::WSSEndpointType``.
+"""
+
+__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)