cloudoll 2.2.37__tar.gz → 2.2.38__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudoll
-Version: 2.2.37
+Version: 2.2.38
 Summary: 辅助快速创建可分布的微服务。
 Home-page: https://gitee.com/chuchur/cloudoll-py
 Author: chuchur

cloudoll-2.2.38/cloudoll/__init__.py

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

cloudoll-2.2.38/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_mian 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.2.38}/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.38/cloudoll/utils/cli_mian.py

@@ -0,0 +1,74 @@
+
+
+from typing import Any
+from ..web.settings import get_config
+from ..logging import print_info
+from .common import Object, chainMap
+from ..utils.watch import AppTask
+from aiohttp import web
+from ..web import app
+from pathlib import Path
+from ..utils.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.2.37 → cloudoll-2.2.38}/cloudoll/utils/common.py

@@ -6,7 +6,19 @@ class Object(dict):
 
     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()

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

@@ -1,4 +1,4 @@
-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
 import asyncio
@@ -10,9 +10,10 @@ from multiprocessing import Process
 from watchfiles import awatch, DefaultFilter
 from ..logging import print_info, print_warn
 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
 
 
 class CloudollFilter(DefaultFilter):
@@ -95,6 +96,8 @@ def mian_app(tty_path, config, entry, env):
                 loop.run_forever()
             except KeyboardInterrupt:
                 pass
+            except Exception as e:
+                traceback.print_exc()
             finally:
                 with suppress(asyncio.TimeoutError, KeyboardInterrupt):
                     loop.run_until_complete(runner.cleanup())
@@ -123,9 +126,8 @@ 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):
@@ -134,15 +136,14 @@ class AppTask(WatchTask):
                     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']}"
-        )
+        
 
         try:
             tty_path = os.ttyname(sys.stdin.fileno())
@@ -153,10 +154,30 @@ 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)
+        # 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:
+            print(f"Error starting server: {e}")
+        
+        print_info(
+            f"Server Running on http://{self._config['server']['host']}:{self._config['server']['port']}"
         )
-        self._process.start()
+        print_info("(Press CTRL+C to quit)")
+        
 
     async def _stop_dev_server(self) -> None:
         if self._process.is_alive():

{cloudoll-2.2.37 → cloudoll-2.2.38}/cloudoll/web/__init__.py

@@ -142,6 +142,7 @@ async def check_port_open(port: int, delay: float = 1) -> None:
 
 
 def auto_reg_module(module_dir: str):
+    
     module_path = os.path.join(os.path.abspath("."), module_dir)
     if not os.path.exists(module_path):
         print_info(f"{module_dir} not detected")
@@ -218,6 +219,7 @@ class Application(object):
 
         # middlewares
         auto_reg_module("middlewares")
+        print_info("auto register middlewares")
 
         conf_server = config.get("server")
         client_max_size = 1024**2 * 2
@@ -242,6 +244,8 @@ class Application(object):
         # self._init_session()
         #  router:
         auto_reg_module("controllers")
+        print_info("auto register controllers")
+        
         self.app.add_routes(self._route_table)
 
         # load life
@@ -584,7 +588,7 @@ def render_json(data, **kw) -> Response:
         res.update(data)
     elif isinstance(data, tuple):
         data = dict(data)
-        res.update(data)    
+        res.update(data)
     else:
         res["data"] = data
     status = kw.get("status", 200)

{cloudoll-2.2.37 → cloudoll-2.2.38}/cloudoll.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudoll
-Version: 2.2.37
+Version: 2.2.38
 Summary: 辅助快速创建可分布的微服务。
 Home-page: https://gitee.com/chuchur/cloudoll-py
 Author: chuchur

{cloudoll-2.2.37 → cloudoll-2.2.38}/cloudoll.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ cloudoll/robot/dingtalk.py
 cloudoll/robot/feishu.py
 cloudoll/robot/slack.py
 cloudoll/utils/__init__.py
+cloudoll/utils/cli_mian.py
 cloudoll/utils/common.py
 cloudoll/utils/m2d.py
 cloudoll/utils/patch_loop.py

cloudoll-2.2.37/cloudoll/__init__.py

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

cloudoll-2.2.37/cloudoll/cli.py

@@ -1,137 +0,0 @@
-import click
-from .web.settings import get_config
-from .web import app
-from .orm import create_engine
-from .utils.m2d import create_models, create_tables
-import asyncio
-import os
-import sys
-from .logging import print_error, print_info
-from pathlib import Path
-from . import __version__
-import traceback
-from .utils.watch import AppTask
-from aiohttp import web
-from .utils.common import chainMap
-
-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(path, create, table, environment, database) -> None:
-    """Help to create models or tables."""
-
-    # click.echo(create)
-    async def start():
-        try:
-            config = get_config(environment)
-            url_config = config.get("database")
-            if url_config is None:
-                raise ValueError(
-                    f"Can't find the database config in conf.{environment}.yaml"
-                )
-            db_config = url_config.get(database)
-            if db_config is None:
-                raise ValueError(
-                    f"Can't find the database config key ->{database} in conf.{environment}.yaml"
-                )
-            sa = await create_engine(**db_config)
-            if sa.pool is None:
-                return
-            model_path = os.path.join(os.path.abspath("."), path)
-            tables = None
-            if table != "ALL":
-                tables = table.split(",")
-
-            if create == "model":
-                await create_models(sa, path, tables=tables)
-                print_info(f"Model save at:{model_path}")
-            elif create == "table":
-                if model_path is None:
-                    raise ValueError("Need package name or model name.")
-                await create_tables(sa, model_path, tables=tables)
-
-        except Exception as e:
-            print_error(traceback.print_exc())
-            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(environment, host, port, mode, path, entry) -> None:
-    """Start a services."""
-    try:
-        print_info("Current mode: ", mode)
-        config = get_config(environment)
-        # print(environment, host, port, mode, path, entry)
-        # return
-        if mode == 'production':
-            App = app.create(env=environment, config=config, entry_model=entry)
-            App.run()
-            return
-        aux_app = web.Application(
-            logger=None,
-        )
-        defaults = {"host": "0.0.0.0", "port": 9001, "path": None}
-        conf_server = config.get("server", {})
-        env_server = {"host": host, "port": port, "path": path}
-        server = chainMap(defaults, conf_server, env_server)
-        config["server"] = server
-
-        aux_port = int(server.port) + 1
-        task = AppTask(Path(".").resolve(), config, entry=entry, env=environment)
-        aux_app.cleanup_ctx.append(task.cleanup_ctx)
-        web.run_app(
-            aux_app,
-            access_log=None,
-            host=host,
-            port=aux_port,
-            print=None,
-            shutdown_timeout=0.1,
-        )
-    except KeyboardInterrupt:
-        sys.exit(0)
-    except Exception as e:
-        print_error(e)
-        print_error(traceback.format_exc())
-        sys.exit(0)
-
-
-_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()