cloud-python-vars 0.1.1__tar.gz → 0.2.0__tar.gz

{cloud_python_vars-0.1.1 → cloud_python_vars-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloud-python-vars
-Version: 0.1.1
+Version: 0.2.0
 Summary: To manage and create raw Python variables on cloud servers.
 Author-email: ThatOnePythonDev <khakhang2h5e@gmail.com>
 Classifier: Programming Language :: Python :: 3

{cloud_python_vars-0.1.1 → cloud_python_vars-0.2.0}/cloud_python_vars.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloud-python-vars
-Version: 0.1.1
+Version: 0.2.0
 Summary: To manage and create raw Python variables on cloud servers.
 Author-email: ThatOnePythonDev <khakhang2h5e@gmail.com>
 Classifier: Programming Language :: Python :: 3

{cloud_python_vars-0.1.1 → cloud_python_vars-0.2.0}/cloud_variables.py

@@ -96,11 +96,11 @@ async def main() -> None: # You're recommended to put this in an asynchronous fu
 
 from __future__ import annotations
 
-from typing import Any, Literal, Never
-
-import time
 import asyncio
 import threading
+import time
+from typing import Any, Literal, override
+
 import upstash_redis as redis
 
 
@@ -120,6 +120,7 @@ class CloudProxy:
 
         self.value: Any = value
 
+    @override
     def __repr__(self) -> str:
         return f"CloudProxy({self.value})"
 
@@ -137,6 +138,8 @@ class CloudVar(redis.Redis):
         rest_retry_interval: float = 3,
         allow_telemetry: bool = True,
         read_your_writes: bool = True,
+        delay: float = 0.1,
+        tb: Literal["strict", "log", "ignore"] = "log"
     ) -> None:
         """
         To initialize the class.
@@ -148,6 +151,8 @@ class CloudVar(redis.Redis):
         :param rest_retry_interval: The number of seconds the client waits before retrying a new request. The default is 3.
         :param allow_telemetry: Controls whether the client is allowed to send telemetry data. The default is True.
         :param read_your_writes: Allows whether the client is allowed to read your writes. The default is True.
+        :param delay: The delay to prevent CPU over-usage and network spamming. The default is 0.1.
+        :param tb: Controls what to do when an error occurs. 'strict' for letting it raise, 'log' for catching and logging the error, 'ignore' for passing silently. The default is 'log'.
 
         :type url: str
         :type token: str
@@ -156,23 +161,34 @@ class CloudVar(redis.Redis):
         :type rest_retry_interval: float
         :type allow_telemetry: bool
         :type read_your_writes: bool
+        :type delay: float
+        :type tb: Literal["strict", "log", "ignore"]
         """
 
         super().__init__(url, token, rest_encoding, rest_retries, rest_retry_interval, allow_telemetry, read_your_writes,)
 
-        self.__data: dict[str, CloudProxy] = {k: v for k, v in self.items().items()}
+        self.__data: dict[str, CloudProxy] = {k: CloudProxy(v) for k, v in self.items().items()}
 
         self.__thread: threading.Thread = threading.Thread(target=self.__loop)
         self.__thread.start()
 
+        self.delay: float = delay
+        self.tb: str = tb
+
     def __loop(self) -> None:
         try:
             while True:
                 for k, v in self.__data.copy().items():
                     self.set(k, repr(v))
-                time.sleep(0.1)
-        except:
-            pass
+                time.sleep(self.delay)
+        except Exception as e:
+            match self.tb:
+                case "strict":
+                    raise
+                case "log":
+                    print(e.__traceback__)
+                case _:
+                    pass
 
     def __setitem__(self, key: str, value: Any) -> None:
         """
@@ -219,6 +235,9 @@ class CloudVar(redis.Redis):
         values: list[Any] = [self[key] for key in keys]
         self.delete(*keys)
 
+        for key in keys:
+            del self.__data[key]
+
         return tuple(values)
 
     def clear(self) -> None:
@@ -229,6 +248,7 @@ class CloudVar(redis.Redis):
 
         all_keys: list[str] = self.keys(r"[\s\S]*")
         self.delete(*all_keys)
+        self.__data.clear()
 
     def items(self) -> dict[str, Any]:
         """
@@ -255,6 +275,8 @@ class AsyncCloudVar(redis.AsyncRedis):
         rest_retry_interval: float = 3,
         allow_telemetry: bool = True,
         read_your_writes: bool = True,
+        delay: float = 0.1,
+        tb: Literal["strict", "log", "ignore"] = "log"
     ) -> None:
         """
         To initialize the class.
@@ -280,21 +302,30 @@ class AsyncCloudVar(redis.AsyncRedis):
 
         self.__data: dict[str, CloudProxy] = {}
 
+        self.delay: float = delay
+        self.tb: str = tb
+
     def start(self) -> None:
         """Starts the instance's process."""
 
-        async def task() -> Never | None:
+        async def task() -> None:
             self.__data = {k: v for k, v in (await self.items()).items()}
 
             try:
                 while True:
                     for k, v in self.__data.copy().items():
-                        await self.set(k, repr(v))
+                        _ = await self.set(k, repr(v))
                     await asyncio.sleep(0.1)
-            except:
-                pass
+            except Exception as e:
+                match self.tb:
+                    case "strict":
+                        raise
+                    case "log":
+                        print(e.__traceback__)
+                    case _:
+                        pass
 
-        asyncio.create_task(task())
+        _ = asyncio.create_task(task())
 
     def __setitem__(self, key: str, value: Any) -> None:
         """
@@ -341,6 +372,9 @@ class AsyncCloudVar(redis.AsyncRedis):
         values: list[Any] = [self[key] for key in keys]
         await self.delete(*keys)
 
+        for key in keys:
+            del self.__data[key]
+
         return tuple(values)
 
     async def clear(self) -> None:
@@ -352,6 +386,8 @@ class AsyncCloudVar(redis.AsyncRedis):
         all_keys: list[str] = await self.keys(r"[\s\S]*")
         await self.delete(*all_keys)
 
+        self.__data.clear()
+
     async def items(self) -> dict[str, Any]:
         """
         Returns a dictionary of key-value pairs on the client.
@@ -361,4 +397,4 @@ class AsyncCloudVar(redis.AsyncRedis):
         :returns: The key-value pairs from the client.
         """
 
-        return {k: self.get(k) for k in await self.keys(r"[\s\S]*") if self.get(k)}
+        return {k: await self.get(k) for k in await self.keys(r"[\s\S]*") if await self.get(k)}

{cloud_python_vars-0.1.1 → cloud_python_vars-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cloud-python-vars"
-version = "0.1.1"
+version = "0.2.0"
 authors = [
   { name="ThatOnePythonDev", email="khakhang2h5e@gmail.com" },
 ]