cloudoll 3.0.0__tar.gz → 3.0.2__tar.gz

{cloudoll-3.0.0 → cloudoll-3.0.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: cloudoll
-Version: 3.0.0
+Version: 3.0.2
 Summary: Assist in quickly creating distributable microservices based on aiohttp, with a focus on simplicity and ease of use.
-Home-page: https://gitee.com/chuchur/cloudoll-py
+Home-page: https://github.com/smallerqiu/cloudoll-py
 Author: Qiu
 Author-email: Qiu <smallerqiu@gmail.com>
 License-Expression: MIT
-Project-URL: Homepage, https://gitee.com/chuchur/cloudoll-py
-Project-URL: Repository, https://gitee.com/chuchur/cloudoll-py
+Project-URL: Homepage, https://github.com/smallerqiu/cloudoll-py
+Project-URL: Repository, https://github.com/smallerqiu/cloudoll-py
 Keywords: Microservices,aiohttp,cloudoll
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6

cloudoll-3.0.2/cloudoll/__init__.py

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

{cloudoll-3.0.0 → cloudoll-3.0.2}/cloudoll/cli.py

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

{cloudoll-3.0.0 → cloudoll-3.0.2}/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.0 → cloudoll-3.0.2}/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.0 → cloudoll-3.0.2}/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.0 → cloudoll-3.0.2}/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.0 → cloudoll-3.0.2}/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.0 → cloudoll-3.0.2}/cloudoll/web/requests.py

@@ -1,28 +1,43 @@
 import aiohttp
 import asyncio
-from typing import Optional, Dict, Any, Union
+
+# 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: int = 30,
-        max_retries: int = 3,
+        timeout: float = 30.0,
+        max_retries: int = 1,
         retry_delay: float = 1.0,
-        session: Optional[aiohttp.ClientSession] = None,
+        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,
     ):
-        """
-        Asynchronous HTTP request client
-
-        :param timeout: Request timeout(Second)
-        :param max_retries: Maximum retry attempts
-        :param retry_delay: Retry delay(Second)
-        :param session: Reusable aiohttp session
-        """
-        self.timeout = aiohttp.ClientTimeout(total=timeout)
+        self.timeout = timeout
         self.max_retries = max_retries
         self.retry_delay = retry_delay
-        self._session = session
+        # self.session = session
+        # self.connector = connector
+        self.use_cookies = use_cookies
+        self.keep_alive = keep_alive
+
+        self.session: aiohttp.ClientSession = 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,
@@ -30,32 +45,19 @@ class AsyncRequest:
         url: str,
         params: Optional[Dict[str, Any]] = None,
         data: Optional[Union[Dict[str, Any], str, bytes]] = None,
-        json_data: Optional[Any] = 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,
-    ) -> aiohttp.ClientResponse:
-        """
-        Perform asynchronous HTTP requests
-
-        :param method: HTTP方法 (GET, POST, PUT, DELETE等)
-        :param url: Request URL
-        :param params: URL query parameters
-        :param data: Request body data (Forms or raw data)
-        :param json_data: JSON formatted request body data
-        :param headers: Request headers
-        :param cookies: Cookies
-        :param allow_redirects: Whether to allow redirects
-        :param raise_for_status: Whether to raise an exception for HTTP errors
-        :return: aiohttp.ClientResponse
-        """
-        session = self._session or aiohttp.ClientSession(timeout=self.timeout)
+        proxy: Optional[str] = None,
+        # parse_json: bool = False,
+    ) -> Union[dict, str, aiohttp.ClientResponse]:
         last_exception = None
 
         for attempt in range(self.max_retries):
             try:
-                async with session.request(
+                response = await self.session.request(
                     method=method,
                     url=url,
                     params=params,
@@ -64,29 +66,30 @@ class AsyncRequest:
                     headers=headers,
                     cookies=cookies,
                     allow_redirects=allow_redirects,
-                ) as response:
-                    if raise_for_status:
-                        response.raise_for_status()
-                    return response
+                    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()
 
-        if self._session is None:
-            await session.close()
-
-        raise last_exception or RuntimeError("Request failed")
+        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:
+        **kwargs,
+    ) -> Union[dict, str, aiohttp.ClientResponse]:
         """Send a GET request"""
         return await self.request("GET", url, params=params, headers=headers, **kwargs)
 
@@ -96,8 +99,8 @@ class AsyncRequest:
         data: Optional[Union[Dict[str, Any], str, bytes]] = None,
         json_data: Optional[Any] = None,
         headers: Optional[Dict[str, str]] = None,
-        **kwargs
-    ) -> aiohttp.ClientResponse:
+        **kwargs,
+    ) -> Union[dict, str, aiohttp.ClientResponse]:
         """Send a POST request"""
         return await self.request(
             "POST", url, data=data, json_data=json_data, headers=headers, **kwargs
@@ -109,8 +112,8 @@ class AsyncRequest:
         data: Optional[Union[Dict[str, Any], str, bytes]] = None,
         json_data: Optional[Any] = None,
         headers: Optional[Dict[str, str]] = None,
-        **kwargs
-    ) -> aiohttp.ClientResponse:
+        **kwargs,
+    ) -> Union[dict, str, aiohttp.ClientResponse]:
         """Send a PUT request"""
         return await self.request(
             "PUT", url, data=data, json_data=json_data, headers=headers, **kwargs
@@ -118,15 +121,14 @@ class AsyncRequest:
 
     async def delete(
         self, url: str, headers: Optional[Dict[str, str]] = None, **kwargs
-    ) -> aiohttp.ClientResponse:
+    ) -> Union[dict, str, 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
+        """Close the aiohttp session if it exists"""
+        if self.session is not None:
+            await self.session.close()
 
     async def __aenter__(self):
         return self

{cloudoll-3.0.0 → cloudoll-3.0.2}/cloudoll.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: cloudoll
-Version: 3.0.0
+Version: 3.0.2
 Summary: Assist in quickly creating distributable microservices based on aiohttp, with a focus on simplicity and ease of use.
-Home-page: https://gitee.com/chuchur/cloudoll-py
+Home-page: https://github.com/smallerqiu/cloudoll-py
 Author: Qiu
 Author-email: Qiu <smallerqiu@gmail.com>
 License-Expression: MIT
-Project-URL: Homepage, https://gitee.com/chuchur/cloudoll-py
-Project-URL: Repository, https://gitee.com/chuchur/cloudoll-py
+Project-URL: Homepage, https://github.com/smallerqiu/cloudoll-py
+Project-URL: Repository, https://github.com/smallerqiu/cloudoll-py
 Keywords: Microservices,aiohttp,cloudoll
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.6

{cloudoll-3.0.0 → cloudoll-3.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cloudoll"
-version = "3.0.0" 
+version = "3.0.2" 
 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"},
@@ -39,8 +39,8 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://gitee.com/chuchur/cloudoll-py"
-Repository = "https://gitee.com/chuchur/cloudoll-py"
+Homepage = "https://github.com/smallerqiu/cloudoll-py"
+Repository = "https://github.com/smallerqiu/cloudoll-py"
 
 [project.scripts]
 cloudoll = "cloudoll.cli:cli"

{cloudoll-3.0.0 → cloudoll-3.0.2}/setup.cfg

@@ -6,7 +6,7 @@ long_description = file: README.md
 long_description_content_type = text/markdown
 author = Qiu
 author_email = smallerqiu@gmail.com
-url = https://gitee.com/chuchur/cloudoll-py
+url = https://github.com/smallerqiu/cloudoll-py
 
 [options]
 packages = find:

cloudoll-3.0.0/cloudoll/__init__.py

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