cloudoll 2.2.37__tar.gz → 2.3.0__tar.gz

{cloudoll-2.2.37 → cloudoll-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: cloudoll
-Version: 2.2.37
+Version: 2.3.0
 Summary: 辅助快速创建可分布的微服务。
 Home-page: https://gitee.com/chuchur/cloudoll-py
 Author: chuchur
@@ -29,6 +29,17 @@ Requires-Dist: aiohttp_session[secure]
 Requires-Dist: PyYAML
 Requires-Dist: click
 Requires-Dist: envyaml
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 # cloudoll 云端玩具

cloudoll-2.3.0/cloudoll/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.3.0"

cloudoll-2.3.0/cloudoll/cli.py

@@ -0,0 +1,76 @@
+import click
+import asyncio
+import os
+import sys
+from .logging import print_error
+from . import __version__
+from typing import Any
+from .utils.cli_main import run_app, run_gen
+sys.path.append(os.path.abspath("."))
+
+
+@click.group()
+@click.version_option(__version__, "-V", "--version", prog_name="cloudoll")
+def cli() -> None:
+    pass
+
+
+life_cycle = ["on_startup", "on_shutdown", "on_cleanup", "cleanup_ctx"]
+
+
+@cli.command()
+@click.option("-p", "--path", help="Model's relative path,save models or create tables", default="models.py",)
+@click.option("-c", "--create", help="For create model or table, model / table", default="model")
+@click.option("-t", "--table", help="Table's name or Model's name, split by `,` or 'ALL'", required=True,)
+@click.option("-env", "--environment", help="Environment, local / test / prod", default="local")
+@click.option("-db", "--database", help="Database name, pick the database in conf.{env}.yaml", default="mysql",)
+def gen(**config: Any) -> None:
+    """Help to create models or tables."""
+
+    # click.echo(create)
+    async def start():
+        try:
+            sa = await run_gen(**config)
+        except Exception as e:
+            # traceback.print_exc()
+            print_error('Error: %s', e)
+            click.echo("input `cloudoll --help` for more helps.")
+        finally:
+            await sa.close()
+
+    asyncio.run(start())
+
+
+@cli.command()
+@click.option("-env", "--environment", help="Environment, local / test / prod", default="local")
+@click.option("-p", "--port", help="Server's port", default=None)
+@click.option("-h", "--host", help="Server's host", default=None)
+@click.option("-m", "--mode", help="development or production mode", default='development')
+@click.option("-path", "--path", help="Unix file system path to serve on. Specifying a path will cause hostname and port arguments to be ignored.",)
+@click.option("-e", "--entry", help="Entry point model name. delfault name app", default="app")
+def start(**config: Any) -> None:
+    """Start a services."""
+    try:
+        active_config = {k: v for k, v in config.items() if v is not None}
+        run_app(**active_config)
+    except Exception as e:
+        print_error('Error: %s', e)
+        # traceback.format_exc()
+        sys.exit(2)
+
+
+_project_existing = click.Path(dir_okay=True)
+
+
+@cli.command()
+@click.argument("project-name", type=_project_existing, required=True)
+def create(project_name) -> None:
+    full_path = os.path.join(os.path.abspath("."), project_name)
+    # log = logging.getLogger('cloudoll.create')
+    if os.path.exists(full_path):
+        print_error(f"Project name `{project_name}` already exist.")
+        # return None
+
+
+if __name__ == "__main__":
+    cli()

{cloudoll-2.2.37 → cloudoll-2.3.0}/cloudoll/logging/__init__.py

@@ -42,10 +42,10 @@ class ColorAnsi:
 _FORMATS = {
     # 终端输出格式
     # "console_format": "%(log_color)s[%(levelname)s]-%(asctime)s-%(pathname)s-%(module)s-%(funcName)s-[line:%(lineno)d]: %(message)s",
-    "console_format": "%(log_color)s%(asctime)s %(levelname)s %(funcName)s %(message)s",
+    "console_format": "%(log_color)s%(asctime)s %(levelname)s %(message)s",
     # 日志输出格式
     # "log_format": "[%(levelname)s]-%(asctime)s-%(pathname)s-%(module)s-%(funcName)s-[line:%(lineno)d]: %(message)s",
-    "log_format": "%(asctime)s %(levelname)s %(funcName)s %(message)s",
+    "log_format": "%(asctime)s %(levelname)s %(message)s",
 }
 
 _LOG_SIZE = 1024 * 1024 * 1  # 1MB 日志最大1MB

{cloudoll-2.2.37 → cloudoll-2.3.0}/cloudoll/orm/__init__.py

@@ -44,7 +44,7 @@ async def create_engine(**kw):
             url = f"{driver}://{configs['username']}:{configs['password']}@{configs['host']}:{configs['port']}/{configs['db']}"
         return await aioredis.from_url(url, **query)
     else:
-        print_error("Not suport this database type.")
+        raise "Not suport this database type."
 
 
 class Postgres(MeteBase):

{cloudoll-2.2.37 → cloudoll-2.3.0}/cloudoll/orm/model.py

@@ -1,5 +1,5 @@
 from .field import Field, Function, Expression
-from ..logging import print_warn
+from ..logging import warning
 from functools import reduce
 import operator
 import copy
@@ -35,13 +35,13 @@ class ModelMetaclass(type):
                 # mappings[k] = v
                 if v.primary_key:
                     if primary_key:
-                        print_warn(f"Duplicate primary key for {table_name}")
+                        warning(f"Duplicate primary key for {table_name}")
                     primary_key = k
                 # else:
                 fields.append(k)
 
         if not primary_key:
-            print_warn(f"{table_name} Missing primary key")
+            warning(f"{table_name} Missing primary key")
 
         # for k in mappings.keys():
         #     attrs.pop(k)

cloudoll-2.3.0/cloudoll/utils/cli_main.py

@@ -0,0 +1,72 @@
+from typing import Any
+from ..web.settings import get_config
+from ..logging import print_info
+from .common import Object, chainMap
+from .watch import AppTask
+from aiohttp import web
+from ..web import app
+from pathlib import Path
+from .m2d import create_models, create_tables
+from ..orm import create_engine
+import os
+
+
+def run_app(**config_kwargs: Any):
+    config = Object(config_kwargs)
+    print_info("Current mode: ", config.mode)
+    app_config = get_config(config.environment)
+    # print(environment, host, port, mode, path, entry)
+    # return
+    if config.mode == 'production':
+        App = app.create(env=config.environment, config=app_config, entry_model=config.entry)
+        App.run()
+    else:
+        aux_app = web.Application(
+            logger=None,
+        )
+        defaults = {"host": "0.0.0.0", "port": 9001, "path": None}
+        conf_server = app_config.get("server", {})
+        env_server = {"host": config.host, "port": config.port, "path": config.path}
+        server = chainMap(defaults, conf_server, env_server)
+        app_config["server"] = server
+        aux_port = int(server.port) + 1
+        task = AppTask(Path(".").resolve(), app_config, entry=config.entry, env=config.environment)
+        aux_app.cleanup_ctx.append(task.cleanup_ctx)
+        web.run_app(
+            aux_app,
+            access_log=None,
+            host=config.host,
+            port=aux_port,
+            print=None,
+            shutdown_timeout=0.1,
+        )
+
+
+async def run_gen(**config_kwargs: Any):
+    config = Object(config_kwargs)
+    configs = get_config(config.environment)
+    db_configs = configs.get("database")
+    if db_configs is None:
+        raise KeyError(
+            f"Can't find the database config in conf.{config.environment}.yaml"
+        )
+    db_config = db_configs.get(config.database)
+    if db_config is None:
+        raise KeyError(
+            f"Can't find the database config key ->{config.database} in conf.{config.environment}.yaml"
+        )
+    sa = await create_engine(**db_config)
+    if sa.pool is None:
+        return
+    model_path = os.path.join(os.path.abspath("."), config.path)
+    tables = None
+    if config.table != "ALL":
+        tables = config.table.split(",")
+
+    if config.create == "model":
+        await create_models(sa, config.path, tables=tables)
+        print_info(f"Model save at:{model_path}")
+    elif config.create == "table":
+        if model_path is None:
+            raise ValueError("Need package name or model name.")
+        await create_tables(sa, model_path, tables=tables)

cloudoll-2.3.0/cloudoll/utils/common.py

@@ -0,0 +1,51 @@
+import asyncio
+class Object(dict):
+    # __setattr__ = dict.__setitem__
+    # __getattr__ = dict.__getitem__
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def __getattr__(self, key):
+        return self.get(key, None)
+    
+    def __delattr__(self, key):
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(f"'DotDict' object has no attribute '{key}'")
+    
+    def __getstate__(self):
+        '''to fix pickle.dumps '''
+        return dict(self)
+
+    def __setstate__(self, state):
+        self.update(state)
+
+def chainMap(*dicts):
+    merged_dict = Object()
+    for d in dicts:
+        for key, value in d.items():
+            if key not in merged_dict or value is not None:
+                merged_dict[key] = value
+    return merged_dict
+
+
+async def check_port_open(port: int, delay: float = 1) -> None:
+    loop = asyncio.get_running_loop()
+    # the "s = socket.socket; s.bind" approach sometimes says a port is in use when it's not
+    # this approach replicates aiohttp so should always give the same answer
+    for i in range(5, 0, -1):
+        try:
+            server = await loop.create_server(
+                asyncio.Protocol, host="0.0.0.0", port=port
+            )
+        except OSError as e:
+            if e.errno != EADDRINUSE:
+                raise
+            warning("port %d is already in use, waiting %d...", port, i)
+            await asyncio.sleep(delay)
+        else:
+            server.close()
+            await server.wait_closed()
+            return
+    raise Exception("The port {} is already is use".format(port))

{cloudoll-2.2.37 → cloudoll-2.3.0}/cloudoll/utils/watch.py

@@ -1,6 +1,6 @@
-from typing import AsyncIterator, Iterable, Optional, Tuple, Union
+from typing import AsyncIterator, Optional, Union
 from pathlib import Path
-from ..web import Application, app, check_port_open
+from ..web import Application, app
 import asyncio
 import os
 import signal
@@ -8,12 +8,13 @@ import sys
 from contextlib import suppress
 from multiprocessing import Process
 from watchfiles import awatch, DefaultFilter
-from ..logging import print_info, print_warn
+from ..logging import info, warning, error
 import contextlib
-from typing import Any, Iterator, Optional, NoReturn
-from typing import TYPE_CHECKING, Optional, Sequence, Union
+from typing import Iterator, Optional
+from typing import Optional, Union
 from aiohttp import web
-
+import traceback
+from .common import check_port_open
 
 class CloudollFilter(DefaultFilter):
     def __init__(self, ignore_dirs: tuple = None) -> None:
@@ -89,9 +90,7 @@ def mian_app(tty_path, config, entry, env):
             loop = asyncio.new_event_loop()
             runner = loop.run_until_complete(create_main_app(config, entry, env))
             try:
-                loop.run_until_complete(
-                    start_main_app(runner, config["server"]["port"])
-                )
+                loop.run_until_complete(start_main_app(runner, config["server"]["port"]))
                 loop.run_forever()
             except KeyboardInterrupt:
                 pass
@@ -109,6 +108,8 @@ async def create_main_app(config, entry, env):
 async def start_main_app(runner, port):
     await runner.setup()
     site = web.TCPSite(runner, host="0.0.0.0", port=port)
+    info(f"Server running on http://0.0.0.0:{port}")
+    info("(Press CTRL+C to quit)")
     await site.start()
 
 
@@ -123,26 +124,23 @@ class AppTask(WatchTask):
 
     async def _run(self) -> None:
         assert self._app is not None
+        self._start_dev_server()
         try:
-            self._start_dev_server()
-
             async for changes in self._awatch:
                 self._reloads += 1
                 if any(f.endswith(".py") for _, f in changes):
-                    print_info(f"{len(changes)} changes, restarting server")
+                    info(f"{len(changes)} changes, restarting server")
                     await self._stop_dev_server()
                     self._start_dev_server()
                     await asyncio.sleep(1)
         except Exception as exc:
-            # exception(exc)
+            traceback.print_exc()
+
             raise Exception("error running dev server")
 
     def _start_dev_server(self) -> None:
         act = "Start" if self._reloads == 0 else "Restart"
-        print_info(f"{act}ing dev server")
-        print_info(
-            f"Server Running on http://{self._config['server']['host']}:{self._config['server']['port']}"
-        )
+        info(f"{act}ing dev server")
 
         try:
             tty_path = os.ttyname(sys.stdin.fileno())
@@ -153,26 +151,40 @@ class AppTask(WatchTask):
             # on windows, without a windows machine I've no idea what else to do here
             tty_path = None
 
-        self._process = Process(
-            target=mian_app, args=(tty_path, self._config, self._entry, self._env)
-        )
-        self._process.start()
+        # for key, value in self._config.items():
+        #     try:
+        #         pickle.dumps(value)
+        #     except Exception as e:
+        #         print(f"Serialization error on key '{key}': {e} {value}")
+
+        # import pickle
+        # try:
+        #     pickle.dumps(b)  # 检查是否可序列化
+        # except Exception as e:
+        #     print("Serialization error:", e)
+        try:
+            self._process = Process(
+                target=mian_app, args=(tty_path, self._config, self._entry, self._env)
+            )
+            self._process.start()
+        except Exception as e:
+            error(f"Error starting server: {e}")
 
     async def _stop_dev_server(self) -> None:
         if self._process.is_alive():
-            print_info("stopping server process...")
+            info("stopping server process...")
             if self._process.pid:
-                print_info("sending SIGINT")
+                info("sending SIGINT")
                 os.kill(self._process.pid, signal.SIGINT)
             self._process.join(5)
             if self._process.exitcode is None:
-                print_warn("process has not terminated, sending SIGKILL")
+                warning("process has not terminated, sending SIGKILL")
                 self._process.kill()
                 self._process.join(1)
             else:
-                print_info("process stopped")
+                info("process stopped")
         else:
-            print_warn(
+            warning(
                 "server process already dead, exit code: %s", self._process.exitcode
             )
 

cloudoll-2.3.0/cloudoll/web/__init__.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+__author__ = "chuchur/chuchur.com"
+from typing import Tuple
+
+from .settings import get_config
+from . import jwt
+from .core import (
+    Application,
+    app,
+    Response,
+    WebSocketResponse,
+    WebSocket,
+    WebStream,
+    WSMsgType,
+    View,
+    routes,
+    get,
+    put,
+    delete,
+    post,
+    render_json,
+    render_error,
+    render_view,
+    middleware,
+    redirect,
+)
+
+__all__: Tuple[str, ...] = (
+    "Application",
+    "app",
+    "WebSocket",
+    "Response",
+    "WebSocketResponse",
+    "WebStream",
+    "WSMsgType",
+    "View",
+    "routes",
+    "get",
+    "put",
+    "delete",
+    "post",
+    "render_json",
+    "render_error",
+    "render_view",
+    "middleware",
+    "redirect",
+    "jwt",
+    "get_config",
+)