cloudoll 3.0.1__tar.gz → 3.0.3__tar.gz

{cloudoll-3.0.1 → cloudoll-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudoll
-Version: 3.0.1
+Version: 3.0.3
 Summary: Assist in quickly creating distributable microservices based on aiohttp, with a focus on simplicity and ease of use.
 Home-page: https://github.com/smallerqiu/cloudoll-py
 Author: Qiu

cloudoll-3.0.3/cloudoll/__init__.py

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

{cloudoll-3.0.1 → cloudoll-3.0.3}/cloudoll/cli.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+import traceback
 import click
 import asyncio
 import os

{cloudoll-3.0.1 → cloudoll-3.0.3}/cloudoll/clitool/m2d.py

@@ -27,7 +27,7 @@ async def create_model(pool, table_name) -> str:
     tb = f"\nclass {snake_to_camel(table_name)}(Model):\n\n"
     tb += f"\t__table__ = '{table_name}'\n\n"
     for f in rows:
-        fields = get_col(f, pool.driver)
+        fields: dict = get_col(f, pool.driver)
         # print("fields",fields)
         name = fields["name"]
         column_type = fields["column_type"]
@@ -193,7 +193,8 @@ async def create_tables(pool, model_name: str, tables: list):
     else:
         raise ImportError(f"Module {model_name} not found or invalid.")
 
-def get_col(field, driver="mysql"):
+
+def get_col(field, driver="mysql") -> dict:
     if driver == "mysql":
         fields = {
             "name": field["Field"],
@@ -235,6 +236,8 @@ def get_col(field, driver="mysql"):
             "comment": field["comment"],
         }
         return fields
+    else:
+        raise ValueError(f"Database {driver} not support.")
 
 
 def get_col_sql(field):

{cloudoll-3.0.1 → cloudoll-3.0.3}/cloudoll/clitool/process.py

@@ -27,10 +27,10 @@ class ProcessManager:
     def get_run_dir():
         home = Path.home()
         if platform.system() == "Windows":
-            run_dir =  home / f"AppData/Local/cloudoll"
+            run_dir = home / f"AppData/Local/cloudoll"
         else:
             run_dir = home / f".cloudoll"
-            
+
         try:
             run_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
         except (PermissionError, OSError):
@@ -41,7 +41,7 @@ class ProcessManager:
     @staticmethod
     def get_pid_path(name: str):
         run_dir = ProcessManager.get_run_dir()
-        return run_dir / f"cloudoll-{name}.pid"
+        return run_dir / f"{name}.pid"
 
     @staticmethod
     def save_pid(name: str, pid: int) -> None:
@@ -57,6 +57,7 @@ class ProcessManager:
 
     @staticmethod
     def safe_exit(service_name: str):
+        pid = 0
         try:
             pid = ProcessManager.get_running_pid(service_name)
             if not pid:
@@ -111,8 +112,6 @@ class ProcessManager:
             valid_identifiers = [
                 f"--name {service_name}",
                 f"-n {service_name}",
-                f"--name={service_name}",
-                f"-n={service_name}",
             ]
             cmdline = " ".join(psutil.Process(os.getpid()).cmdline())
             return (
@@ -205,7 +204,16 @@ class ProcessManager:
             return
 
         fmt = "{:<15} {:<8} {:<8} {:<12} {:<8} {:<10} {:<15}"
-        headers = ["Services", "PID", "Status", "RunTime", "CPU%", "Mem(MB)", "Process"]
+        headers = [
+            "Services",
+            "PID",
+            "Status",
+            "Env",
+            "RunTime",
+            "CPU%",
+            "Mem(MB)",
+            "Process",
+        ]
         rows = []
         for pid_file in sorted(pid_dir.glob("*.pid")):
             service = pid_file.stem
@@ -225,11 +233,19 @@ class ProcessManager:
                 uptime = datetime.now() - start_time
                 runtime = str(uptime).split(".")[0]
 
+                "env"
+                args = ProcessManager.load_start_args(service)
+                env_value = "-"
+                if "-env" in args:
+                    index = args.index("-env")
+                    if index + 1 < len(args):
+                        env_value = args[index + 1]
                 rows.append(
                     [
                         service,
                         pid,
                         "🟢 Running",
+                        env_value,
                         runtime,
                         f"{cpu_percent:.1f}",
                         f"{mem_mb:.1f}",
@@ -239,4 +255,4 @@ class ProcessManager:
             except Exception as e:
                 rows.append([service, "???", "error", "-", "-", "-", str(e)])
 
-        click.echo(tabulate(rows, headers=headers, tablefmt="rounded_outline"))
+        click.echo(tabulate(rows, headers=headers, tablefmt="rounded_grid"))

{cloudoll-3.0.1 → cloudoll-3.0.3}/cloudoll/clitool/watch.py

@@ -19,7 +19,7 @@ from cloudoll.utils.common import check_port_open
 
 class CloudollFilter(DefaultFilter):
     def __init__(self, ignore_dirs: tuple = ()) -> None:
-        self.ignore_dirs = self.ignore_dirs + tuple("logs")
+        self.ignore_dirs: tuple = self.ignore_dirs + tuple("logs")
         if ignore_dirs:
             self.ignore_dirs = self.ignore_dirs + ignore_dirs
 
@@ -112,7 +112,7 @@ def mian_app(tty_path, config, entry, env):
 
 async def create_main_app(config, entry, env):
     await check_port_open(config["server"]["port"])
-    App = app.create(env=env, config=config, entry_model=entry)
+    App: Application = app.create(env=env, config=config, entry_model=entry)
     return web.AppRunner(App.app, shutdown_timeout=0.1)
 
 

{cloudoll-3.0.1 → cloudoll-3.0.3}/cloudoll/utils/common.py

@@ -1,8 +1,6 @@
 import asyncio
 from cloudoll.logging import warning
 
-EADDRINUSE: int
-
 
 class Object(dict):
     # __setattr__ = dict.__setitem__
@@ -46,7 +44,8 @@ async def check_port_open(port: int, delay: float = 1) -> None:
                 asyncio.Protocol, host="0.0.0.0", port=port
             )
         except OSError as e:
-            if e.errno != EADDRINUSE:
+            print(e.errno)
+            if e.errno != 48:
                 raise
             warning("port %d is already in use, waiting %d...", port, i)
             await asyncio.sleep(delay)

{cloudoll-3.0.1 → cloudoll-3.0.3}/cloudoll/web/core.py

@@ -157,7 +157,7 @@ class Application(object):
     def __init__(self):
         self._loop = None
         self.env = None
-        self.app = None
+        self.app: web.Application = None
         self._route_table = web.RouteTableDef()
         self._middleware = []
         self.config = {}

cloudoll-3.0.3/cloudoll/web/requests.py

@@ -0,0 +1,86 @@
+import aiohttp
+import asyncio
+from aiohttp import BasicAuth, ClientSession
+
+
+__all__ = ("Session", "BasicAuth")
+
+
+class Session:
+    def __init__(
+        self,
+        timeout: float = 30.0,
+        max_retries: int = 1,
+        retry_delay: int = 1,
+        **kwargs,
+    ):
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+        self.session: ClientSession = ClientSession(
+            timeout=aiohttp.ClientTimeout(total=timeout), **kwargs
+        )
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        **kwargs,
+    ):
+        last_exception = None
+
+        for attempt in range(self.max_retries):
+            try:
+                response = await self.session.request(method=method, url=url, **kwargs)
+                return response
+
+            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                last_exception = e
+                if attempt < self.max_retries - 1:
+                    await asyncio.sleep(self.retry_delay * (attempt + 1))
+                continue
+            # finally:
+            #     if use_temp_session:
+            #         await session.close()
+
+        raise last_exception or RuntimeError(
+            f"Request failed after {self.max_retries} attempts"
+        )
+
+    async def get(
+        self,
+        url: str,
+        **kwargs,
+    ):
+        """Send a GET request"""
+        return await self.request("GET", url, **kwargs)
+
+    async def post(
+        self,
+        url: str,
+        **kwargs,
+    ):
+        """Send a POST request"""
+        return await self.request("POST", url, **kwargs)
+
+    async def put(
+        self,
+        url: str,
+        **kwargs,
+    ):
+        """Send a PUT request"""
+        return await self.request("PUT", url, **kwargs)
+
+    async def delete(self, url: str, **kwargs):
+        """Send a DELETE request"""
+        return await self.request("DELETE", url, **kwargs)
+
+    async def close(self) -> None:
+        """Close the aiohttp session if it exists"""
+        if self.session is not None:
+            await self.session.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

{cloudoll-3.0.1 → cloudoll-3.0.3}/cloudoll.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudoll
-Version: 3.0.1
+Version: 3.0.3
 Summary: Assist in quickly creating distributable microservices based on aiohttp, with a focus on simplicity and ease of use.
 Home-page: https://github.com/smallerqiu/cloudoll-py
 Author: Qiu

{cloudoll-3.0.1 → cloudoll-3.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cloudoll"
-version = "3.0.1" 
+version = "3.0.3" 
 description = "Assist in quickly creating distributable microservices based on aiohttp, with a focus on simplicity and ease of use."
 authors = [
   {name = "Qiu", email = "smallerqiu@gmail.com"},

cloudoll-3.0.1/cloudoll/__init__.py

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

cloudoll-3.0.1/cloudoll/web/requests.py

@@ -1,159 +0,0 @@
-import aiohttp
-import asyncio
-# import ssl
-from typing import Optional, Dict, Union, List, Any
-
-JSONType = Union[Dict[str, Any], List[Any], str, int, float, bool, None]
-
-
-class AsyncRequest:
-    def __init__(
-        self,
-        timeout: float = 30.0,
-        max_retries: int = 1,
-        retry_delay: float = 1.0,
-        keep_alive: bool = True,
-        use_cookies: bool = False,
-        proxy: Optional[str] = None,
-        # session: Optional[aiohttp.ClientSession] = None,
-        # connector: Optional[aiohttp.BaseConnector] = None,
-        # ssl: Union[bool, ssl.SSLContext] = True,
-    ):
-        self.timeout = timeout
-        self.max_retries = max_retries
-        self.retry_delay = retry_delay
-        # self.session = session
-        # self.connector = connector
-        self.use_cookies = use_cookies
-        self.keep_alive = keep_alive
-        
-        self.session = aiohttp.ClientSession(
-            proxy=proxy,
-            connector=aiohttp.TCPConnector(keepalive_timeout=self.timeout) if self.keep_alive else None,
-            timeout=aiohttp.ClientTimeout(total=self.timeout),
-            cookie_jar=aiohttp.CookieJar() if self.use_cookies else None,
-        )
-
-    async def request(
-        self,
-        method: str,
-        url: str,
-        params: Optional[Dict[str, Any]] = None,
-        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
-        json_data: Optional[JSONType] = None,
-        headers: Optional[Dict[str, str]] = None,
-        cookies: Optional[Dict[str, str]] = None,
-        allow_redirects: bool = True,
-        raise_for_status: bool = True,
-        proxy: Optional[str] = None,
-        # parse_json: bool = False,
-    ) -> Union[dict, str, aiohttp.ClientResponse]:
-        last_exception = None
-
-        for attempt in range(self.max_retries):
-            try:
-                response  = await self.session.request(
-                    method=method,
-                    url=url,
-                    params=params,
-                    data=data,
-                    json=json_data,
-                    headers=headers,
-                    cookies=cookies,
-                    allow_redirects=allow_redirects,
-                    proxy=proxy,
-                ) 
-                return response
-
-            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
-                last_exception = e
-                if attempt < self.max_retries - 1:
-                    await asyncio.sleep(self.retry_delay * (attempt + 1))
-                continue
-            # finally:
-            #     if use_temp_session:
-            #         await session.close()
-
-        raise last_exception or RuntimeError(
-            f"Request failed after {self.max_retries} attempts"
-        )
-
-    async def get(
-        self,
-        url: str,
-        params: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        **kwargs,
-    ) -> aiohttp.ClientResponse:
-        """Send a GET request"""
-        return await self.request("GET", url, params=params, headers=headers, **kwargs)
-
-    async def post(
-        self,
-        url: str,
-        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
-        json_data: Optional[Any] = None,
-        headers: Optional[Dict[str, str]] = None,
-        **kwargs,
-    ) -> aiohttp.ClientResponse:
-        """Send a POST request"""
-        return await self.request(
-            "POST", url, data=data, json_data=json_data, headers=headers, **kwargs
-        )
-
-    async def put(
-        self,
-        url: str,
-        data: Optional[Union[Dict[str, Any], str, bytes]] = None,
-        json_data: Optional[Any] = None,
-        headers: Optional[Dict[str, str]] = None,
-        **kwargs,
-    ) -> aiohttp.ClientResponse:
-        """Send a PUT request"""
-        return await self.request(
-            "PUT", url, data=data, json_data=json_data, headers=headers, **kwargs
-        )
-
-    async def delete(
-        self, url: str, headers: Optional[Dict[str, str]] = None, **kwargs
-    ) -> aiohttp.ClientResponse:
-        """Send a DELETE request"""
-        return await self.request("DELETE", url, headers=headers, **kwargs)
-
-    async def close(self) -> None:
-        """Close the aiohttp session if it exists"""
-        if self.session is not None:
-            await self.session.close()
-            self.session = None
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
-
-
-# demo
-"""
-async def test():
-    async with AsyncRequest() as client:
-        try:
-            # GET Request example
-            response = await client.get(
-                "https://httpbin.org/get",
-                params={"key": "value"},
-                headers={"User-Agent": "AsyncRequest/1.0"},
-            )
-            print(await response.json())
-
-            # POST Request example
-            response = await client.post(
-                "https://httpbin.org/post",
-                json_data={"key": "value"},
-                headers={"Content-Type": "application/json"},
-            )
-            print(await response.json())
-
-        except Exception as e:
-            print(f"Request failed: {e}")
-"""