Add environment modules

[pan-x-c]

Description

Add Environment Modules (Env and its sub-classes)

Env is a key concept of AgentScope, representing global data shared among agents.

Each env has name and value, and multiple envs can be organized into a tree structure, where each env can have multiple children envs and one parent env.

Different implementations of envs may have different event functions, which are marked by @event_func.
Users can bind EventListener to specific event functions, and the listener will be activated when the event function is called.

Similar to AgentBase sub-classes, Env sub-classes also support the to_dist call, and the parameter is the same as AgentBase.

Decouple distribution-related functions from other AgentScope modules

Move to_dist into RpcMeta

RpcMeta is a meta-class that integrates all to_dist related methods/parameters.
Now, to_dist function/parameter can be used directly if the class is a subclass of RpcMeta.
The original to_dist and _AgentMeta is removed.

Extend RpcAgent into RpcObject

RpcObject is an enhanced version of RpcAgent, and can be used to represent any object (unlike RpcAgent which can only represent Agent)
Users can call any public methods or get any attributes on the RpcObject, and the RpcObject will forward the request to the real object running in the RPC server.
The original RpcAgent is removed.

Add @async_func and AsyncResult to replace the reply and Placeholder

Because the RpcObject supports calling any public methods and returns any results, the old Placeholder cannot cover this complex scenario. Therefore, @async_func and AsyncResult are added.

Functions decorated with @async_func will automatically return AsyncResult objects in distributed mode.
The usage of AsyncResult is the same as Placeholder, which is instantiated only when its internal objects are accessed.
AsyncResult can be used to represent any type of data, not just Msg.
The original PlaceholderMessage is removed.

Through the above modification, the agent and message modules are decoupled from the distributed mode.
Note that the user interface of the distributed mode is unchanged, all modifications above are completely hidden from the user, and all previous distributed examples can be run without any modification.

Add Guess Two Third of the Average Game example

The code of "Very Large-Scale Multi-Agent Simulation in AgentScope" is released under examples/paper_large_scale_simulation

Checklist

Please check the following items before code is ready to be reviewed.

• Code has passed all tests
• Docstrings have been added/updated in Google Style
• Documentation has been updated
• Code is ready for review

[DavdGao]

1. Move the environment modules into examples like what rag and react did before, and we should consider to merge it into the library when it's ready.
2. Will it enter an infinite loop? For example, agentA and agentB subscribe to the locations of each other and trigger each other, leading to an endless actions cycle.

agentA move ==> agentB listen ==> agent B move ==> agentA listen ==> agentB move ....

[xieyxclack]

LGTM. Please refer to inline comments

[pan-x-c]

To be discussed

1. the name of distributed functions. In the current version, async_func/sync_func may be confused with async in Python asyncio. unblocking_func / blocking_func may be a better name.
2. the old agent_id is renamed to oid (a short version of object_id), which may cause misunderstandings and incompatibility with legacy code. However, here we really need an id field for all objects, not just agents.

[DavdGao]

Some of my concerns in this PR:

1. The planned deprecation of placeholder may be too extensive. Consider this alternative: create a Mixin class that blocks certain remote function calls (e.g., a configurable reply). This way, the message class (and the env modules) can inherit from it, maintaining the functionality of placeholders without causing confusion in return types from an agent (AsyncResult or Msg).

class RemoteMixin:
    
    _enable: bool = False

    __remote_attrs__ = []

    def __getattr__(self, name):
        if _enable and name in self.__remote_attrs__:
            # ...
        else:
            super().__getattr__(name)

class Msg(RemoteMixin):
    __remote_attrs__ = ['reply', 'observe', 'xxx']
    """Functions/attrs need to be executed/obtained from remote."""

    # ...

2. If feasible, try not to use metaclasses for functionality implementation. They can be challenging for developers to understand.

3. I believe the agent should be the framework's core. Thus, the design of the environment module should align with the agent's settings, not vice versa. For instance, the agent's identity should be independent of the environment and distribution modules.