zeroc-ice 3.8.0__cp312-cp312-macosx_10_13_universal2.whl

slice/IceGrid/Registry.ice

@@ -0,0 +1,130 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICEGRID_API"]]
+[["cpp:doxygen:include:IceGrid/IceGrid.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceGrid/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Admin.ice"
+#include "Exception.ice"
+#include "Ice/Locator.ice"
+#include "Session.ice"
+
+/// Deploy and manage Ice servers.
+["java:identifier:com.zeroc.IceGrid"]
+module IceGrid
+{
+    /// Determines which load sampling interval to use.
+    enum LoadSample
+    {
+        /// Sample every minute.
+        ["swift:identifier:loadSample1"]
+        LoadSample1,
+
+        /// Sample every five minutes.
+        ["swift:identifier:loadSample5"]
+        LoadSample5,
+
+        /// Sample every fifteen minutes.
+        ["swift:identifier:loadSample15"]
+        LoadSample15
+    }
+
+    /// Finds well-known Ice objects registered with the IceGrid registry.
+    interface Query
+    {
+        /// Finds a well-known object by identity.
+        /// @param id The identity.
+        /// @return A proxy to the well-known object, or null if no such object is registered.
+        ["cpp:const"]
+        idempotent Object* findObjectById(Ice::Identity id);
+
+        /// Finds a well-known object by type. If there are several objects registered for the given type, the object is
+        /// randomly selected.
+        /// @param type The object type.
+        /// @return A proxy to a well-known object with the specified type, or null if no such object is registered.
+        ["cpp:const"]
+        idempotent Object* findObjectByType(string type);
+
+        /// Finds a well-known object by type on the least-loaded node. If the registry does not know which node hosts
+        /// the object (for example, because the object was registered with a direct proxy), the registry assumes the
+        /// object is hosted on a node that has a load average of 1.0.
+        /// @param type The object type.
+        /// @param sample The sampling interval.
+        /// @return A proxy to the well-known object, or null if no such object is registered.
+        ["cpp:const"]
+        idempotent Object* findObjectByTypeOnLeastLoadedNode(string type, LoadSample sample);
+
+        /// Finds all the well-known objects with the given type.
+        /// @param type The object type.
+        /// @return A list of proxies to the well-known objects with the specified type. Can be empty.
+        ["cpp:const"]
+        idempotent Ice::ObjectProxySeq findAllObjectsByType(string type);
+
+        /// Finds all the replicas of a well-known object.
+        /// @param proxy A proxy that identifies the well-known object.
+        /// @return A list of proxies to the replicas of the well-known object specified by @p proxy. Can be empty.
+        ["cpp:const"]
+        idempotent Ice::ObjectProxySeq findAllReplicas(Object* proxy);
+    }
+
+    /// Represents the main entry point into the IceGrid registry service. It provides operations to create sessions
+    /// with the registry.
+    interface Registry
+    {
+        /// Creates a client session.
+        /// @param userId The user ID.
+        /// @param password The password for the given user.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws PermissionDeniedException Thrown when authentication or authorization fails.
+        Session* createSession(string userId, string password)
+            throws PermissionDeniedException;
+
+        /// Creates an administrative session.
+        /// @param userId The user ID.
+        /// @param password The password for the given user.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws PermissionDeniedException Thrown when authentication or authorization fails.
+        AdminSession* createAdminSession(string userId, string password)
+            throws PermissionDeniedException;
+
+        /// Creates a client session from a secure connection.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws PermissionDeniedException Thrown when authentication or authorization fails.
+        Session* createSessionFromSecureConnection()
+            throws PermissionDeniedException;
+
+        /// Creates an administrative session from a secure connection.
+        /// @return A proxy to the newly created session. This proxy is never null.
+        /// @throws PermissionDeniedException Thrown when authentication or authorization fails.
+        AdminSession* createAdminSessionFromSecureConnection()
+            throws PermissionDeniedException;
+
+        /// Gets the session timeout. An Ice 3.7 or earlier client can use this value to determine how often it needs to
+        /// send heartbeats (using ACM) or call {@link Session#keepAlive} (resp. {@link AdminSession#keepAlive}) to keep
+        /// a session alive in the IceGrid registry.
+        /// @return The session timeout (in seconds).
+        ["cpp:const"]
+        ["deprecated"]
+        idempotent int getSessionTimeout();
+    }
+
+    /// Provides access to the {@link Query} and {@link Registry} objects implemented by the IceGrid registry.
+    interface Locator extends Ice::Locator
+    {
+        /// Gets a proxy to the registry object hosted by this IceGrid registry.
+        /// @return A proxy to the registry object. This proxy is never null.
+        ["cpp:const"]
+        idempotent Registry* getLocalRegistry();
+
+        /// Gets a proxy to the query object hosted by this IceGrid registry.
+        /// @return A proxy to the query object. This proxy is never null.
+        ["cpp:const"]
+        idempotent Query* getLocalQuery();
+    }
+}

slice/IceGrid/Session.ice

@@ -0,0 +1,64 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICEGRID_API"]]
+[["cpp:doxygen:include:IceGrid/IceGrid.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceGrid/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Exception.ice"
+#include "Glacier2/Session.ice"
+
+["java:identifier:com.zeroc.IceGrid"]
+module IceGrid
+{
+    interface Registry; // For doc-comments.
+
+    /// Represents a session object used by IceGrid clients to allocate and release objects. Client sessions are created
+    /// either via the {@link Registry} object or via the registry client {@link Glacier2::SessionManager} object.
+    interface Session extends Glacier2::Session
+    {
+        /// Keeps the session alive.
+        ["deprecated:As of Ice 3.8, there is no need to call this operation, and its implementation does nothing."]
+        idempotent void keepAlive();
+
+        /// Allocates an object.
+        /// @param id The identity of the object to allocate.
+        /// @return A proxy to the allocated object. This proxy is never null.
+        /// @throws ObjectNotRegisteredException Thrown when an object with the given identity is not registered with
+        /// the registry.
+        /// @throws AllocationException Thrown when the allocation fails.
+        /// @see #setAllocationTimeout
+        /// @see #releaseObject
+        Object* allocateObjectById(Ice::Identity id)
+            throws ObjectNotRegisteredException, AllocationException;
+
+        /// Allocates an object with the given type.
+        /// @param type The type of the object.
+        /// @return A proxy to the allocated object. This proxy is never null.
+        /// @throws AllocationException Thrown when the allocation fails.
+        /// @see #setAllocationTimeout
+        /// @see #releaseObject
+        Object* allocateObjectByType(string type)
+            throws AllocationException;
+
+        /// Releases an object that was allocated using {@link allocateObjectById} or {@link allocateObjectByType}.
+        /// @param id The identity of the object to release.
+        /// @throws ObjectNotRegisteredException Thrown when an object with the given identity is not registered with
+        /// the registry.
+        /// @throws AllocationException Thrown when the object can't be released. This can happen when the object is not
+        /// allocatable or is not allocated by this session.
+        void releaseObject(Ice::Identity id)
+            throws ObjectNotRegisteredException, AllocationException;
+
+        /// Sets the allocation timeout. When no object is immediately available for an allocation request, the
+        /// implementation of {@link allocateObjectById} and {@link allocateObjectByType} waits for the duration of
+        /// this @p timeout.
+        /// @param timeout The timeout in milliseconds.
+        idempotent void setAllocationTimeout(int timeout);
+    }
+}

slice/IceGrid/UserAccountMapper.ice

@@ -0,0 +1,34 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICEGRID_API"]]
+[["cpp:doxygen:include:IceGrid/IceGrid.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceGrid/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+["java:identifier:com.zeroc.IceGrid"]
+module IceGrid
+{
+    /// The exception that is thrown when a user account for a given session identifier can't be found.
+    exception UserAccountNotFoundException
+    {
+    }
+
+    /// Maps user strings in server descriptors to actual user account names. You can configure the user account mapper
+    /// of an IceGrid node with the property `IceGrid.Node.UserAccountMapper`.
+    interface UserAccountMapper
+    {
+        /// Gets the name of the user account for the given user. This is used by IceGrid nodes to figure out the user
+        /// account to use to run servers.
+        /// @param user The value of the server descriptor's `user` attribute. When this attribute is not defined, and
+        /// the server's activation mode is `session`, the default value for `user` is the session identifier.
+        /// @return The user account name.
+        /// @throws UserAccountNotFoundException Thrown when no user account is found for the given user.
+        string getUserAccount(string user)
+            throws UserAccountNotFoundException;
+    }
+}

slice/IceStorm/IceStorm.ice

@@ -0,0 +1,186 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICESTORM_API"]]
+[["cpp:doxygen:include:IceStorm/IceStorm.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceStorm/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Ice/Identity.ice"
+#include "Metrics.ice"
+
+/// Lightweight publish/subscribe framework, available for all Ice language mappings.
+["java:identifier:com.zeroc.IceStorm"]
+module IceStorm
+{
+    interface Topic;
+
+    /// Information about a topic link.
+    struct LinkInfo
+    {
+        /// The linked topic proxy. This proxy is never null.
+        Topic* theTopic;
+
+        /// The name of the linked topic.
+        string name;
+
+        /// The cost of traversing this link.
+        int cost;
+    }
+
+    /// A sequence of {@link LinkInfo} objects.
+    sequence<LinkInfo> LinkInfoSeq;
+
+    /// Quality of service parameters.
+    /// @see Topic#subscribeAndGetPublisher
+    dictionary<string, string> QoS;
+
+    /// The exception that is thrown when attempting to create a link that already exists.
+    exception LinkExists
+    {
+        /// The name of the linked topic.
+        string name;
+    }
+
+    /// The exception that is thrown when attempting to remove a link that does not exist.
+    exception NoSuchLink
+    {
+        /// The name of the link that does not exist.
+        string name;
+    }
+
+    /// The exception that is thrown when attempting to subscribe a proxy for which a subscription already exists.
+    exception AlreadySubscribed
+    {
+    }
+
+    /// The exception that is thrown when attempting to subscribe with an invalid {@link QoS}.
+    exception BadQoS
+    {
+        /// The reason for the failure.
+        string reason;
+    }
+
+    /// Represents an IceStorm topic. Publishers publish data to a topic (via the topic's publisher object), and
+    /// subscribers subscribe to a topic.
+    /// @see TopicManager
+    interface Topic
+    {
+        /// Gets the name of this topic.
+        /// @return The name of the topic.
+        /// @see TopicManager#create
+        ["cpp:const"]
+        idempotent string getName();
+
+        /// Gets a proxy to a publisher object for this topic. To publish data to a topic, a publisher calls this
+        /// operation and then creates a proxy with the publisher type from this proxy. If a replicated IceStorm
+        /// deployment is used, this call may return a replicated proxy.
+        /// @return A proxy to publish data on this topic. This proxy is never null.
+        ["cpp:const"]
+        idempotent Object* getPublisher();
+
+        /// Gets a non-replicated proxy to a publisher object for this topic. To publish data to a topic, a publisher
+        /// calls this operation and then creates a proxy with the publisher type from this proxy.
+        /// @return A proxy to publish data on this topic. This proxy is never null.
+        ["cpp:const"]
+        idempotent Object* getNonReplicatedPublisher();
+
+        /// Subscribes to this topic.
+        /// @param theQoS The quality of service parameters for this subscription.
+        /// @param subscriber The subscriber's proxy. This proxy cannot be null.
+        /// @return The per-subscriber publisher proxy. This proxy is never null.
+        /// @throws AlreadySubscribed Thrown when @p subscriber is already subscribed.
+        /// @throws BadQoS Thrown when @p theQoS is unavailable or invalid.
+        /// @see #unsubscribe
+        Object* subscribeAndGetPublisher(QoS theQoS, Object* subscriber)
+            throws AlreadySubscribed, BadQoS;
+
+        /// Unsubscribes the provided @p subscriber from this topic.
+        /// @param subscriber A proxy to an existing subscriber. This proxy is never null.
+        /// @see #subscribeAndGetPublisher
+        idempotent void unsubscribe(Object* subscriber);
+
+        /// Creates a link to another topic. All events originating on this topic will also be sent to the other topic.
+        /// @param linkTo The topic to link to. This proxy cannot be null.
+        /// @param cost The cost of the link.
+        /// @throws LinkExists Thrown when a link to @p linkTo already exists.
+        void link(Topic* linkTo, int cost) throws LinkExists;
+
+        /// Destroys a link from this topic to the provided topic.
+        /// @param linkTo The topic to destroy the link to. This proxy cannot be null.
+        /// @throws NoSuchLink Thrown when a link to @p linkTo does not exist.
+        void unlink(Topic* linkTo) throws NoSuchLink;
+
+        /// Gets information on the current links.
+        /// @return A sequence of LinkInfo objects.
+        ["cpp:const"]
+        idempotent LinkInfoSeq getLinkInfoSeq();
+
+        /// Gets the list of subscribers for this topic.
+        /// @return The sequence of Ice identities for the subscriber objects.
+        ["cpp:const"] Ice::IdentitySeq getSubscribers();
+
+        /// Destroys this topic.
+        void destroy();
+    }
+
+    /// A dictionary of topic name to topic proxy.
+    dictionary<string, Topic*> TopicDict;
+
+    /// The exception that is thrown when attempting to create a topic that already exists.
+    exception TopicExists
+    {
+        /// The name of the topic that already exists.
+        string name;
+    }
+
+    /// The exception that is thrown when attempting to retrieve a topic that does not exist.
+    exception NoSuchTopic
+    {
+        /// The name of the topic that does not exist.
+        string name;
+    }
+
+    /// Represents an object that manages topics.
+    /// @see Topic
+    interface TopicManager
+    {
+        /// Creates a new topic.
+        /// @param name The name of the topic.
+        /// @return A proxy to the new topic object. The returned proxy is never null.
+        /// @throws TopicExists Thrown when a topic with the same @p name already exists.
+        Topic* create(string name) throws TopicExists;
+
+        /// Retrieves a topic by name.
+        /// @param name The name of the topic.
+        /// @return A proxy to the topic object. The returned proxy is never null.
+        /// @throws NoSuchTopic Thrown when there is no topic named @p name.
+        idempotent Topic* retrieve(string name) throws NoSuchTopic;
+
+        /// Creates a new topic with the given name, or retrieves the existing topic with this name if it already
+        /// exists.
+        /// @param name The name of the topic.
+        /// @return A proxy to the topic object. The returned proxy is never null.
+        Topic* createOrRetrieve(string name);
+
+        /// Retrieves all topics managed by this topic manager.
+        /// @return A dictionary of string, topic proxy pairs.
+        idempotent TopicDict retrieveAll();
+    }
+
+    /// Provides access to a {@link TopicManager} object via a fixed identity.
+    /// An IceStorm Finder is always registered with identity `IceStorm/Finder`. This allows clients to obtain the
+    /// associated TopicManager proxy with just the endpoint information of the object. For example, you can use the
+    /// Finder proxy `IceStorm/Finder:tcp -h somehost -p 4061` to get the TopicManager proxy
+    /// `MyIceStorm/TopicManager:tcp -h somehost -p 4061`.
+    interface Finder
+    {
+        /// Gets a proxy to the associated {@link TopicManager}. The proxy might point to several replicas.
+        /// @return The topic manager proxy. This proxy is never null.
+        TopicManager* getTopicManager();
+    }
+}

slice/IceStorm/Metrics.ice

@@ -0,0 +1,41 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+[["cpp:dll-export:ICESTORM_API"]]
+[["cpp:doxygen:include:IceStorm/IceStorm.h"]]
+[["cpp:header-ext:h"]]
+
+[["cpp:include:IceStorm/Config.h"]]
+
+[["js:module:@zeroc/ice"]]
+
+#include "Ice/Metrics.ice"
+
+["java:identifier:com.zeroc.IceMX"]
+["swift:identifier:IceStorm"]
+module IceMX
+{
+    /// Provides information about one or more IceStorm topics.
+    class TopicMetrics extends Metrics
+    {
+        /// The number of events published on the topic(s) by publishers.
+        long published = 0;
+
+        /// The number of events forwarded on the topic(s) by IceStorm topic links.
+        long forwarded = 0;
+    }
+
+    /// Provides information about IceStorm subscribers.
+    class SubscriberMetrics extends Metrics
+    {
+        /// The number of queued events.
+        int queued = 0;
+
+        /// The number of outstanding events.
+        int outstanding = 0;
+
+        /// The number of forwarded events.
+        long delivered = 0;
+    }
+}

slice2py.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+
+# Copyright (c) ZeroC, Inc.
+
+import sys
+import Ice
+import IcePy
+
+
+def main():
+    sliceDir = Ice.getSliceDir()
+    # Automatically add the slice dir.
+    if sliceDir is not None:
+        sys.argv.append("-I" + sliceDir)
+    val = IcePy.compileSlice(sys.argv)
+    return int(val)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

zeroc_ice-3.8.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: zeroc-ice
+Version: 3.8.0
+Summary: Ice is a comprehensive RPC framework with support for Python, C++, .NET, Java, JavaScript and more.
+Author-email: "ZeroC, Inc." <info@zeroc.com>
+License-Expression: GPL-2.0-only
+Project-URL: Homepage, https://zeroc.com/ice
+Project-URL: Repository, https://github.com/zeroc-ice/ice
+Project-URL: Documentation, https://code.zeroc.com/ice/3.8/api/python/index.html
+Project-URL: Issues, https://github.com/zeroc-ice/ice/issues
+Project-URL: Changelog, https://github.com/zeroc-ice/ice/blob/main/CHANGELOG-3.8.md
+Keywords: ice,RPC
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Ice for Python
+
+[Examples] | [Documentation] | [API Reference] | [Building from source]
+
+The [Ice framework] provides everything you need to build networked applications,
+including RPC, pub/sub, server deployment, and more.
+
+Ice for Python is the Python implementation of the Ice framework.
+
+## Sample Code
+
+```slice
+// Slice definitions (Greeter.ice)
+
+module VisitorCenter
+{
+    /// Represents a simple greeter.
+    interface Greeter
+    {
+        /// Creates a personalized greeting.
+        /// @param name The name of the person to greet.
+        /// @return The greeting.
+        string greet(string name);
+    }
+}
+```
+
+```python
+# Client application (main.py)
+import Ice
+import asyncio
+import getpass
+import sys
+
+import VisitorCenter
+
+async def main():
+    async with Ice.Communicator(sys.argv, eventLoop=asyncio.get_running_loop()) as communicator:
+        greeter = VisitorCenter.GreeterPrx(communicator, "greeter:tcp -h localhost -p 4061")
+        greeting = await greeter.greetAsync(getpass.getuser())
+        print(greeting)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+```python
+# Server application (main.py)
+
+import Ice
+import chatbot
+import sys
+
+def main():
+    with Ice.Communicator(sys.argv) as communicator:
+        adapter = communicator.createObjectAdapterWithEndpoints("GreeterAdapter", "tcp -p 4061")
+        adapter.add(chatbot.Chatbot(), Ice.Identity(name="greeter"))
+
+        adapter.activate()
+        print("Listening on port 4061...")
+
+        try:
+            communicator.waitForShutdown()
+        except KeyboardInterrupt:
+            print("Caught Ctrl+C, exiting...")
+
+if __name__ == "__main__":
+    main()
+```
+
+```python
+# Greeter implementation (chatbot.py)
+import VisitorCenter
+
+class Chatbot(VisitorCenter.Greeter):
+    def greet(self, name: str, current: Ice.Current) -> str:
+        print(f"Dispatching greet request {{ name = '{name}' }}")
+        return f"Hello, {name}!"
+```
+
+[Examples]: https://github.com/zeroc-ice/ice-demos/tree/3.8/python
+[Documentation]: https://docs.zeroc.com/ice/3.8/python/
+[API Reference]: https://code.zeroc.com/ice/3.8/api/python/index.html
+[Building from source]: ./BUILDING.md
+[Ice framework]: https://github.com/zeroc-ice/ice