change some code naming

pywebio/io_ctrl.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 def send_msg(cmd, spec=None):
     msg = dict(command=cmd, spec=spec, coro_id=get_current_task_id())
-    get_current_session().send_task_message(msg)
+    get_current_session().send_task_command(msg)
 
 
 def chose_impl(gen_func):

pywebio/platform/flask.py

@@ -43,7 +43,7 @@ _event_loop = None
 
 
 def _make_response(webio_session: AbstractSession):
-    return jsonify(webio_session.get_task_messages())
+    return jsonify(webio_session.get_task_commands())
 
 
 def _remove_expired_sessions(session_expire_seconds):

pywebio/platform/tornado.py

@@ -27,7 +27,7 @@ def webio_handler(task_func):
             return {}
 
         def send_msg_to_client(self, session: CoroutineBasedSession):
-            for msg in session.get_task_messages():
+            for msg in session.get_task_commands():
                 self.write_message(json.dumps(msg))
 
         def open(self):
@@ -37,10 +37,10 @@ def webio_handler(task_func):
             self._close_from_session_tag = False  # 是否从session中关闭连接
 
             if get_session_implement() is CoroutineBasedSession:
-                self.session = CoroutineBasedSession(task_func, on_task_message=self.send_msg_to_client,
+                self.session = CoroutineBasedSession(task_func, on_task_command=self.send_msg_to_client,
                                                      on_session_close=self.close)
             else:
-                self.session = ThreadBasedSession(task_func, on_task_message=self.send_msg_to_client,
+                self.session = ThreadBasedSession(task_func, on_task_command=self.send_msg_to_client,
                                                   on_session_close=self.close_from_session,
                                                   loop=asyncio.get_event_loop())
 
@@ -144,7 +144,7 @@ def start_server_in_current_thread_session():
         def open(self):
             if SingleSessionWSHandler.session is None:
                 SingleSessionWSHandler.session = DesignatedThreadSession(thread,
-                                                                         on_task_message=self.send_msg_to_client,
+                                                                         on_task_command=self.send_msg_to_client,
                                                                          loop=asyncio.get_event_loop())
                 websocket_conn_opened.set()
             else:

pywebio/session/base.py

@@ -4,7 +4,7 @@ class AbstractSession:
         get_current_session
         get_current_task_id
 
-        send_task_message
+        send_task_command
         next_client_event
         on_task_exception
         register_callback
@@ -12,7 +12,7 @@ class AbstractSession:
 
     由Backend调用：
         send_client_event
-        get_task_messages
+        get_task_command
 
     Task和Backend都可调用：
         close
@@ -30,10 +30,10 @@ class AbstractSession:
     def get_current_task_id():
         raise NotImplementedError
 
-    def __init__(self, target, on_task_message=None, on_session_close=None, **kwargs):
+    def __init__(self, target, on_task_command=None, on_session_close=None, **kwargs):
         raise NotImplementedError
 
-    def send_task_message(self, message):
+    def send_task_command(self, command):
         raise NotImplementedError
 
     def next_client_event(self):
@@ -42,7 +42,7 @@ class AbstractSession:
     def send_client_event(self, event):
         raise NotImplementedError
 
-    def get_task_messages(self):
+    def get_task_commands(self):
         raise NotImplementedError
 
     def close(self):

pywebio/session/coroutinebased.py

@@ -33,8 +33,8 @@ class CoroutineBasedSession(AbstractSession):
     一个PyWebIO任务会话， 由不同的后端Backend创建并维护
 
     WebIOSession是不同的后端Backend与协程交互的桥梁：
-        后端Backend在接收到用户浏览器的数据后，会通过调用 ``send_client_msg`` 来通知会话，进而由WebIOSession驱动协程的运行。
-        协程内在调用输入输出函数后，会调用 ``send_coro_msg`` 向会话发送输入输出消息指令， WebIOSession将其保存并留给后端Backend处理。
+        后端Backend在接收到用户浏览器的数据后，会通过调用 ``send_client_event`` 来通知会话，进而由Session驱动协程的运行。
+        Task内在调用输入输出函数后，会调用 ``send_task_command`` 向会话发送输入输出消息指令， Session将其保存并留给后端Backend处理。
 
     .. note::
         后端Backend在相应on_session_close时关闭连接时，需要保证会话内的所有消息都传送到了客户端
@@ -52,13 +52,13 @@ class CoroutineBasedSession(AbstractSession):
             raise RuntimeError("No current task found in context!")
         return _context.current_task_id
 
-    def __init__(self, coroutine_func, on_task_message=None, on_session_close=None):
+    def __init__(self, coroutine_func, on_task_command=None, on_session_close=None):
         """
         :param coro_func: 协程函数
         :param on_coro_msg: 由协程内发给session的消息的处理函数
         :param on_session_close: 会话结束的处理函数。后端Backend在相应on_session_close时关闭连接时，需要保证会话内的所有消息都传送到了客户端
         """
-        self._on_task_message = on_task_message or (lambda _: None)
+        self._on_task_command = on_task_command or (lambda _: None)
         self._on_session_close = on_session_close or (lambda: None)
         self.unhandled_task_msgs = []
 
@@ -89,16 +89,16 @@ class CoroutineBasedSession(AbstractSession):
                 del self.coros[sub_task.coro_id]
 
     def _on_main_task_finish(self):
-        self.send_task_message(dict(command='close_session'))
+        self.send_task_command(dict(command='close_session'))
         self.close()
 
-    def send_task_message(self, message):
+    def send_task_command(self, command):
         """向会话发送来自协程内的消息
 
-        :param dict message: 消息
+        :param dict command: 消息
         """
-        self.unhandled_task_msgs.append(message)
-        self._on_task_message(self)
+        self.unhandled_task_msgs.append(command)
+        self._on_task_command(self)
 
     async def next_client_event(self):
         res = await WebIOFuture()
@@ -117,7 +117,7 @@ class CoroutineBasedSession(AbstractSession):
 
         self._step_task(coro, event)
 
-    def get_task_messages(self):
+    def get_task_commands(self):
         msgs = self.unhandled_task_msgs
         self.unhandled_task_msgs = []
         return msgs

pywebio/session/threadbased.py

@@ -41,16 +41,16 @@ class ThreadBasedSession(AbstractSession):
     def get_current_task_id():
         return threading.current_thread().getName()
 
-    def __init__(self, target, on_task_message=None, on_session_close=None, loop=None):
+    def __init__(self, target, on_task_command=None, on_session_close=None, loop=None):
         """
         :param target_func: 会话运行的函数
         :param on_coro_msg: 由协程内发给session的消息的处理函数
         :param on_session_close: 会话结束的处理函数。后端Backend在相应on_session_close时关闭连接时，
             需要保证会话内的所有消息都传送到了客户端
-        :param loop: 事件循环。若on_task_message或者on_session_close中有调用使用asyncio事件循环的调用，
+        :param loop: 事件循环。若 on_task_command 或者 on_session_close 中有调用使用asyncio事件循环的调用，
             则需要事件循环实例来将回调在事件循环的线程中执行
         """
-        self._on_task_message = on_task_message or (lambda _: None)
+        self._on_task_command = on_task_command or (lambda _: None)
         self._on_session_close = on_session_close or (lambda: None)
         self._loop = loop
 
@@ -79,7 +79,7 @@ class ThreadBasedSession(AbstractSession):
             except Exception as e:
                 self.on_task_exception()
             finally:
-                self.send_task_message(dict(command='close_session'))
+                self.send_task_command(dict(command='close_session'))
                 self.close()
 
         task_name = '%s-%s' % (target.__name__, random_str(10))
@@ -89,17 +89,17 @@ class ThreadBasedSession(AbstractSession):
 
         thread.start()
 
-    def send_task_message(self, message):
+    def send_task_command(self, command):
         """向会话发送来自协程内的消息
 
-        :param dict message: 消息
+        :param dict command: 消息
         """
         with self._server_msg_lock:
-            self.unhandled_task_msgs.append(message)
+            self.unhandled_task_msgs.append(command)
         if self._loop:
-            self._loop.call_soon_threadsafe(self._on_task_message, self)
+            self._loop.call_soon_threadsafe(self._on_task_command, self)
         else:
-            self._on_task_message(self)
+            self._on_task_command(self)
 
     def next_client_event(self):
         name = threading.current_thread().getName()
@@ -122,7 +122,7 @@ class ThreadBasedSession(AbstractSession):
 
         mq.put(event)
 
-    def get_task_messages(self):
+    def get_task_commands(self):
         with self._server_msg_lock:
             msgs = self.unhandled_task_msgs
             self.unhandled_task_msgs = []
@@ -242,16 +242,16 @@ class ThreadBasedSession(AbstractSession):
 class DesignatedThreadSession(ThreadBasedSession):
     """以指定进程为会话"""
 
-    def __init__(self, thread, on_task_message=None, loop=None):
+    def __init__(self, thread, on_task_command=None, loop=None):
         """
         :param on_coro_msg: 由协程内发给session的消息的处理函数
-        :param on_session_close: 会话结束的处理函数。后端Backend在相应on_session_close时关闭连接时，
+        :param on_task_command: 会话结束的处理函数。后端Backend在相应on_session_close时关闭连接时，
             需要保证会话内的所有消息都传送到了客户端
-        :param loop: 事件循环。若on_task_message或者on_session_close中有调用使用asyncio事件循环的调用，
+        :param loop: 事件循环。若 on_task_command 或者on_session_close中有调用使用asyncio事件循环的调用，
             则需要事件循环实例来将回调在事件循环的线程中执行
 
         """
-        self._on_task_message = on_task_message or (lambda _: None)
+        self._on_task_command = on_task_command or (lambda _: None)
         self._on_session_close = lambda: None
         self._loop = loop