renus 2.7.2__tar.gz → 2.7.4__tar.gz

{renus-2.7.2 → renus-2.7.4}/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2022, https://github.com/smkoBa/renus
+Copyright (c) 2022, https://github.com/kak-smko/renus
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

{renus-2.7.2/renus.egg-info → renus-2.7.4}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: renus
-Version: 2.7.2
+Version: 2.7.4
 Summary: Renus Core Framework
-Home-page: https://github.com/smkoBa/renus
+Home-page: https://github.com/kak-smko/renus
 Author: Smko Bayazidi
 Author-email: ba.smko@gmail.com
 License: BSD

renus-2.7.4/README.md

@@ -0,0 +1,135 @@
+
+# Renus
+
+**Renus** is a lightweight ASGI framework/toolkit, which is ideal for building async web services in Python. It is production-ready and designed for large-scale projects while maintaining a lightweight footprint and high performance.
+
+## ✨ Features
+
+- 🚀 **High Performance**: Great overall performance against independent benchmarks.
+- 🪶 **Lightweight**: Low-complexity HTTP web framework with few hard dependencies.
+- 🔄 **Async Support**: Fully compatible with `asyncio` and `trio` backends.
+- 🔌 **WebSocket Support**: Built-in support for WebSockets.
+- 🛠️ **Background Tasks**: Handle in-process background tasks easily.
+- 🔄 **Lifespan Events**: Manage startup and shutdown events for resource management.
+- 📦 **Built-in Utilities**: CORS, GZip, Static Files, Streaming responses, Caching, Cryptography, Scheduling, and more.
+- ✅ **Reliable**: 100% test coverage.
+- 📝 **Type Safe**: 100% type annotated codebase.
+
+## 📦 Installation
+
+Install Renus using pip:
+
+```bash
+pip install renus
+```
+
+## 🚀 Quick Start
+
+Here is a simple example to get you started with Renus:
+
+```python
+from renus.app import App
+from renus.core.response import TextResponse, JsonResponse
+from renus.core.routing import Router
+
+# 1. Define route handlers
+def home():
+    return TextResponse('Hello, world!')
+
+def user(username):
+    return JsonResponse({'name': username})
+
+async def websocket(ws):
+    await ws.accept()
+    await ws.send_text('Hello, world!')
+    await ws.close()
+
+# 2. Define lifespan events (startup and shutdown)
+async def lifespan(app):
+    print('Startup', app)
+    yield
+    print('Shutdown')
+
+# 3. Setup routing
+r = Router()
+r.get('/', func=home)
+r.get('/user/{username}', func=user)
+r.ws('/ws', func=websocket)
+
+# 4. Initialize the app
+app = App(lifespan=lifespan)
+```
+
+### Running the Application
+
+You can run your application using an ASGI server like `uvicorn`:
+
+```python
+# main.py
+import uvicorn
+from renus.app import App
+import routes.index # Import your routes module
+
+app = App()
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "main:app", 
+        host="127.0.0.1", 
+        port=4000, 
+        reload=True, 
+        log_level="info",
+        headers=[
+            ("X-Frame-Options", 'DENY'),
+            ("Access-Control-Allow-Headers", '*'),
+            ("Access-Control-Allow-Origin", '*')
+        ]
+    )
+```
+
+Run it with:
+```bash
+python main.py
+```
+
+## 📚 Documentation
+
+For full documentation, advanced features, and API references, please visit the official documentation:
+👉 **[Renus Documentation](https://codenus.com/en/renus)**
+
+### Advanced Features
+Renus comes packed with advanced features out of the box to help you build complex applications:
+- **Caching**: Efficient data caching mechanisms.
+- **Lifespan**: Manage application lifecycle events.
+- **Cryptography**: Built-in cryptographic utilities.
+- **Background Tasks**: Handle long-running tasks in the background.
+- **Dependency Injection**: Powerful injection system.
+- **Logging**: Integrated logging system.
+- **Scheduling**: Schedule tasks to run at specific intervals.
+- **Thread Pool**: Manage concurrent operations efficiently.
+
+## 🤝 Contributing
+
+Thank you for your interest in contributing to the Renus framework! We welcome all contributions from the community, whether they're bug reports, feature requests, documentation improvements, or code contributions.
+
+### Coding Standards
+- Follow **PEP 8** style guidelines.
+- Use **type hints** for all new code (PEP 484).
+- Keep lines under **88 characters** (Black's default line length).
+
+### Testing
+- Write unit tests for all new features using `pytest`.
+- Include docstrings for all public methods and classes.
+
+### Issue Reporting
+When reporting bugs or requesting features:
+- Check existing issues to avoid duplicates.
+- Provide detailed reproduction steps for bugs.
+- Include Python version, OS, and framework version.
+- For feature requests, explain the use case and benefits.
+
+Please read our [Contributing Guidelines](https://codenus.com/en/renus/3) for more details.
+
+## 📄 License
+
+*BSD 3-Clause License*

{renus-2.7.2 → renus-2.7.4}/renus/core/cache.py

@@ -1,12 +1,23 @@
 import os
+import threading
 import pickle
-from datetime import datetime, timedelta,timezone
+from datetime import UTC, datetime, timedelta
 from hashlib import sha3_256
 
 from renus.core.config import Config
 from renus.core.log import Log
 from renus.util.helper import encode64
 
+try:
+    import fcntl
+except ImportError:  # Windows has no fcntl module
+    fcntl = None
+
+try:
+    import msvcrt
+except ImportError:  # non-Windows has no msvcrt module
+    msvcrt = None
+
 try:
     import redis
     rds = redis.Redis()
@@ -17,11 +28,32 @@ class Cache:
     depth = 1
     folder_path = 'cache'
     typ = Config('app').get('cacheDriver', 'file')
+    _lock = threading.RLock()
     if typ=='redis':
         assert rds is not None, "'redis' must be installed for Cache"
         rd=rds
     else:
         rd=None
+
+    def _lock_file(self, file):
+        """Acquire an exclusive lock on an open file (cross-platform)."""
+        if fcntl is not None:
+            fcntl.flock(file.fileno(), fcntl.LOCK_EX)
+        else:  # Windows
+            file.seek(0)
+            msvcrt.locking(file.fileno(), msvcrt.LK_LOCK, 1)
+
+    def _unlock_file(self, file):
+        """Release the lock on an open file (cross-platform)."""
+        if fcntl is not None:
+            fcntl.flock(file.fileno(), fcntl.LOCK_UN)
+        else:  # Windows
+            file.seek(0)
+            try:
+                msvcrt.locking(file.fileno(), msvcrt.LK_UNLCK, 1)
+            except OSError:
+                pass
+
     def __init__(self, prefix: str = '', use_hash=False) -> None:
         self._prefix = prefix
         self._use_hash = use_hash
@@ -33,36 +65,52 @@ class Cache:
         :param value: value that save by key
         :param expire: seconds to expire from now
         """
-        if self.rd:
-            v=pickle.dumps(value,pickle.HIGHEST_PROTOCOL)
-            self.rd.set(self._prefix+key,v,expire)
-            return
-        expire =  int((datetime.now(timezone.utc) + timedelta(seconds=expire)).timestamp())
-        path = self._build_name(key, self.depth)
-        self._create_if_not_exist(path, value, expire)
+        with self._lock:
+            if self.rd:
+                v=pickle.dumps(value,pickle.HIGHEST_PROTOCOL)
+                self.rd.set(self._prefix+key,v,expire)
+                return
+            expire = datetime.now(UTC) + timedelta(seconds=expire)
+            path = self._build_name(key, self.depth)
+            self._create_if_not_exist(path, value, expire)
+
+    def increment(self, key: str, value, expire: int = 60):
+        with self._lock:
+            if self.rd:
+                r=self.rd.get(self._prefix+key)
+                value= value if r is None else (pickle.loads(r)+value)
+                v=pickle.dumps(value,pickle.HIGHEST_PROTOCOL)
+                self.rd.set(self._prefix+key,v,expire)
+                return
+            expire = datetime.now(UTC) + timedelta(seconds=expire)
+            value=self.get(key,value-1)+1
+            path = self._build_name(key, self.depth)
+            self._create_if_not_exist(path, value, expire)
 
     def get(self, key: str, default=None):
-        if self.rd:
-            r=self.rd.get(self._prefix+key)
-            return default if r is None else pickle.loads(r)
-        path = self._build_name(key, self.depth)
-        return self._read_key(path, default)['value']
+        with self._lock:
+            if self.rd:
+                r=self.rd.get(self._prefix+key)
+                return default if r is None else pickle.loads(r)
+            path = self._build_name(key, self.depth)
+            return self._read_key(path, default)['value']
 
     def expire(self, key, default=None):
-        if self.rd:
-            return max(-1,self.rd.ttl(self._prefix+key))
-        path = self._build_name(key, self.depth)
-        t= self._read_key(path, default)['expire']
-        if t==-1:
-            return -1
-        return max(-1,int(t- datetime.now(timezone.utc).timestamp()))
+        with self._lock:
+            if self.rd:
+                return max(-1,self.rd.ttl(self._prefix+key))
+            path = self._build_name(key, self.depth)
+            t= self._read_key(path, default)['expire']
+            if t==-1:
+                return -1
+            return max(-1,int(t.timestamp()-datetime.now(UTC).timestamp()))
 
     def delete(self, key):
-        if self.rd:
-            return self.rd.delete(self._prefix+key)
-
-        path = self._build_name(key, self.depth)
-        return self._delete_file(f"storage/{self.folder_path}{path}")
+        with self._lock:
+            if self.rd:
+                return self.rd.delete(self._prefix+key)
+            path = self._build_name(key, self.depth)
+            return self._delete_file(f"storage/{self.folder_path}{path}")
 
     def delete_expired(self):
         filename = f'./storage/{self.folder_path}/'
@@ -86,7 +134,8 @@ class Cache:
         except Exception as exc:
             if n < 3:
                 return self._delete_file(path, n + 1)
-            Log().info(f'cache delete_file: {exc}')
+            else:
+                raise exc
         return True
 
     def _check_pass(self, line):
@@ -94,7 +143,7 @@ class Cache:
         if len(res) < 2:
             return True
         expired, path = res
-        if (datetime.strptime(expired, '%Y-%m-%d %H:%M:%S').timestamp() < datetime.utcnow().timestamp()):
+        if (datetime.strptime(expired, '%Y-%m-%d %H:%M:%S').timestamp() < datetime.now(UTC).timestamp()):
             self._delete_file(f'storage/{self.folder_path}{path}')
             return False
         return True
@@ -105,11 +154,15 @@ class Cache:
         try:
             os.makedirs(os.path.dirname(filename), exist_ok=True)
             with open(filename, 'wb') as output:
+                self._lock_file(output)
                 pickle.dump(expire, output, pickle.HIGHEST_PROTOCOL)
                 pickle.dump(value, output, pickle.HIGHEST_PROTOCOL)
-        except:
+                self._unlock_file(output)
+        except Exception as e:
             if n < 3:
                 self._create_if_not_exist(path, value, expire, n + 1)
+            else:
+                raise e
 
     def _read_key(self, path, default=None, n=0):
         filename = f'storage/{self.folder_path}{path}'
@@ -120,13 +173,13 @@ class Cache:
             with open(filename, 'rb') as input:
                 expire = pickle.load(input)
                 value = pickle.load(input)
-        except Exception:
+        except Exception as e:
             if n < 3:
                 return self._read_key(path, default, n + 1)
             else:
-                return {'value': default, 'expire': -1}
+                raise e
 
-        if expire < datetime.now(timezone.utc).timestamp():
+        if expire.timestamp() < datetime.now(UTC).timestamp():
             self._delete_file(filename)
             return {'value': default, 'expire': -1}
         return {'value': value, 'expire': expire}
@@ -177,4 +230,4 @@ def cache_func(time: int, prefix=''):
 
         return wrapper
 
-    return dec
+    return dec

{renus-2.7.2 → renus-2.7.4}/renus/core/model.py

@@ -25,6 +25,9 @@ class ReModel:
             elif isinstance(v, list):
                 v = self._process_list_items(v, field_type)
 
+            elif isinstance(v, datetime):
+                v = v.replace(tzinfo=timezone.utc)
+
             setattr(self, k, v)
 
     def _process_list_items(self, items, field_type):
@@ -366,8 +369,7 @@ class ModelBase(Generic[M]):
         self.visible_fields = fields
         return self
 
-    @staticmethod
-    def boot_event(typ: str, old, new, session):
+    def boot_event(self,typ: str, old, new, session):
         pass
 
     @staticmethod

{renus-2.7.2 → renus-2.7.4}/renus/core/serialize.py

@@ -19,10 +19,8 @@ _DECIMAL_RE = re.compile(r'^-?\d+\.\d+$')
 
 class jsonEncoder(json.JSONEncoder):
     def default(self, o):
-        if isinstance(o, datetime.datetime):
-            return o.isoformat()+'Z'
-        elif isinstance(o, datetime.date):
-            return o.isoformat() + 'T00:00:00Z'
+        if isinstance(o, (datetime.datetime, datetime.date)):
+            return o.isoformat()
         elif isinstance(o, datetime.time):
             r = o.isoformat()
             if o.microsecond:

{renus-2.7.2 → renus-2.7.4/renus.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: renus
-Version: 2.7.2
+Version: 2.7.4
 Summary: Renus Core Framework
-Home-page: https://github.com/smkoBa/renus
+Home-page: https://github.com/kak-smko/renus
 Author: Smko Bayazidi
 Author-email: ba.smko@gmail.com
 License: BSD

{renus-2.7.2 → renus-2.7.4}/setup.py

@@ -2,9 +2,9 @@ from setuptools import setup, find_packages
 
 setup(
     name='renus',
-    version='2.7.2',
+    version='2.7.4',
     description='Renus Core Framework',
-    url='https://github.com/smkoBa/renus',
+    url='https://github.com/kak-smko/renus',
     author='Smko Bayazidi',
     author_email='ba.smko@gmail.com',
     license='BSD',

renus-2.7.2/README.md

@@ -1 +0,0 @@
-# renus