jknife 0.0.1__py2.py3-none-any.whl

jknife/dependencies/token.py

@@ -0,0 +1,202 @@
+# import packages from default or pip library
+import jwt
+from redis.exceptions import ConnectionError
+from random import randint
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBasic, HTTPBearer, HTTPAuthorizationCredentials
+from datetime import datetime, timedelta, timezone
+
+# import packages from this framework
+from settings import AUTHENTICATION
+from src.jknife.db import logger
+from src.jknife.db import redis_connector
+
+
+# create secret key in this file.
+def create_secretkey() -> str:
+    return "".join([chr(randint(65, 122)) for _ in range(256)])
+
+
+# SETTINGS
+_DEFAULT_TOKEN_VALID_TIME: int = 20
+_DEFAULT_TOKEN_REFRESH_TIME: int = 24 * 60 * 30
+_TOKEN_SETTING: dict = AUTHENTICATION.get("token")
+_TOKEN_SECRET_KEY: str = _TOKEN_SETTING.get("secret_key") or create_secretkey()
+_TOKEN_ISSUER: str = _TOKEN_SETTING.get("token_issuer") or "127.0.0.1"
+_TOKEN_AUDIENCE: str = _TOKEN_SETTING.get("token_audience") or "http://127.0.0.1"
+_TOKEN_EXP_ACCESS: int = _TOKEN_SETTING.get("token_valid_time") or _DEFAULT_TOKEN_VALID_TIME
+_TOKEN_EXP_REFRESH: int = _TOKEN_SETTING.get("token_refresh_time") or _DEFAULT_TOKEN_REFRESH_TIME
+_TOKEN_ALGORITHM: str = _TOKEN_SETTING.get("algorithm") or "HS256"
+
+
+# Bearer Token Window
+oauth2_scheme = HTTPBearer(scheme_name="bearer",
+                           description="Authentication related with JWT token.\nInput access token got after signing in.",
+                           auto_error=False)
+basic_scheme = HTTPBasic(scheme_name="basic",
+                         description="Authentication with username and password.\nInput username and password.",
+                         auto_error=False)
+
+
+# define function for tokens
+def _check_blacklist_access_token(token: str) -> str:
+    """
+    check whether the access token is registered as blacklist in redis.
+
+    :param token: access_token in string
+    :return: access_token, if it is not registered in redis
+    """
+
+    user_unique = decode_jwt_token(token=token).get("sub")
+
+    if redis_connector.get(name=f"access_token:{token}"):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail={"msg": "invalid access token"})
+
+    elif not redis_connector.get(name=f"refresh_token:{user_unique}"):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail={"msg": "you have to sign in first."})
+
+    return token
+
+def check_whitelist_refresh_token(user_unique: str, token: str):
+    """
+    check whether the refresh token is registered as whitelist in redis.
+
+    :param token: refresh_token in string
+    :return: refresh_token, if it is registered in redis
+    """
+
+    registered_token: bytes = redis_connector.get(name=f"refresh_token:{user_unique}")
+    if registered_token is None:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail={"msg": "you have to sign in first."})
+
+    if registered_token.decode("utf-8") != token:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail={"msg": "invalid refresh token"})
+    return token
+
+def create_jwt_token(user_unique: str, user_data: dict, is_access: bool=True) -> str:
+    """
+    create jwt token(access and refresh) with user data.
+
+    :param user_unique: primary key to distinguish specific object among the users.
+    :param user_data: user data that is customised by developer.
+    :param is_access: set token type as bool for access(default) or refresh(False).
+    :return: encrypted string token.
+    """
+
+    payload: dict = {
+        "iss": _TOKEN_ISSUER,
+        "sub": str(user_unique),
+        "aud": _TOKEN_AUDIENCE,
+        "exp": datetime.now(timezone.utc) + timedelta(minutes=_TOKEN_EXP_ACCESS if is_access else _TOKEN_EXP_REFRESH),
+        "user_data": user_data,
+    }
+    return jwt.encode(payload=payload,
+                      key=_TOKEN_SECRET_KEY,
+                      algorithm=_TOKEN_ALGORITHM)
+
+def decode_jwt_token(token:str, is_access:bool=True) -> dict | None:
+    """
+    decode jwt token information that encrypted in token string.
+
+    :param token: token value in string
+    :param is_access: set token type as bool for access(default) or refresh(False).
+    :return:
+    """
+
+    try:
+        return jwt.decode(jwt=token,
+                          key=_TOKEN_SECRET_KEY,
+                          audience=_TOKEN_AUDIENCE,
+                          algorithms=_TOKEN_ALGORITHM)
+
+    except jwt.exceptions.ExpiredSignatureError:
+        token_type: str = "access" if is_access else "refresh"
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail={"msg": f"{token_type} token was expired"})
+
+    except jwt.exceptions.DecodeError:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail={"msg": "invalid access token. can not decode token information."})
+
+def get_bearer_access_token(user_cred: HTTPAuthorizationCredentials = Depends(oauth2_scheme)) -> str:
+    """
+    get access token from HTTPBearer credential in RestAPI Docs Page.
+
+    :param user_cred: get access_token information from HTTPBearer credential
+    :return: return access_token
+    """
+
+    if user_cred is None:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail={"msg": "missing access token in headers."})
+
+    if user_cred.scheme.lower() != "bearer":
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
+                            detail={"msg": "invalid access token. token type is not match."})
+
+    return _check_blacklist_access_token(token=user_cred.credentials)
+
+def get_token_info(token: str, is_access: bool = True) -> dict:
+    """
+    decrypt JWT token and return its data as dict type.
+
+    :param token: JWT token(access or refresh)
+    :param is_access: set token type as bool for access(default) or refresh(False).
+    :return: token information in dict type.
+    """
+
+
+    payload: dict = decode_jwt_token(token=token, is_access=is_access)
+    return payload
+
+def register_blacklist_access_token(token: str, ex: int=_TOKEN_EXP_ACCESS) -> None:
+    """
+    register JWT access token in redis after signout or changing password
+    template: access_token: {ACCESS_TOKEN}
+
+    :param token: access_token that will be registered in redis.
+    :param ex: token expiration time in second.
+    :return: None
+    """
+
+    try:
+        redis_connector.set(name=f"access_token:{token}", value="1", ex=ex * 60)
+    except ConnectionError:
+        logger.warning(msg="fail to register access_token as a blacklist. can not connect to redis db.")
+
+    return None
+
+def register_whitelist_refresh_token(user_unique: str, token: str) -> None:
+    """
+    register JWT refresh token in redis after signin.
+    template: refresh_token:{USER_UNIQUE}
+
+    :param user_unique: primary key for each user.
+    :param token: refresh token that was issued after signin.
+    :return: None
+    """
+    try:
+        redis_connector.set(name=f"refresh_token:{user_unique}", value=token, ex=_TOKEN_EXP_REFRESH * 60)
+    except ConnectionError:
+        logger.warning(msg="fail to register refresh_token as a whitelist. can not connect to redis db.")
+
+    return None
+
+def remove_whitelist_refresh_token(user_unique: str) -> None:
+    """
+    remove registered refresh token in redis after signout or changing password.
+
+    :param user_unique: primary key for each user.
+    :return: None
+    """
+
+    try:
+        redis_connector.delete(f"refresh_token:{user_unique}")
+    except ConnectionError:
+        logger.warning(msg="fail to remove refresh token from redis. can not connect to redis db.")
+
+    return None

jknife/dependencies/users.py

@@ -0,0 +1,76 @@
+# import packages from default or pip library
+from fastapi.exceptions import RequestValidationError
+
+# import packages from this framework
+from settings import PASSWORD_POLICIES
+
+
+# settings
+MIN_LENGTH: int = PASSWORD_POLICIES.get("min_length")
+SPECIAL_CHARS: str = "!@#$%^&*()_-+=~`\'\";:\\|<>,.?/"
+
+
+# define password policy functions
+def password_minlen(password: str, field: str = "password"):
+    if len(password) >= MIN_LENGTH:
+        return password
+
+    raise RequestValidationError(errors={"input": field,
+                                         "msg": f"{field} must be at least 8 chars"})
+
+
+def password_upchar(password: str, field: str = "password") -> str:
+    for c in password:
+        if c.isupper():
+            return password
+
+    raise RequestValidationError(errors={"input": field,
+                                         "msg": f"{field} must contain at least one upper character"})
+
+def password_lowchar(password: str, field: str = "password") -> str:
+    for c in password:
+        if c.islower():
+            return password
+
+    raise RequestValidationError(errors={"input": field,
+                                         "msg": f"{field} must contain at least one lower character"})
+
+
+def password_number(password: str, field: str = "password") -> str:
+    for c in password:
+        if c.isnumeric():
+            return password
+
+    raise RequestValidationError(errors={"input": field,
+                                         "msg": f"{field} must contain at least one number"})
+
+
+def password_special(password: str, field: str = "password") -> str:
+    for c in password:
+        if c in SPECIAL_CHARS:
+            return password
+
+    raise RequestValidationError(errors={"input":field,
+                                         "msg":f"{field} must contain at least one special character"})
+
+
+# define dependencies functions
+def validate_password_policy(password: str, field: str = "password") -> str:
+    policy_mapping: dict = {
+        "PASSWORD_MINLEN": password_minlen,
+        "PASSWORD_UPCHAR": password_upchar,
+        "PASSWORD_LOWCHAR": password_lowchar,
+        "PASSWORD_NUMBER": password_number,
+        "PASSWORD_SPECIAL": password_special,
+    }
+    validate_list: list = PASSWORD_POLICIES.get("compliance")
+
+    if len(validate_list) == 0:
+        return password
+
+    for func in validate_list:
+        tmp = policy_mapping.get(func)
+        if tmp is not None and callable(tmp):
+            tmp(password=password, field=field)
+
+    return password

jknife/logging.py

@@ -0,0 +1,69 @@
+import logging
+import logging.config
+from os import mkdir, listdir
+from typing_extensions import Annotated, Doc
+from settings import LOG_SETTINGS, DEBUG_MODE
+
+
+# create logs folder to store log files.
+if "logs" not in listdir(""):
+    mkdir("logs")
+
+# set logging config from settings.py
+# apply default key:value for dictConfig
+LOG_SETTINGS.update({"version": 1, "disable_existing_loggers": False})
+logging.config.dictConfig(config=LOG_SETTINGS)
+
+
+# define LoggerMgmt for multiple logging
+class LoggerMgmt:
+    """
+    This class is designed to implement multiple logging system in FastAPI.
+
+    :param logger_names: assign the logger name that you want to use in specific area.
+                         you can define it in settings.py with LOG_SETTINGS and *_LOGGER_LIST
+    """
+
+    def __init__(self,
+                 logger_names: Annotated[list[str],
+                                         Doc("assign the name of loggers to record activities")]):
+        self.__loggers = [logging.getLogger(name=name) for name in logger_names]
+        if DEBUG_MODE:
+            uvicorn_logger = logging.getLogger(name="uvicorn")
+            uvicorn_logger.setLevel(level="DEBUG")
+            self.__loggers.append(uvicorn_logger)
+
+    def critical(self, msg: Annotated[str,
+                                      Doc("log message for critical level")]) -> None:
+        for logger in self.__loggers:
+            logger.critical(msg=msg)
+
+        return None
+
+    def error(self, msg: Annotated[str,
+                                   Doc("log message for error level")]) -> None:
+        for logger in self.__loggers:
+            logger.error(msg=msg)
+
+        return None
+
+    def warning(self, msg: Annotated[str,
+                                     Doc("log message for warning level")]) -> None:
+        for logger in self.__loggers:
+            logger.warning(msg=msg)
+
+        return None
+
+    def info(self, msg: Annotated[str,
+                                  Doc("log message for info level")]) -> None:
+        for logger in self.__loggers:
+            logger.info(msg=msg)
+
+        return None
+
+    def debug(self, msg: Annotated[str,
+                                  Doc("log message for debug level")]) -> None:
+        for logger in self.__loggers:
+            logger.debug(msg=msg)
+
+        return None

jknife/views/__init__.py

@@ -0,0 +1,23 @@
+# import packages from default or pip library
+from datetime import datetime
+from pydantic import BaseModel
+from typing_extensions import Annotated, Doc, Optional
+from uuid import UUID
+
+# import packages from this framework
+
+
+# define mixin class
+class IdViewMixin(BaseModel):
+    id: Annotated[int,
+    Doc("Default integer id for each table row.")]
+
+
+class UUIDViewMixin(BaseModel):
+    id: Annotated[UUID,
+    Doc("UUID format id for each table row.")]
+
+
+class RegisterDateTimeViewMixin(BaseModel):
+    register_dt: Annotated[Optional[datetime],
+    Doc("Datetime that the row was added at.")]

jknife/views/error_message.py

@@ -0,0 +1,38 @@
+# import packages from default or pip library
+from typing_extensions import Annotated, Doc
+from pydantic import BaseModel
+
+# import packages from this framework
+
+
+# Error Mixin Class
+class ErrMsgMixin(BaseModel):
+    msg: Annotated[str,
+    Doc("message for error")]
+
+
+class ErrMsgTypeMixin(BaseModel):
+    type: Annotated[str,
+    Doc("customised message type. for example, 'password_mismatch' or 'unauthorised access'.")]
+
+
+class ErrMsgBoolResultMixin(BaseModel):
+    result: Annotated[bool, Doc("result of calling API in bool type.")] = False
+
+
+class FieldValidationErrMixin(BaseModel):
+    field: Annotated[str,
+    Doc("field name which has an error.")]
+
+
+# Error Model
+class DefaultErrorMsgView(ErrMsgMixin):
+    pass
+
+
+class ErrMsgWithTypeView(ErrMsgTypeMixin, DefaultErrorMsgView):
+    pass
+
+
+class ErrMsgWithTypeAndResultView(ErrMsgBoolResultMixin, ErrMsgWithTypeView):
+    pass

jknife/views/personnel_info.py

@@ -0,0 +1,42 @@
+# import packages from default or pip library
+from datetime import date
+from typing_extensions import Annotated, Doc
+from pydantic import BaseModel, EmailStr
+
+# import packages from this framework
+
+
+# define mixin class
+class BirthdateViewMixin(BaseModel):
+    birthdate: Annotated[date,
+    Doc("user's birthdate")]
+
+
+class CPNumViewMixin(BaseModel):
+    cp_num: Annotated[str,
+    Doc("cellphone number.")]
+
+
+class EmailInputViewMixin(BaseModel):
+    email: Annotated[EmailStr,
+    Doc("email address for user. it can be replaced username.")]
+
+
+class FirstNameViewMixin(BaseModel):
+    firstname: Annotated[str,
+    Doc("firstname of user")]
+
+
+class LastNameViewMixin(BaseModel):
+    lastname: Annotated[str,
+    Doc("lastname of user")]
+
+
+class NationViewMixin(BaseModel):
+    nation: Annotated[str,
+    Doc("the nation that user came from.")]
+
+
+class PostalCodeViewMixin(BaseModel):
+    postal_code: Annotated[str,
+    Doc("postal number of address.")]

jknife/views/tokens.py

@@ -0,0 +1,22 @@
+# import packages from default or pip library
+from typing_extensions import Annotated, Doc
+from pydantic import BaseModel
+
+
+# import packages from this framework
+
+
+
+# define Class for Common SQLModel
+class DefaultJWTTokenView(BaseModel):
+    """
+    This class is a view template for returning JWT tokens information.
+    Read Only.
+    """
+
+    access_token: Annotated[str,
+    Doc("This is an access token string for authenticated user")]
+    refresh_token: Annotated[str,
+    Doc("This is a token string for reissuing access token")]
+    token_type: Annotated[str,
+    Doc("Token type that used in this class. Default is 'Bearer'")] = "Bearer"

jknife/views/users.py

@@ -0,0 +1,70 @@
+# import packages from default or pip library
+from datetime import datetime
+from typing_extensions import Annotated, Doc
+from pydantic import BaseModel, field_validator
+
+# import packages from this framework
+from src.jknife.views.personnel_info import EmailInputViewMixin
+from src.jknife.dependencies.users import validate_password_policy
+
+
+# define mixin class
+class UsernameInputViewMixin(BaseModel):
+    username: Annotated[str,
+    Doc("username")]
+
+
+class InputPasswordViewMixin(BaseModel):
+    password: Annotated[str,
+    Doc("password for user")]
+
+
+class LastSigninDateTimeViewMixin(BaseModel):
+    last_signin_dt: Annotated[datetime | None,
+    Doc("User's last signin datetime.")] = None
+
+
+class SigninFailMixin(BaseModel):
+    is_active: Annotated[bool,
+    Doc("show whether the user is activated or not.")]
+    signin_fail: Annotated[int,
+    Doc("If the user fail to login, this value will be incremented.")]
+
+
+# define common view class
+class ChangePasswordView(InputPasswordViewMixin):
+    new_password: Annotated[str,
+    Doc("New password for changing password")]
+
+    @field_validator('new_password', mode='before')
+    @classmethod
+    def check_new_password(cls, value) -> str:
+        return validate_password_policy(password=value, field="new_password")
+
+
+class DefaultSignupView(InputPasswordViewMixin, UsernameInputViewMixin):
+    password: Annotated[str,
+    Doc("password for user")]
+
+    @field_validator('password', mode='before')
+    @classmethod
+    def check_password(cls, value) -> str:
+        return validate_password_policy(password=value)
+
+
+class DefaultEmailSignupView(InputPasswordViewMixin, EmailInputViewMixin):
+    password: Annotated[str,
+    Doc("password for user")]
+
+    @field_validator('password', mode='before')
+    @classmethod
+    def check_password(cls, value) -> str:
+        return validate_password_policy(password=value)
+
+
+class UsernameSigninView(InputPasswordViewMixin, UsernameInputViewMixin):
+    pass
+
+
+class EmailSigninView(InputPasswordViewMixin, EmailInputViewMixin):
+    pass

jknife-0.0.1.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: jknife
+Version: 0.0.1
+Summary: Custom FastAPI for luna-negra
+Author: luna-negra
+License-Expression: MIT
+License-File: LICENSE
+Keywords: Backend,Customised,FastAPI,Python,pypi
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: blinker>=1.9.0
+Requires-Dist: fastapi[standard]>=0.166.1
+Requires-Dist: mongoengine
+Requires-Dist: pycountry>=24.6.1
+Requires-Dist: pyjwt>=2.10.1
+Requires-Dist: redis>=6.4.0
+Requires-Dist: sqlmodel>=0.0.24

jknife-0.0.1.dist-info/RECORD

@@ -0,0 +1,31 @@
+jknife/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jknife/logging.py,sha256=0MVIdLEYE2hpaRHhjbS20hFKIFXVJVVDzqyJmUU8_HQ,2314
+jknife/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jknife/commands/jknife.py,sha256=Mu-oiYMjdHT0rD3jKjum6_9K_RjbxuqB2C7gr-_Qukc,11635
+jknife/db/__init__.py,sha256=weR-h-z2xd4wW64kc5rCrG7zz3toe-bwggoBka_g0nA,6245
+jknife/db/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jknife/db/models/mongo/__init__.py,sha256=bDj6rFEtNudrbtPbk4iORlWwXyMv6V_PCeixyGufxP4,1984
+jknife/db/models/mongo/network.py,sha256=MfFq05k_42uw4mMfcd62K7MOhuk0E5OuqfxmHD_ONR0,1106
+jknife/db/models/mongo/personnel_info.py,sha256=wIalbvVI1bqCTOsShrSvy29I6OrdqaY6nYGhSxRFTf0,3273
+jknife/db/models/mongo/settings.py,sha256=mFJQAAeoyWEY1J6y5_l1p4JevOYHyX27wL5A-gO35bg,2219
+jknife/db/models/mongo/token.py,sha256=Xfw6LlAZ8Qu2iA9vYxyTk52aq4KoMLZ9P0KBRDiOBLI,2410
+jknife/db/models/mongo/users.py,sha256=xTlkK5BiF5oSaeFyF1aTh7JDpu2K6Jr0MI2ALt0BoSA,2931
+jknife/db/models/rdbms/__init__.py,sha256=0r22xz8J_kENMiPNVr_t3P5iILGXsll38wXXwnREABc,1847
+jknife/db/models/rdbms/network.py,sha256=lk3p4UBbsnPRuwr5Q4CGXDL9bSAlZAEaUz-GVfEWc0U,1040
+jknife/db/models/rdbms/personnel_info.py,sha256=OBwMvg8K_3XqKSSaeJzDir_pIIHNd3cxdL-2IsQFuFQ,2976
+jknife/db/models/rdbms/settings.py,sha256=p_typKsxO6aCh-HNL_vlj9GIT7gm-eYkyA-vvo0wsmY,1520
+jknife/db/models/rdbms/token.py,sha256=4JP3sdspM-nsBXM9v1zbM2JqI56FzKPsP7nNowZDPGo,2179
+jknife/db/models/rdbms/users.py,sha256=5vldUYl3pGZjWjuWGvn6M0SeHvj869omcMS6TkBVSa4,3189
+jknife/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jknife/dependencies/token.py,sha256=uBQ_zIU56HBOZH_mQWwdQeEFv7VXdKAJn7MAFqWODsU,7765
+jknife/dependencies/users.py,sha256=G6bJ-vHz7hlHXn2OpNEAoVB1H8DJhwc4XBMBmKW1v6Q,2502
+jknife/views/__init__.py,sha256=uXUiBzToN6gmb7zcHUyPbniNjCtzbyN31FrIVs7PpI0,596
+jknife/views/error_message.py,sha256=g3xS8Z0R1BeP9XpmETgLirDdghM789iGXBfU-K8wwWM,887
+jknife/views/personnel_info.py,sha256=JL_GqerZjhgs4AJQsQ2eeUZxCh17G8zXuWsDqaEI2tk,957
+jknife/views/tokens.py,sha256=PJh_fGEwK3T6Kq0aY-CuJPWCTdcHFrCSd2NhJMZqYqU,647
+jknife/views/users.py,sha256=ndbSTMlEeiwazfejHrGj37Jnw-e40Y6YoZwzyyyM4ns,2041
+jknife-0.0.1.dist-info/METADATA,sha256=VPDim94DKvnv8t2T4RQrpcWOaOcBP7j1aRoQ6tWGa9I,519
+jknife-0.0.1.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+jknife-0.0.1.dist-info/entry_points.txt,sha256=08tkSuEw5jKr7Jz0cFlcKr8b2fjsQIf4Mzmb0cB8XOM,55
+jknife-0.0.1.dist-info/licenses/LICENSE,sha256=myY0xrsHJcytQadTeGVqmIo6QlskAAf5epHL-WRQe30,1067
+jknife-0.0.1.dist-info/RECORD,,

jknife-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

jknife-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jknife = jknife.commands.jknife:main

jknife-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright <YEAR> <COPYRIGHT HOLDER>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.