sharedkernel 2.5.3__tar.gz → 2.5.6__tar.gz

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sharedkernel
-Version: 2.5.3
+Version: 2.5.6
 Summary: sharekernel is a shared package between all python projects
 Author: Smilinno
 Description-Content-Type: text/markdown
@@ -20,6 +20,7 @@ Requires-Dist: markdown
 Requires-Dist: beautifulsoup4
 Requires-Dist: deepdiff
 Requires-Dist: kombu
+Requires-Dist: redis
 Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
@@ -30,6 +31,12 @@ Dynamic: summary
 this is a shared kernel package
 
 # Change Log
+### Version 2.5.6
+- fix bug
+### Version 2.5.5
+- fix bug
+### Version 2.5.4
+- Add Ip Session Service
 ### Version 2.5.3
 - Fix bug
 ### Version 2.5.2

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/README.md

@@ -2,6 +2,12 @@
 this is a shared kernel package
 
 # Change Log
+### Version 2.5.6
+- fix bug
+### Version 2.5.5
+- fix bug
+### Version 2.5.4
+- Add Ip Session Service
 ### Version 2.5.3
 - Fix bug
 ### Version 2.5.2

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/setup.py

@@ -37,9 +37,10 @@ setup(
         "beautifulsoup4",
         "deepdiff",
         "kombu",
+        "redis",
     ],
     # *strongly* suggested for sharing
-    version="2.5.3",
+    version="2.5.6",
     description="sharekernel is a shared package between all python projects",
     long_description=long_description,
     long_description_content_type="text/markdown",

sharedkernel-2.5.6/sharedkernel/config.py

@@ -0,0 +1,34 @@
+import os
+
+# Log *******************************************************************************
+LOG_ENABLE = True if os.getenv("LOG_ENABLE", "False").lower() == "true" else False
+RABBITMQ_USER = os.getenv("RABBITMQ_USER")
+RABBITMQ_PASSWORD = os.getenv("RABBITMQ_PASSWORD")
+RABBITMQ_HOST = os.getenv("RABBITMQ_HOST")
+RABBITMQ_VHOST = os.getenv("RABBITMQ_VHOST")
+LOG_EXCHANGE = os.getenv("LOG_EXCHANGE")
+LOG_REQUESTS_QUEUE = os.getenv("LOG_REQUESTS_QUEUE")
+SERVICE_NAME = os.getenv("SERVICE_NAME")
+IP_HEADER_NAME = os.getenv("IP_HEADER_NAME")
+
+# IP Session ************************************************************************
+IP_SESSION_AUTH_ENABLE = True if os.getenv("IP_SESSION_AUTH_ENABLE", "False").lower() == "true" else False
+APIKEY_HEADER_NAME = os.getenv("APIKEY_HEADER_NAME")
+WHITE_LIST_IP = os.getenv("WHITE_LIST_IP") #192.168.0.0/16, 10.0.0.0/24, 11.22.33.44
+IP_SESSION_CACHE_DATABASE_NUMBER = os.getenv("IP_SESSION_CACHE_DATABASE_NUMBER")
+
+
+# REDIS *****************************************************************************
+REDIS_URL = os.getenv("REDIS_URL")
+REDIS_PASSWORD = os.getenv("REDIS_PASSWORD")
+REDIS_USER = os.getenv("REDIS_USER")
+REDIS_CONNECTION_STRING = os.getenv("REDIS_CONNECTION_STRING")
+CACHE_DATABASE_NUMBER = os.getenv("CACHE_DATABASE_NUMBER")
+REDIS_CONNECTION_STRING = os.getenv(
+    "REDIS_CONNECTION_STRING", f"redis://{REDIS_USER}:{REDIS_PASSWORD}@{REDIS_URL}"
+)
+CACHE_EXPIRE_TIME_HOURS = int(os.getenv("CACHE_EXPIRE_TIME_HOURS", 24))
+REDIS_SENTINELS = os.getenv("REDIS_SENTINELS")
+REDIS_MASTER_NAME = os.getenv("REDIS_MASTER_NAME")
+REDIS_CLUSTER_NODES = os.getenv("REDIS_CLUSTER_NODES")
+REDIS_MODE = os.getenv("REDIS_MODE") # sentinel / cluster / standalone

sharedkernel-2.5.6/sharedkernel/database/distributed_cache.py

@@ -0,0 +1,138 @@
+from typing import Generic, List, Optional, Tuple, Type, TypeVar
+
+import redis
+from pydantic import BaseModel
+from redis import Redis
+from redis.sentinel import Sentinel
+from redis.cluster import RedisCluster, ClusterNode
+from sharedkernel.exception.exception import BusinessException
+
+from sharedkernel import config
+from sharedkernel.enum import ErrorCode, RedisMode
+
+T = TypeVar("T", bound=BaseModel)
+
+
+from typing import List, Tuple
+
+def parse_nodes(value: str) -> List[Tuple[str, int]]:
+    if not value:
+        return []
+
+    sentinels = []
+    for item in value.split(","):
+        item = item.strip()
+
+        if ":" in item:
+            host, port = item.rsplit(":", 1)
+            port = int(port)
+        else:
+            host = item
+            port = 6379
+
+        sentinels.append((host, port))
+
+    return sentinels
+
+
+
+def get_redis_client(cache_database_number=config.CACHE_DATABASE_NUMBER) -> Redis:
+    redis_mode = config.REDIS_MODE
+    if redis_mode == RedisMode.SENTINEL:
+        sentinels = parse_nodes(config.REDIS_SENTINELS)
+
+        sentinel = Sentinel(sentinels)
+        return sentinel.master_for(
+            service_name=config.REDIS_MASTER_NAME,
+            db=cache_database_number,
+            username=config.REDIS_USER,
+            password=config.REDIS_PASSWORD,
+            # decode_responses=True,
+        )
+
+    elif redis_mode == RedisMode.CLUSTER:
+        nodes = parse_nodes(config.REDIS_CLUSTER_NODES)
+
+        startup_nodes = [ClusterNode(host=h, port=p) for h, p in nodes]
+
+        return RedisCluster(
+            startup_nodes=startup_nodes,
+            username=config.REDIS_USER,
+            password=config.REDIS_PASSWORD,
+        )
+    
+    else:
+        return redis.Redis.from_url(
+            url=f"{config.REDIS_CONNECTION_STRING}/{cache_database_number}"
+        )
+
+
+
+class DistributedCache(Generic[T]):
+    def __init__(
+        self,
+        namespace: str,
+        model: Type[T],
+        expire_time_hour: int = config.CACHE_EXPIRE_TIME_HOURS,
+    ):
+        """
+        :param namespace:        Prefix for the key
+        :param model:            The Pydantic model class to store/retrieve
+        :param expire_time_hour: Time-to-live for each item in hours
+        """
+
+        self.client = get_redis_client()
+        if not self.client.ping():
+            raise BusinessException(ErrorCode.Internal_Server)
+
+        self.namespace = namespace
+        self.model = model
+        self.expire_time = self.expire_time_to_seconds(expire_time_hour)
+
+    def expire_time_to_seconds(self, hours: int) -> int:
+        return hours * 60 * 60
+
+    def _pref(self, key: str) -> str:
+        return f"{self.namespace}:{key}"
+
+    def _serialize(self, value: T) -> str:
+        return value.model_dump_json()
+
+    def _deserialize(self, raw: bytes) -> T:
+        return self.model.model_validate_json(raw.decode())
+
+    def set(self, key: str, value: T) -> None:
+        if value is None:
+            return
+        skey = self._pref(key)
+        payload = self._serialize(value)
+        self.client.set(skey, payload, ex=self.expire_time)
+
+    def get(self, key: str) -> Optional[T]:
+        skey = self._pref(key)
+        raw = self.client.get(skey)
+        if raw is None:
+            return None
+        return self._deserialize(raw)
+
+    def get_all_ids(self) -> list[str]:
+        return [
+            raw.decode().split(":")[1]
+            for raw in self.client.scan_iter(f"{self.namespace}:*")
+        ]
+
+    def exists(self, key: str) -> bool:
+        skey = self._pref(key)
+        return self.client.exists(skey)
+
+    def delete(self, key):
+        self.client.delete(key)
+        
+    def delete_group(self, key_prefix: str):
+        pattern = f"{self.namespace}:{key_prefix}*"
+        for k in self.client.scan_iter(pattern):
+            self.client.delete(k)
+
+    def clear(self):
+        for k in self.client.scan_iter(f"{self.namespace}:*"):
+            self.client.delete(k)

sharedkernel-2.5.6/sharedkernel/enum/__init__.py

@@ -0,0 +1,2 @@
+from .error_code import ErrorCode
+from .redis_mode_enum import RedisMode

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/sharedkernel/enum/error_code.py

@@ -8,3 +8,4 @@ class ErrorCode(str, Enum):
     Success = "با موفقیت انجام شد"
     Intents_Count_Should_Equal_One = "فقط یک اینتنت میتوانید وارد نمایید"
     Unsupported_Date_Type = "تاریخ داده شده پیشتیبانی نمیشود."
+    Unsupported_IP = "آی پی داده شده معتبر نمی باشد"

sharedkernel-2.5.6/sharedkernel/enum/redis_mode_enum.py

@@ -0,0 +1,8 @@
+
+from enum import Enum
+
+class RedisMode(str, Enum):
+    SENTINEL = "sentinel"
+    CLUSTER = "cluster"
+    STANDALONE = "standalone"
+    

sharedkernel-2.5.6/sharedkernel/ip_session_service.py

@@ -0,0 +1,98 @@
+import json
+import ipaddress
+from typing import List
+from fastapi import Request
+from sharedkernel.exception.exception import UnAuthorizedException, BusinessException
+from sharedkernel.database.distributed_cache import get_redis_client
+from sharedkernel.logger.log_decorator import unified_logger
+from sharedkernel.enum import ErrorCode
+from sharedkernel import config
+
+
+class IPSessionAuth:
+
+    def __init__(self):
+        self.redis = get_redis_client(cache_database_number=config.IP_SESSION_CACHE_DATABASE_NUMBER)
+        self.whitelist_networks = self._load_whitelist(config.WHITE_LIST_IP)
+
+
+    def _load_whitelist(self, raw_value):
+        if not raw_value:
+            return []
+
+        entries = [e.strip() for e in raw_value.split(",") if e.strip()]
+
+        networks = []
+
+        for entry in entries:
+            try:
+                if "/" in entry:
+                    networks.append(ipaddress.ip_network(entry, strict=False))
+
+                else:
+                    ip = ipaddress.ip_address(entry)
+                    networks.append(ipaddress.ip_network(f"{ip}/32"))
+
+            except ValueError:
+                raise BusinessException(ErrorCode.Unsupported_IP)
+
+        return networks
+
+
+    def _is_ip_allowed(self, ip_str: str) -> bool:
+        try:
+            ip = ipaddress.ip_address(ip_str)
+        except ValueError:
+            raise BusinessException(ErrorCode.Unsupported_IP)
+
+        return any(ip in net for net in self.whitelist_networks)
+
+    
+    @unified_logger()
+    def ip_session_auth(self, request: Request):
+
+        if not config.IP_SESSION_AUTH_ENABLE:
+            return
+
+        api_key = request.headers.get(config.APIKEY_HEADER_NAME)
+
+        if api_key:
+            return
+
+        state = getattr(request.state, "decoded_token", None)
+        if not state:
+            raise UnAuthorizedException()
+
+        nameid = state.get("nameid")
+        sessionid = state.get("sessionId")
+
+        if not nameid or not sessionid:
+            raise UnAuthorizedException()
+
+        request_ip = request.headers.get(config.IP_HEADER_NAME)
+        if not request_ip:
+            raise UnAuthorizedException()
+
+        request_ip = request_ip.strip()
+
+        if self._is_ip_allowed(request_ip):
+            return
+
+        redis_key = f"userId:{nameid}:session:{sessionid}"
+        user_data = self.redis.get(redis_key)
+
+        if not user_data:
+            raise UnAuthorizedException()
+
+        try:
+            payload = json.loads(user_data.decode())
+        except (ValueError, UnicodeDecodeError, TypeError):
+            raise UnAuthorizedException()
+
+        stored_ip = payload.get("Ip")
+
+        if not stored_ip:
+            raise UnAuthorizedException()
+
+        if stored_ip.strip() != request_ip:
+            raise UnAuthorizedException()

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/sharedkernel/logger/log_decorator.py

@@ -2,12 +2,10 @@ import inspect
 from functools import wraps
 from typing import Callable, Type
 from asyncio import iscoroutinefunction
-import os
 
 from sharedkernel.logger.logger_service import LoggerService
+from sharedkernel import config
 
-LOG_ENABLE = True if os.getenv("LOG_ENABLE", "True").lower() == "true" else False
-print("Log Enable" if LOG_ENABLE else "Log Disable")
 
 logger = LoggerService()
 
@@ -37,7 +35,7 @@ def decorate_class_methods(cls: Type) -> Type:
 def unified_logger(endpoint_name: str = None, class_name: str = None) -> Callable:
     def decorator(target: Callable | Type):
 
-        if not LOG_ENABLE:
+        if not config.LOG_ENABLE:
             return target
 
         if inspect.isclass(target):

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/sharedkernel/logger/log_middlewares.py

@@ -1,25 +1,22 @@
 import uuid
 from typing import Callable
-import os
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 
 
 from sharedkernel.logger.log_info import log_info
 from sharedkernel.logger.log_dto import LogDTO
-
-IP_HEADER_NAME = os.getenv("IP_HEADER_NAME", "true-client-ip")
-LOG_ENABLE = True if os.getenv("LOG_ENABLE", "True").lower() == "true" else False
+from sharedkernel import config
 
 class LogMiddleware(BaseHTTPMiddleware):
 
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
 
-        if not LOG_ENABLE:
+        if not config.LOG_ENABLE:
             return await call_next(request)
 
         correlation_id = request.headers.get("x-request-id") or uuid.uuid4().hex
-        ip_address = request.headers.get(IP_HEADER_NAME)
+        ip_address = request.headers.get(config.IP_HEADER_NAME)
         log_obj = LogDTO(
             CorrelationId=correlation_id,
             RequestPath=request.url.path,

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/sharedkernel/logger/logger_service.py

@@ -4,7 +4,6 @@ from pydantic import BaseModel
 from typing import Optional
 import datetime
 import uuid
-import os
 
 from sharedkernel.logger.log_info import log_info
 from sharedkernel.enum import ErrorCode
@@ -12,26 +11,19 @@ from sharedkernel.objects.user_info import current_user_info
 from sharedkernel.exception.exception import BusinessException
 from sharedkernel.logger.log_dto import LogDTO
 from sharedkernel.logger.log_enums import LogEventTypeEnum, LogLevelEnum
+from sharedkernel import config
 
-RABBITMQ_USER = os.getenv("RABBITMQ_USER")
-RABBITMQ_PASSWORD = os.getenv("RABBITMQ_PASSWORD")
-RABBITMQ_HOST = os.getenv("RABBITMQ_HOST")
-RABBITMQ_VHOST = os.getenv("RABBITMQ_VHOST")
-LOG_EXCHANGE = os.getenv("LOG_EXCHANGE")
-LOG_REQUESTS_QUEUE = os.getenv("LOG_REQUESTS_QUEUE")
-SERVICE_NAME = os.getenv("SERVICE_NAME")
-IP_HEADER_NAME = os.getenv("IP_HEADER_NAME", "IP_HEADER_NAME")
 
 rabbitmq_url = (
-    f"amqp://{RABBITMQ_USER}:{RABBITMQ_PASSWORD}"
-    f"@{RABBITMQ_HOST}/{RABBITMQ_VHOST}"
+    f"amqp://{config.RABBITMQ_USER}:{config.RABBITMQ_PASSWORD}"
+    f"@{config.RABBITMQ_HOST}/{config.RABBITMQ_VHOST}"
 )
 
 class LoggerService:
     def __init__(self):
         self._connection: Optional[Connection] = None
         self._producer: Optional[Producer] = None
-        self._exchange = Exchange(LOG_EXCHANGE, type="topic")
+        self._exchange = Exchange(config.LOG_EXCHANGE, type="topic")
 
 
     def _ensure_connection(self):
@@ -47,10 +39,10 @@ class LoggerService:
         self._producer.publish(
             body=log.model_dump_json(),
             exchange=self._exchange,
-            routing_key=LOG_REQUESTS_QUEUE,
+            routing_key=config.LOG_REQUESTS_QUEUE,
             headers={
                 "cap-msg-id": str(uuid.uuid4()),
-                "cap-msg-name": LOG_REQUESTS_QUEUE,
+                "cap-msg-name": config.LOG_REQUESTS_QUEUE,
             },
             content_type="application/json",
             retry=True
@@ -70,7 +62,7 @@ class LoggerService:
         user = current_user_info.get(None)
         if user:
             log.UserId = user.nameid
-        log.ServiceName = SERVICE_NAME
+        log.ServiceName = config.SERVICE_NAME
         log.MethodName = method_name
         log.Description = endpoint_name
         log.IsSuccess = is_success
@@ -141,8 +133,10 @@ class LoggerService:
 
     @staticmethod
     def websocket_handler(websocket: WebSocket):
+        if not config.LOG_ENABLE:
+            return
         correlation_id = websocket.headers.get("x-request-id") or uuid.uuid4().hex
-        ip_address = websocket.headers.get(IP_HEADER_NAME)
+        ip_address = websocket.headers.get(config.IP_HEADER_NAME)
 
         log_obj = LogDTO(
             CorrelationId=correlation_id,

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/sharedkernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sharedkernel
-Version: 2.5.3
+Version: 2.5.6
 Summary: sharekernel is a shared package between all python projects
 Author: Smilinno
 Description-Content-Type: text/markdown
@@ -20,6 +20,7 @@ Requires-Dist: markdown
 Requires-Dist: beautifulsoup4
 Requires-Dist: deepdiff
 Requires-Dist: kombu
+Requires-Dist: redis
 Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
@@ -30,6 +31,12 @@ Dynamic: summary
 this is a shared kernel package
 
 # Change Log
+### Version 2.5.6
+- fix bug
+### Version 2.5.5
+- fix bug
+### Version 2.5.4
+- Add Ip Session Service
 ### Version 2.5.3
 - Fix bug
 ### Version 2.5.2

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/sharedkernel.egg-info/SOURCES.txt

@@ -1,10 +1,12 @@
 README.md
 setup.py
 sharedkernel/common.py
+sharedkernel/config.py
 sharedkernel/data_format_converter.py
 sharedkernel/date_converter.py
 sharedkernel/diff_utils.py
 sharedkernel/file_validation.py
+sharedkernel/ip_session_service.py
 sharedkernel/jwt_service.py
 sharedkernel/multipart_upload.py
 sharedkernel/regex_masking.py
@@ -17,11 +19,13 @@ sharedkernel.egg-info/requires.txt
 sharedkernel.egg-info/top_level.txt
 sharedkernel/database/__init__.py
 sharedkernel/database/audit_model.py
+sharedkernel/database/distributed_cache.py
 sharedkernel/database/mongo_generic_audit_repository.py
 sharedkernel/database/mongo_generic_repository.py
 sharedkernel/database/pagination_response_dto.py
 sharedkernel/enum/__init__.py
 sharedkernel/enum/error_code.py
+sharedkernel/enum/redis_mode_enum.py
 sharedkernel/enum/sort_order.py
 sharedkernel/exception/__init__.py
 sharedkernel/exception/exception.py

{sharedkernel-2.5.3 → sharedkernel-2.5.6}/sharedkernel.egg-info/requires.txt

@@ -14,3 +14,4 @@ markdown
 beautifulsoup4
 deepdiff
 kombu
+redis

sharedkernel-2.5.3/sharedkernel/enum/__init__.py

@@ -1 +0,0 @@
-from .error_code import ErrorCode