sharedkernel 1.0.0__py3-none-any.whl

sharedkernel/common.py

@@ -0,0 +1,29 @@
+import yaml
+import json
+
+def yaml2json(yaml_data:yaml) -> json:
+        
+    output = json.dumps(yaml.safe_load(yaml_data), indent=2)
+
+    return json.loads(output)
+
+def json2yaml(data) -> yaml:
+    
+    data=json.dumps(data,default=lambda o: del_none(o.__dict__))
+    
+    data=json.loads(data)
+    output = yaml.dump(data)
+    
+    return output
+
+def del_none(d):
+    """
+    Delete keys with the value ``None`` in a dictionary, recursively.
+    """
+
+    for key, value in list(d.items()):
+        if value is None:
+            del d[key]
+        elif isinstance(value, dict):
+            del_none(value)
+    return d  

sharedkernel/config.py

@@ -0,0 +1,12 @@
+
+# MONGO CONFIG
+
+# MONGO_CONNECTION_STRING = "mongodb://localhost:27017"
+MONGO_CONNECTION_STRING = "mongodb://admin:Xp!j1h73ALrD@188.121.112.202:27017"
+
+# AUTHENTICATION
+
+JWT_ISSURE = "enterprise-identity"
+JWT_AUDIENCE = "AdminPortal"
+JWT_SECRETKEY = "ThereR_10_Project$@$milinnoBut50%OfThemRPublished"
+JWT_ALGORITHM= "HS256"

sharedkernel/database/adapter.py

@@ -0,0 +1,6 @@
+from pymongo import MongoClient
+
+class MongoDBClient:
+    def __init__(self,connection_string):
+        self.client = MongoClient(connection_string)
+        self.domain = self.client.domain

sharedkernel/database/repository_base.py

@@ -0,0 +1,82 @@
+from typing import (Optional,
+                    List
+                    )
+from bson.objectid import ObjectId
+from typing import Generic, TypeVar
+from pydantic import BaseModel
+from pydantic import parse_obj_as
+
+from sharedkernel.string_extentions import camel_to_snake
+from .adapter import MongoDBClient
+
+
+from sharedkernel.exception.exception import BusinessException
+from sharedkernel.enum.error_code import ErrorCode
+
+mongo_client= MongoDBClient()
+
+ResultT = TypeVar("ResultT")
+
+T = TypeVar("T", bound=BaseModel)
+
+class RepositoryBase(Generic[T]):
+    
+    def __init__(self,model):
+      self.model = model
+      self.model_name= camel_to_snake(self.model.__name__)
+      
+      
+    def find(self,id: str) -> T:
+        if (not ObjectId.is_valid(id)):
+            raise BusinessException(ErrorCode.Item_NotFound)
+        
+        query = {"_id": ObjectId(id),"is_deleted":False}
+        
+        item = mongo_client.domain[self.model_name].find_one(query)
+        
+        if (not item):
+            raise BusinessException(ErrorCode.Item_NotFound)
+        
+        item['_id']=str(item['_id'])
+        item['id']= item['_id']
+        item.pop('_id')
+
+        return self.model.parse_obj(item) if item else None
+    
+        
+    def get_all(self,query:dict = None) -> Optional[List]:
+        if query:
+            query["is_deleted"]= False
+        else:
+            query= {"is_deleted":False}
+        items = list(mongo_client.domain[self.model_name].find(query))
+
+        for item in items:
+            item['_id'] = str(item['_id'])
+            item['id']= item['_id']
+            item.pop('_id')
+        
+        return parse_obj_as(List[self.model],items)
+    
+
+    def insert(self, insert_data: T) -> str:
+        delattr(insert_data, "id")
+        inserted_data= mongo_client.domain[self.model_name].insert_one(insert_data.dict())
+        
+        return str(inserted_data.inserted_id)
+    
+    def bulk_insert(self, insert_data: List[T]):
+        insert_data=[delattr(data, "id") for data in insert_data]
+        mongo_client.domain[self.model_name].insert_many(insert_data)
+
+
+
+    def update(self,id:str,update_data: T):
+        query = {"_id": ObjectId(id)}
+        delattr(update_data, "id")
+        mongo_client.domain[self.model_name].update_one(query,  {"$set": update_data.dict()}, upsert=False)
+        
+
+    def query(self):
+        return mongo_client.domain[self.model_name]
+        

sharedkernel/enum/error_code.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class ErrorCode(str, Enum):
+    Item_NotFound= "یافت نشد"
+
+    Internal_Server= "خطایی در سیستم رخ داده است"
+
+    UnAuthorized= "توکن دسترسی معتبر نمی باشد"
+
+    Success= "با موفقیت انجام شد"
+    
+    Intents_Count_Should_Equal_One= "فقط یک اینتنت میتوانید وارد نمایید"

sharedkernel/exception/__init__.py

@@ -0,0 +1,5 @@
+from .exception import CustomException,BusinessException,UnAuthorizedException
+from .exception_handlers import http_exception_handler,\
+                                business_http_exception_handler,\
+                                custom_http_exception_handler,\
+                                exception_handler

sharedkernel/exception/exception.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict, Optional
+from fastapi import HTTPException, status
+
+from sharedkernel.enum.error_code import ErrorCode
+
+
+class CustomException(HTTPException):
+    def __init__(
+        self,
+        status_code:int,
+        error_code: str,
+        detail: Any = None,
+        headers: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(status_code= status_code,detail= detail)
+        self.headers = headers
+        self.error_code = error_code
+
+
+class BusinessException(HTTPException):
+    def __init__(
+        self,
+        error_code: ErrorCode,
+        headers: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(status.HTTP_400_BAD_REQUEST,detail=error_code.value)
+        self.headers = headers
+        self.error_code = error_code.name
+
+
+class UnAuthorizedException(HTTPException):
+    def __init__(
+            self,
+            headers: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(status.HTTP_401_UNAUTHORIZED, headers)
+
+
+
+

sharedkernel/exception/exception_handlers.py

@@ -0,0 +1,74 @@
+
+from fastapi import Request,status
+import requests
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import HTTPException
+
+from sharedkernel.exception import (
+                                        BusinessException,
+                                        UnAuthorizedException,
+                                        CustomException
+                                     )
+from sharedkernel.objects import Result
+from sharedkernel.enum.error_code import ErrorCode
+
+
+
+async def http_exception_handler(request: Request, exc: HTTPException):
+    if type(exc)==UnAuthorizedException :
+        return await custom_http_exception_handler(
+                                                    request,
+                                                    CustomException
+                                                    (
+                                                        status_code= exc.status_code,
+                                                        error_code= ErrorCode.UnAuthorized.name,
+                                                        detail= ErrorCode.UnAuthorized.value
+                                                    )
+                                                 )
+
+    return await custom_http_exception_handler(
+                                                request,
+                                                CustomException
+                                                (
+                                                    status_code= exc.status_code,
+                                                    error_code= requests.status_codes._codes[exc.status_code][0].title(),
+                                                    detail= exc.detail
+                                                )
+                                            )
+
+
+
+async def business_http_exception_handler(request: Request, exc: BusinessException):
+    return await custom_http_exception_handler(
+                                    request,
+                                    CustomException
+                                    (
+                                        status_code= status.HTTP_400_BAD_REQUEST,
+                                        error_code= exc.error_code,
+                                        detail= exc.detail
+                                    ),
+    )
+
+async def custom_http_exception_handler(request: Request, exc: CustomException):
+    return JSONResponse(
+                        status_code=exc.status_code,
+                        content= Result(    isSucceed= False,
+                                            data= None,
+                                            message= exc.detail,
+                                            errorCode= exc.error_code
+                                        ).__dict__
+                     )       
+
+
+async def exception_handler(request: Request, exc: Exception):
+   
+    return await custom_http_exception_handler(
+        request,
+        CustomException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            error_code=ErrorCode.Internal_Server.name,
+            detail=ErrorCode.Internal_Server.value
+        ),
+    )
+
+

sharedkernel/jwt_service.py

@@ -0,0 +1,38 @@
+import jwt
+import time
+from fastapi import Request
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+from sharedkernel.exception.exception import UnAuthorizedException
+from sharedkernel.objects import JwtModel
+
+
+class JWTBearer(HTTPBearer):
+
+    def __init__(self,jwt_config:JwtModel, auto_error: bool = True):
+        self.jwt_config=jwt_config
+        super(JWTBearer, self).__init__(auto_error=auto_error)
+
+    async def __call__(self, request: Request):
+        try:
+            credentials: HTTPAuthorizationCredentials = await super(
+                JWTBearer, self
+            ).__call__(request)
+
+            self.verify(credentials.credentials)
+
+        except:
+            raise UnAuthorizedException()       
+
+
+    def verify(self, token: str) -> bool:
+            decoded_token = jwt.decode(
+            jwt= token.replace("Bearer","").strip(),
+            key= self.jwt_config.secret_key,
+            algorithms= self.jwt_config.algorithms,
+            audience= self.jwt_config.audience,
+            issuer= self.jwt_config.issuer
+            )
+
+            if decoded_token["exp"] < time.time():
+                raise UnAuthorizedException()

sharedkernel/objects/__init__.py

@@ -0,0 +1,3 @@
+from .base_document import BaseDocument
+from .jwt_model import JwtModel
+from .result import Result

sharedkernel/objects/base_document.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+from typing import  Optional
+
+class BaseDocument(BaseModel):
+    id: Optional[str]
+    is_deleted: bool = False
+    # created_on: datetime.datetime.now()
+

sharedkernel/objects/jwt_model.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel   
+
+class JwtModel(BaseModel):
+    secret_key:str
+    algorithms: str
+    audience: str
+    issuer: str

sharedkernel/objects/result.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+from pydantic.generics import GenericModel
+
+from sharedkernel.enum.error_code import ErrorCode
+
+ResultT = TypeVar("ResultT")
+
+
+class BaseResult(BaseModel):
+    isSucceed:bool = True
+    message: str = ErrorCode.Success.value
+    errorCode: str = None
+
+class Result(BaseResult,GenericModel, Generic[ResultT]):
+    data: ResultT =None
+
+    def __init__(
+        self,
+        isSucceed:bool = True,
+        data: object = None,
+        message: str = ErrorCode.Success.value,
+        errorCode: str = None
+        )-> None:
+        super().__init__(isSucceed= isSucceed, data= data, message= message, errorCode= errorCode)

sharedkernel/string_extentions.py

@@ -0,0 +1,4 @@
+import re
+
+def camel_to_snake(value:str):
+   return re.sub('(?!^)([A-Z]+)', r'_\1',value).lower()

sharedkernel-1.0.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: sharedkernel
+Version: 1.0.0
+Summary: sharekernel is an shared package between all python projects
+Author: Smilinno
+Requires-Dist: numpy
+Requires-Dist: requests
+Requires-Dist: pymongo
+Requires-Dist: fastapi ==0.89.1
+Requires-Dist: PyJWT
+

sharedkernel-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+sharedkernel/common.py,sha256=HL5vsuJBaIeBcoXA8Hbe6jnYAv4danIszo5Y7G2gGDA,622
+sharedkernel/config.py,sha256=e77EbMSv-gTmtXklh1mYNHWuY-ztE7RKGv_sL6XS-Qo,326
+sharedkernel/jwt_service.py,sha256=MzlfGROiNhUGDtCPNrpN5T0IgK_bn8M7tAJ9lnCUD9M,1178
+sharedkernel/string_extentions.py,sha256=ld02W06gd0Ql80GQU6nlqPAeUSfOe2Yr8cCzf3lJgQY,98
+sharedkernel/database/adapter.py,sha256=hxCRusICwWyNopG5rQ8lDHgaTc_-XbkUfugI67ccDm4,190
+sharedkernel/database/repository_base.py,sha256=f0Lqn3aVmtuRSslMuV16hOTBq7A9X4G2QED4Far_OO4,2412
+sharedkernel/enum/error_code.py,sha256=xGR0hGj4rbkBKvQQ_GOEInRay_f8yw6gs-GOsYmrX7w,387
+sharedkernel/exception/__init__.py,sha256=VvWkai1Biz4KVYS58aS_xUdhhphS6WbxB2-lH05UiZs,319
+sharedkernel/exception/exception.py,sha256=TOxnymWJfhsrMmuLsG-amqJlDxmzznEfRnqDBe1vizk,1016
+sharedkernel/exception/exception_handlers.py,sha256=81b0sp_QL2TZJMplyZkFnh8tWmGzDdd7230EBcL1UOA,3176
+sharedkernel/objects/__init__.py,sha256=7s5P9I3JQOrAhEWVyTPEHoQ7Xz_56UubfFJ-WEcHXTU,100
+sharedkernel/objects/base_document.py,sha256=BLK_16ji_1BkahqZj9HAnju5pbI99PekcyMaPFAQ1NE,186
+sharedkernel/objects/jwt_model.py,sha256=XQHQhTbg7PT8XiUh5fd9MwRH4ldPsesI_hfbjaSqdKg,134
+sharedkernel/objects/result.py,sha256=zKGONnS9ctEE2XgegdWWhptIZhFvEF3qyz-me7nO_qo,721
+sharedkernel-1.0.0.dist-info/METADATA,sha256=23XFIBvBTlD7-_ZXenHYgg4G8gxcrIlRQz9dYEIu3lc,276
+sharedkernel-1.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+sharedkernel-1.0.0.dist-info/top_level.txt,sha256=TVTOnV1MItSSlpSjqkiijuHkoVsGHS4CArpsM-lylkE,13
+sharedkernel-1.0.0.dist-info/RECORD,,

sharedkernel-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sharedkernel-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sharedkernel