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

Ice/ObjectPrx_forward.py

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

Ice/ObjectSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Value_forward import _Ice_Value_t
+
+_Ice_ObjectSeq_t = IcePy.defineSequence("::Ice::ObjectSeq", (), _Ice_Value_t)
+
+__all__ = ["_Ice_ObjectSeq_t"]

Ice/OperationMode.py

@@ -0,0 +1,47 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from enum import Enum
+
+class OperationMode(Enum):
+    """
+    Specifies if an operation is idempotent, which affects the retry behavior of the Ice client runtime.
+    
+    Enumerators:
+    
+    - Normal:
+        A non-idempotent operation (the default). The Ice client runtime guarantees that it will not violate
+        at-most-once semantics for operations with this mode.
+    
+    - Nonmutating:
+        Equivalent to :class:`Ice.OperationMode.Idempotent`, but deprecated.
+    
+    - Idempotent:
+        An idempotent operation. The Ice client runtime does not guarantee at-most-once semantics for such an
+        operation.
+    
+    Notes
+    -----
+        The Slice compiler generated this enum class from Slice enumeration ``::Ice::OperationMode``.
+    """
+    
+    Normal = 0
+    Nonmutating = 1
+    Idempotent = 2
+
+_Ice_OperationMode_t = IcePy.defineEnum(
+    "::Ice::OperationMode",
+    OperationMode,
+    (),
+    {
+        0: OperationMode.Normal,
+        1: OperationMode.Nonmutating,
+        2: OperationMode.Idempotent,
+    }
+)
+
+__all__ = ["OperationMode", "_Ice_OperationMode_t"]

Ice/Process.py

@@ -0,0 +1,217 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Object import Object
+
+from Ice.ObjectPrx import ObjectPrx
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.OperationMode import OperationMode
+
+from Ice.Process_forward import _Ice_ProcessPrx_t
+
+from abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Ice.Current import Current
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class ProcessPrx(ObjectPrx):
+    """
+    A server application managed by a locator implementation such as IceGrid hosts a Process object and registers a
+    proxy to this object with the locator registry. See :meth:`Ice.LocatorRegistryPrx.setServerProcessProxyAsync`.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Ice::Process``.
+    """
+
+    def shutdown(self, context: dict[str, str] | None = None) -> None:
+        """
+        Initiates a graceful shutdown of the server application.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return Process._op_shutdown.invoke(self, ((), context))
+
+    def shutdownAsync(self, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Initiates a graceful shutdown of the server application.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return Process._op_shutdown.invokeAsync(self, ((), context))
+
+    def writeMessage(self, message: str, fd: int, context: dict[str, str] | None = None) -> None:
+        """
+        Writes a message on the server application's stdout or stderr.
+        
+        Parameters
+        ----------
+        message : str
+            The message to write.
+        fd : int
+            1 for stdout, 2 for stderr.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return Process._op_writeMessage.invoke(self, ((message, fd), context))
+
+    def writeMessageAsync(self, message: str, fd: int, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Writes a message on the server application's stdout or stderr.
+        
+        Parameters
+        ----------
+        message : str
+            The message to write.
+        fd : int
+            1 for stdout, 2 for stderr.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return Process._op_writeMessage.invokeAsync(self, ((message, fd), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> ProcessPrx | None:
+        return checkedCast(ProcessPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[ProcessPrx | None ]:
+        return checkedCastAsync(ProcessPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> ProcessPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> ProcessPrx | None:
+        return uncheckedCast(ProcessPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::Process"
+
+IcePy.defineProxy("::Ice::Process", ProcessPrx)
+
+class Process(Object, ABC):
+    """
+    A server application managed by a locator implementation such as IceGrid hosts a Process object and registers a
+    proxy to this object with the locator registry. See :meth:`Ice.LocatorRegistryPrx.setServerProcessProxyAsync`.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Ice::Process``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::Ice::Process", )
+    _op_shutdown: IcePy.Operation
+    _op_writeMessage: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::Process"
+
+    @abstractmethod
+    def shutdown(self, current: Current) -> None | Awaitable[None]:
+        """
+        Initiates a graceful shutdown of the server application.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def writeMessage(self, message: str, fd: int, current: Current) -> None | Awaitable[None]:
+        """
+        Writes a message on the server application's stdout or stderr.
+        
+        Parameters
+        ----------
+        message : str
+            The message to write.
+        fd : int
+            1 for stdout, 2 for stderr.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+Process._op_shutdown = IcePy.Operation(
+    "shutdown",
+    "shutdown",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    None,
+    ())
+
+Process._op_writeMessage = IcePy.Operation(
+    "writeMessage",
+    "writeMessage",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), IcePy._t_int, False, 0)),
+    (),
+    None,
+    ())
+
+__all__ = ["Process", "ProcessPrx", "_Ice_ProcessPrx_t"]

Ice/ProcessLogger.py

@@ -0,0 +1,25 @@
+# Copyright (c) ZeroC, Inc.
+
+import IcePy
+
+from ._LoggerI import LoggerI
+from .Logger import Logger
+
+__name__ = "Ice"
+
+
+def getProcessLogger() -> Logger:
+    """Returns the default logger object."""
+    logger = IcePy.getProcessLogger()
+    if isinstance(logger, Logger):
+        return logger
+    else:
+        return LoggerI(logger)
+
+
+def setProcessLogger(logger: Logger):
+    """Sets the default logger object."""
+    IcePy.setProcessLogger(logger)
+
+
+__all__ = ["getProcessLogger", "setProcessLogger"]

Ice/Process_forward.py

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

Ice/Properties.py

@@ -0,0 +1,387 @@
+# Copyright (c) ZeroC, Inc.
+
+from typing import Self, final, overload
+
+import IcePy
+
+
+@final
+class Properties:
+    """
+    Represents a set of properties used to configure Ice and Ice-based applications. A property is a key/value pair,
+    where both the key and the value are strings. By convention, property keys should have the form
+    application-name[.category[.sub-category]].name.
+    """
+
+    @overload
+    def __init__(self, args: list[str] | None = None, defaults: Self | None = None): ...
+
+    @overload
+    def __init__(self, *, properties: IcePy.Properties): ...
+
+    def __init__(
+        self, args: list[str] | None = None, defaults: Self | None = None, properties: IcePy.Properties | None = None
+    ):
+        """
+        Initialize a new instance of the Properties class.
+
+        This constructor loads the configuration files specified by the ``Ice.Config`` property or the
+        ``ICE_CONFIG`` environment variable, and then parses Ice properties from ``args``.
+
+        Parameters
+        ----------
+        args : list of str, optional
+            The command-line arguments. Arguments starting with ``--`` and one of the reserved prefixes
+            (``Ice``, ``IceSSL``, etc.) are parsed as properties and removed from the list. If there is
+            an argument starting with ``--Ice.Config``, the specified configuration file is loaded. When
+            the same property is set in both a configuration file and a command-line argument, the
+            command-line setting takes precedence.
+        defaults : dict of (str, str), optional
+            Default values for the new Properties object. Settings in configuration files and command-line
+            arguments override these defaults.
+
+        Notes
+        -----
+        When there is no ``--Ice.Config`` command-line argument, this constructor loads properties from
+        the files specified by the ``ICE_CONFIG`` environment variable.
+
+        Examples
+        --------
+        .. code-block:: python
+            # Create a new empty property set.
+            properties = Ice.Properties()
+
+            # Create a property set from command-line arguments.
+            properties = Ice.Properties(sys.argv)
+
+            # Create a property set using default values.
+            defaultProperties = Ice.Properties()
+            defaultProperties.setProperty("Ice.Trace.Protocol", "1")
+            properties = Ice.Properties(defaults=defaultProperties)
+
+            # Combine command-line parsing with default values.
+            defaultProperties = Ice.Properties()
+            defaultProperties.setProperty("Ice.Trace.Protocol", "1")
+            properties = Ice.Properties(sys.argv, defaultProperties)
+        """
+        if isinstance(properties, IcePy.Properties):
+            self._impl = properties
+        else:
+            self._impl = IcePy.createProperties(args, defaults)
+
+    def getProperty(self, key: str) -> str:
+        """
+        Get a property by key.
+
+        If the property is not set, an empty string is returned.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+
+        Returns
+        -------
+        str
+            The property value, or an empty string if the property is not set.
+        """
+        return self._impl.getProperty(key)
+
+    def getIceProperty(self, key: str) -> str:
+        """
+        Get an Ice property by key.
+
+        If the property is not set, its default value is returned.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+
+        Returns
+        -------
+        str
+            The property value, or the default value if the property is not set.
+
+        Raises
+        ------
+        PropertyException
+            When the property is not a known Ice property.
+        """
+        return self._impl.getIceProperty(key)
+
+    def getPropertyWithDefault(self, key: str, value: str) -> str:
+        """
+        Get a property by key.
+
+        If the property is not set, the given default value is returned.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+        value : str
+            The default value to use if the property does not exist.
+
+        Returns
+        -------
+        str
+            The property value, or the default value if the property does not exist.
+        """
+        return self._impl.getPropertyWithDefault(key, value)
+
+    def getPropertyAsInt(self, key: str) -> int:
+        """
+        Get a property as an integer.
+
+        If the property is not set, 0 is returned.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+
+        Returns
+        -------
+        int
+            The property value interpreted as an integer, or 0 if the property is not set.
+
+        Raises
+        ------
+        PropertyException
+            When the property value is not a valid integer.
+        """
+        return self._impl.getPropertyAsInt(key)
+
+    def getIcePropertyAsInt(self, key: str) -> int:
+        """
+        Get an Ice property as an integer.
+
+        If the property is not set, its default value is returned.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+
+        Returns
+        -------
+        int
+            The property value interpreted as an integer, or the default value if the property is not set.
+
+        Raises
+        ------
+        PropertyException
+            When the property is not a known Ice property or the property value is not a valid integer.
+        """
+        return self._impl.getIcePropertyAsInt(key)
+
+    def getPropertyAsIntWithDefault(self, key: str, value: int) -> int:
+        """
+        Get a property as an integer.
+
+        If the property is not set, the given default value is returned.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+        value : int
+            The default value to use if the property does not exist.
+
+        Returns
+        -------
+        int
+            The property value interpreted as an integer, or the default value if the property does not exist.
+
+        Raises
+        ------
+        PropertyException
+            When the property value is not a valid integer.
+        """
+        return self._impl.getPropertyAsIntWithDefault(key, value)
+
+    def getPropertyAsList(self, key: str) -> list[str]:
+        """
+        Get a property as a list of strings.
+
+        The strings must be separated by whitespace or comma. If the property is not set, an empty list is returned.
+        The strings in the list can contain whitespace and commas if they are enclosed in single or double quotes.
+        If quotes are mismatched, an empty list is returned. Within single or double quotes, you can escape the quote
+        in question with a backslash, e.g., O'Reilly can be written as O'Reilly, "O'Reilly" or 'O\'Reilly'.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+
+        Returns
+        -------
+        list of str
+            The property value interpreted as a list of strings.
+        """
+        return self._impl.getPropertyAsList(key)
+
+    def getIcePropertyAsList(self, key: str) -> list[str]:
+        """
+        Get an Ice property as a list of strings.
+
+        The strings must be separated by whitespace or comma. If the property is not set, its default value is returned.
+        The strings in the list can contain whitespace and commas if they are enclosed in single or double quotes.
+        If quotes are mismatched, the default value is returned. Within single or double quotes, you can escape the quote
+        in question with a backslash, e.g., O'Reilly can be written as O'Reilly, "O'Reilly" or 'O\'Reilly'.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+
+        Returns
+        -------
+        list of str
+            The property value interpreted as a list of strings, or the default value if the property is not set.
+
+        Raises
+        ------
+        PropertyException
+            When the property is not a known Ice property.
+        """
+        return self._impl.getIcePropertyAsList(key)
+
+    def getPropertyAsListWithDefault(self, key: str, value: list[str]) -> list[str]:
+        """
+        Get a property as a list of strings.
+
+        The strings must be separated by whitespace or comma. If the property is not set, the default value is returned.
+        The strings in the list can contain whitespace and commas if they are enclosed in single or double quotes.
+        If quotes are mismatched, the default value is returned. Within single or double quotes, you can escape the quote
+        in question with a backslash, e.g., O'Reilly can be written as O'Reilly, "O'Reilly" or 'O\'Reilly'.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+        value : list of str
+            The default value to use if the property is not set.
+
+        Returns
+        -------
+        list of str
+            The property value interpreted as a list of strings, or the default value if the property is not set.
+        """
+        return self._impl.getPropertyAsListWithDefault(key, value)
+
+    def getPropertiesForPrefix(self, prefix: str) -> dict[str, str]:
+        """
+        Get all properties whose keys begin with the given prefix.
+
+        If the prefix is an empty string, then all properties are returned.
+
+        Parameters
+        ----------
+        prefix : str
+            The prefix to search for (empty string if none).
+
+        Returns
+        -------
+        dict[str, str]
+            The matching property set with keys and values as strings.
+        """
+        return self._impl.getPropertiesForPrefix(prefix)
+
+    def setProperty(self, key: str, value: str) -> None:
+        """
+        Set a property.
+
+        To unset a property, set it to the empty string.
+
+        Parameters
+        ----------
+        key : str
+            The property key.
+        value : str
+            The property value.
+        """
+        self._impl.setProperty(key, value)
+
+    def getCommandLineOptions(self) -> list[str]:
+        """
+        Get a sequence of command-line options that is equivalent to this property set.
+
+        Each element of the returned sequence is a command-line option of the form --key=value.
+
+        Returns
+        -------
+        list of str
+            The command line options for this property set.
+        """
+        return self._impl.getCommandLineOptions()
+
+    def parseCommandLineOptions(self, prefix: str, options: list[str]) -> list[str]:
+        """
+        Convert a sequence of command-line options into properties.
+
+        All options that begin with `--prefix.` are converted into properties. If the prefix is empty, all options that
+        begin with `--` are converted to properties.
+
+        Parameters
+        ----------
+        prefix : str
+            The property prefix, or an empty string to convert all options starting with `--`.
+        options : list of str
+            The command-line options.
+
+        Returns
+        -------
+        list of str
+            The command-line options that do not start with the specified prefix, in their original order.
+        """
+        return self._impl.parseCommandLineOptions(prefix, options)
+
+    def parseIceCommandLineOptions(self, options: list[str]) -> list[str]:
+        """
+        Convert a sequence of command-line options into properties.
+
+        All options that begin with one of the following prefixes are converted into properties: `--Ice`, `--IceBox`,
+        `--IceGrid`, `--IceSSL`, `--IceStorm`, and `--Glacier2`.
+
+        Parameters
+        ----------
+        options : list of str
+            The command-line options.
+
+        Returns
+        -------
+        list of str
+            The command-line options that do not start with one of the listed prefixes, in their original order.
+        """
+        return self._impl.parseIceCommandLineOptions(options)
+
+    def load(self, file: str) -> None:
+        """
+        Load properties from a file.
+
+        Parameters
+        ----------
+        file : str
+            The property file.
+        """
+        self._impl.load(file)
+
+    def clone(self) -> "Properties":
+        """
+        Create a copy of this property set.
+
+        Returns
+        -------
+        Properties
+            A copy of this property set.
+        """
+        return Properties(properties=self._impl.clone())
+
+    def __iter__(self):
+        dict = self._impl.getPropertiesForPrefix("")
+        return iter(dict)
+
+    def __str__(self) -> str:
+        return str(self._impl)