rj-core 0.1.1__tar.gz

rj_core-0.1.1/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: rj-core
+Version: 0.1.1
+Author: rahul
+Requires-Dist: bcrypt
+Requires-Dist: rj-home

rj_core-0.1.1/pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "rj-core"
+version = "0.1.1"
+authors = [
+    { name = "rahul" }
+]
+dependencies = ['bcrypt', "rj-home"]

rj_core-0.1.1/rj_core/cli.py

@@ -0,0 +1,121 @@
+import rj.settings
+
+from rj.settings import *
+from rj.core.helpers import jsonify
+
+
+def formatted_json_string_literal(JSON):
+    keys = []
+    values = []
+    largest_key = ""
+    len_largest_key = -1
+    if not isinstance(JSON, dict):
+        raise TypeError("The argument must be a dict.")
+    else:
+        for key, value in JSON.items():
+            keys.append(key)
+            len_key = len(key)
+            if len_key > len_largest_key:
+                largest_key = key
+                len_largest_key = len_key
+            values.append(value)
+
+        try:
+            print("{\n")
+            for key, value in JSON.items():
+                len_key = len(key)
+                remaining_len = len_largest_key - len_key
+                spacing = ""
+                for i in range(remaining_len):
+                    spacing += " "
+                string = key + spacing + "  "
+                print("\t%s:  %s" % (string, value))
+
+            print("}")
+
+        except Exception as e:
+            print(e)
+
+
+def chaduvukofirst():
+    print("Breakup ainda...?? Poyi Chitti tho kalisi chaduvuko ra poookkaaa!!!!")
+
+
+def cli_test():
+
+    import sys
+
+    if len(sys.argv) < 2:
+        print("No command given")
+        exit(1)
+
+    command = sys.argv[1]
+
+    match command:
+        case "settings":
+            print("__reding__settings__")
+
+        case "read_settings":
+            from rj.settings import SETTINGS_JSON_PATH
+            import json
+
+            with open(SETTINGS_JSON_PATH, "r") as settings:
+                try:
+                    settings_dictionary = json.load(settings)
+                    formatted_json_string_literal(settings_dictionary)
+
+                except json.JSONDecodeError as e:
+                    import sys
+
+                    print(
+                        "\033[31mError occurred during handling settings. Improperly configured settings.\033[0m"
+                    )
+                    print()
+                    write_log(e, True)
+                    write_log(settings.read())
+
+        case "set_username_validator":
+            set_username_validator()
+        case "help":
+            pass
+        case "-h":
+            pass
+        case "--help":
+            help = jsonify(
+                settings="reads settings",
+                read_settings="reads settings and print out to the terminal",
+                set_username_validator="sets username validator regex.",
+                read_logs="Prints out the logs written in logs",
+                clear_logs="Clears all the log file",
+                initialise_settings="Initialises settings, and fixes the errrosr and overwrites settings json, if errors were found.",
+            )
+
+            print("avaliable commands:")
+            formatted_json_string_literal(help)
+
+        case "read_logs":
+
+            read_logs()
+
+        case "clear_logs":
+
+            settings.clear_logs()
+
+        case "mails":
+            from rj.mails import show_help, help
+
+            if sys.argv[2] == "--help":
+
+                show_help()
+
+            else:
+                print("Use --help for longer description")
+                help()
+        case "show_args":
+            print(("settings", "read_logs", "read_settings", "clear_logs", "--help"))
+        case "initialise_settings":
+
+            initialise_settings()
+
+        case _:
+            print("Iinvalid command.")

rj_core-0.1.1/rj_core/exeptions.py

@@ -0,0 +1,85 @@
+class BaseException(Exception):
+    def __init__(self, message="Value is required."):
+        self.message = f" {message}."
+        super().__init__(message)
+
+
+class PhoneNumberException(Exception):
+    message = "Invalid Phone number formats."
+
+    def __init__(self, message="Invalid Phone number formats."):
+        super().__init__(self.message)
+
+
+class InvalidCountryCodeException(Exception):
+    def __init__(self, message="Invalid country code format."):
+        self.message = f"InvalidPhoneNumberException : {message}."
+        super().__init__(self.message)
+
+
+class InvalidPhoneNumberException(Exception):
+    def __init__(self, message="Phone number should contain atleast 10 digits."):
+        self.message = f"{message}."
+        super().__init__(self.message)
+
+
+class InvalidEmailException(Exception):
+    def __init__(self, message="Email format is invalid."):
+        self.message = f"{message}."
+        super().__init__(self.message)
+
+
+class UsernameException(BaseException):
+    def __init__(self, message="Invalid Username format."):
+        self.message = f"{message}"
+        super().__init__(self.message)
+
+
+class ValidatePhoneNumber(Exception):
+
+    @staticmethod
+    def validate_phone(phone):
+        phone = str(phone)
+        country_code = phone[:-10]
+        if not phone.startswith("+") and len(country_code) < 2:
+            error_message = f"{phone} : Invalid countrycode country code is empty."
+            raise PhoneNumberException(error_message)
+
+        if len(phone) > 15 or len(phone) < 10:
+            PhoneNumberIsValid = True
+            for i in phone:
+                if int(i) in range(0, 9):
+                    pass
+                else:
+                    PhoneNumberIsValid = False
+                    raise PhoneNumberException(
+                        f"{phone} : Phone Number should contain only Digits (0-9)."
+                    )
+            raise PhoneNumberException(
+                f"{phone} : Phone number should be exactly 10 digits."
+            )
+        else:
+            phone_number = phone[-10:]
+        return {"phone_number": phone_number, "country_code": country_code}
+
+    def __call__(self, phone):
+        return self.validate_phone(phone)
+
+
+class MissingFieldError(ValueError):
+    def __init__(self, field="", *args):
+        self.message = f"The filed -- {field if not field == "" or field is not None else "__NOT_MENTIONED__"} -- is missing."
+        super().__init__(self.message)
+
+
+class IncompleteWritingError(BaseException):
+    def __init__(self, *args):
+        super().__init__("Error... The code is marked as incompete")
+
+
+class ImproperlyConfigured(Exception):
+    def __init__(self, *args):
+        super().__init__(*args)
+
+
+class RJMailsMIMETypeException(Exception): ...

rj_core-0.1.1/rj_core/helpers.py

@@ -0,0 +1,295 @@
+# def jsonify(update={}, *args: dict, **kwargs) -> dict:
+#     # update = {}
+#     for i in args:
+#         if isinstance(i, dict):
+#             update.setdefault("kwargs", {})
+#             update["kwargs"].update(i)
+
+#         else:
+#             update.setdefault("args", [])
+#             update["args"].append(i)
+
+#     for i in kwargs:
+#         update.setdefault(i, kwargs.get(i))
+
+#     return update
+
+
+# def jsonify(*args, ___ignore_empty__=False, **kwargs) -> dict:
+#     result = {}
+
+#     # Process all positional arguments (dicts or single values)
+#     for item in args:
+#         if isinstance(item, dict):
+#             if ___ignore_empty__:
+#                 continue
+#             # Merge dictionary and filter out empty strings/None values if needed
+#             for key, val in item.items():
+#                 if val:  # Filters out empty values like "", None, []
+#                     result[key] = val
+#         else:
+#             # Handle non-dict positional items
+#             result.setdefault("args", []).append(item)
+
+#     # Process keyword arguments (kwargs override positional args)
+#     for key, val in kwargs.items():
+#         if val:
+#             result[key] = val
+
+#     return result
+
+
+import json
+
+
+def jsonify(*args, ___ignore_empty__=False, **kwargs) -> dict:
+    result = {}
+
+    def is_valid(val):
+        if ___ignore_empty__:
+            return True
+        # Filter out None, empty strings, and empty collections (lists/dicts/tuples)
+        if val is None or val == "":
+            return False
+        if isinstance(val, (list, dict, set, tuple)) and len(val) == 0:
+            return False
+        return True
+
+    # 1. Process positional arguments
+    for item in args:
+        if isinstance(item, dict):
+            for key, val in item.items():
+                if is_valid(val):
+                    result[key] = val
+        else:
+            if is_valid(item):
+                result.setdefault("args", []).append(item)
+
+    # 2. Process keyword arguments
+    for key, val in kwargs.items():
+        if is_valid(val):
+            result[key] = val
+
+    return result
+
+
+class STATUS:
+    # --- 2xx Success ---
+    OK = 200
+    CREATED = 201
+    ACCEPTED = 202
+    NO_CONTENT = 204
+
+    # --- 3xx Redirection ---
+    MOVED_PERMANENTLY = 301
+    FOUND = 302
+    NOT_MODIFIED = 304
+
+    # --- 4xx Client Errors ---
+    BAD_REQUEST = 400
+    UNAUTHENTICATED = 401
+    UNAUTHORIZED = 403  # Forbidden
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    CONFLICT = 409
+    UNPROCESSABLE_ENTITY = 422
+    TOO_MANY_REQUESTS = 429
+
+    # --- 5xx Server Errors ---
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+
+    # Mapping codes to human-readable status phrases
+    _MESSAGES = {
+        200: "OK",
+        201: "Created",
+        202: "Accepted",
+        204: "No Content",
+        301: "Moved Permanently",
+        302: "Found",
+        304: "Not Modified",
+        400: "Bad Request",
+        401: "Unauthenticated",
+        403: "Unauthorized",
+        404: "Not Found",
+        405: "Method Not Allowed",
+        409: "Conflict",
+        422: "Unprocessable Entity",
+        429: "Too Many Requests",
+        500: "Internal Server Error",
+        501: "Not Implemented",
+        502: "Bad Gateway",
+        503: "Service Unavailable",
+        504: "Gateway Timeout",
+    }
+
+    def __init__(self, code):
+        if code not in self._MESSAGES:
+            raise ValueError(f"Invalid or unsupported status code: {code}")
+
+        self.status = code
+        self.message = self._MESSAGES[code]
+
+    def __repr__(self):
+        return f"<STATUS code={self.status} message='{self.message}'>"
+
+
+class returnjson:
+    @staticmethod
+    def _N_GET_STATUS_CODES():
+        return STATUS
+
+    def __init__(
+        self,
+        dictionary={},
+        message="",
+        error="",
+        status="failed",
+        info="",
+        status_code=200,
+        **args,
+    ):
+        args.setdefault("data", None)
+        dictx = jsonify(
+            dictionary,
+            args,
+            message=message,
+            status_code=status_code,
+            error=error,
+            status=status,
+            info=info,
+            ___ignore_empty__=True,
+        )
+
+        self.__dict__.update(dictx)
+
+    @property
+    def json(self):
+        return self.__dict__
+
+    def __str__(self):
+        import json
+
+        return json.dumps(self.__dict__, indent=2)
+
+    def __repr__(self):
+        return json.dumps(self.__dict__, indent=2)
+
+    @staticmethod
+    def _N_SERVER_ERROR():
+        return returnjson(
+            message="Server Caught Exception",
+            status_code=500,
+            error="InternalServerError",
+        )
+
+    @staticmethod
+    def _N_STATUS_OK():
+        return returnjson(
+            message=STATUS._MESSAGES.get(STATUS.OK), status_code=STATUS.OK, status="ok"
+        )
+
+    @staticmethod
+    def _N_JSON_DECODE_ERROR():
+        return returnjson(
+            message="Please provide a valid json format.",
+            status_code=STATUS.BAD_REQUEST,
+            error="JSONDecodeError",
+        )
+
+
+# class comjson:
+#     def __init__(
+#         self,
+#         message="",
+#         error="",
+#         status="failed",
+#         info="",
+#         object=None,
+#         data={},
+#         **args
+#     ):
+#         self.__dict__.update(
+#             jsonify(
+#                 error=error,
+#                 message=message,
+#                 info=info,
+#                 data=data,
+#                 object=object,
+#                 **args,
+#                 status=status,
+#             )
+#         )
+
+import json
+
+
+class comjson:
+    def __init__(
+        self,
+        dictionary=None,
+        message="",
+        error="",
+        status="failed",
+        info="",
+        object=None,
+        data=None,
+        **args,
+    ):
+        if dictionary is None:
+            dictionary = {}
+
+        # Merge extra keyword arguments into dictionary if provided
+        combined_dict = {**dictionary, **args}
+
+        # Filter empty strings, Nones, and empty collections
+        dictx = jsonify(
+            combined_dict,
+            message=message,
+            error=error,
+            status=status,
+            info=info,
+            object=object,
+            data=data,
+            ___ignore_empty__=True,
+        )
+
+        self.__dict__.update(dictx)
+
+    @property
+    def json(self):
+        return self.__dict__
+
+    def __str__(self):
+        return json.dumps(self.__dict__, indent=2)
+
+    def __repr__(self):
+        return json.dumps(self.__dict__, indent=2)
+
+
+if __name__ == "__main__":
+
+    def printf(*args, **kwargs):
+        import json
+
+        for i in args:
+            if isinstance(i, tuple):
+                kwargs.setdefault("args", {})
+                kwargs["args"].update(args)
+        finaldict = (
+            kwargs.update(args)
+            if isinstance(args, dict)
+            else kwargs.setdefault("args", args)
+        )
+        print(type(args))
+        print(json.dumps(kwargs, indent=2))
+
+    def printf(*args, **kwargs):
+        print(*args, **kwargs)
+
+    print(jsonify(returnjson().json, message="test", **returnjson().json))
+    print(returnjson(obj="Hello world string").json)
+    print(comjson(neekenduuku="Chaduvuko first").json)

rj_core-0.1.1/rj_core/modules.py

@@ -0,0 +1,21 @@
+class UrlGenerator:
+    @staticmethod
+    def __init__ (**kwargs):
+        host  = kwargs.get("hostname")
+        port = kwargs.get("port")
+        path = kwargs.get("path","")
+        return f"http://{host}:{port}/{path}"
+    
+
+class jsonify:
+    @staticmethod
+    def __init__(**kwargs):
+        return kwargs
+
+    def returnjson (dictionary = {} , message="", error= "", status="failed", info="", **args):
+        dictionary.setdefault("message", message)
+        dictionary.setdefault("status",status)
+        dictionary.setdefault("info", info)
+        dictionary.update(args)
+
+        return dictionary

rj_core-0.1.1/rj_core/save_data.py

@@ -0,0 +1,14 @@
+import json
+from pathlib import Path
+
+def save_to_config(data):
+    # Create a hidden folder in the user's home directory
+    config_dir = Path.home() / ".rj_data"
+    config_dir.mkdir(exist_ok=True)
+    
+    file_path = config_dir / "settings.json"
+    
+    with open(file_path, "w") as f:
+        json.dump(data, f, indent=4)
+    
+    return str(file_path)

rj_core-0.1.1/rj_core/validators.py

@@ -0,0 +1,270 @@
+import re
+
+# from django.core.validators import validate_email as django_validate_email
+# from django.core.validators import RegexValidator
+# from django.core.exceptions import ValidationError
+import os
+
+from .exeptions import InvalidCountryCodeException
+from .exeptions import InvalidPhoneNumberException, InvalidEmailException
+from rj import settings
+
+###############################################
+# own validators. protect this from ai agents..
+# class UsernameValidator:
+#     def __init__ (self, username=None, phone_no=None,email=None,**kwargs):
+#         self.username = username or kwargs.get("username")
+#         self.email = email or kwargs.get("email")
+#         self.phone_no = phone_no or kwargs.get("phone_no")
+#         return self.validate(username)
+#     def __str__(self):
+#         return self.username
+#     def __repr__(self):
+#         return self.email
+#     @staticmethod
+#     def validate(username):
+#         if username is None or len(username) <6:
+#             raise BaseException("Username should be greater than 6 characters.")
+#         else :
+#             temp = UsernameValidator(username)
+#             if temp:
+#                 return temp.username
+#             else :
+#                 class UsernameInvalidException(Exception):
+#                     message = "Please match the request username format."
+#                     def __init__(self,message=None, *args):
+#                         self.message = message if message is not None else self.message
+#                         super().__init__(self.message,*args)
+#                 raise UsernameInvalidException
+# @staticmethod
+# def validate_username(username):
+#     return Validators.validate(username)
+# def valid_username(self):
+#     try:
+#         valid_username = self.validate_
+username_validation_pattern = ""
+from rj.settings import DEFAULT_SETTINGS_DICT
+
+username_validation_pattern = DEFAULT_SETTINGS_DICT.get("regex").get("username_regex")
+
+
+class UsernameValidator:
+    def __init__(self, username=None):
+        self.username = username
+
+    def validate(username):
+        import re
+
+        # username = self.username
+        # username_validation_pattern = r'^(?=.*[a-z])[a-z0-9_.]+$'
+        IsMatched = re.compile(username_validation_pattern)
+        if IsMatched.match(username):
+            return username
+        else:
+            raise Exception("Username is not valid.")
+
+    @property
+    def is_valid(self):
+        import re
+
+        username = self.username
+        username_validation_pattern = r"^(?=.*[a-z])[a-z0-9_.]+$"
+        IsMatched = re.compile(username_validation_pattern)
+        if IsMatched.match(username):
+            return True
+        else:
+            return False
+
+
+class Validators:
+    def __init__(self, username=None, phone_no=None, email=None, **kwargs):
+        self.username = username or kwargs.get("username")
+        self.email = email or kwargs.get("email")
+        self.phone_no = phone_no or kwargs.get("phone_no")
+        return None
+
+    @staticmethod
+    def validate_username(username):
+        import re
+
+        pattern = r"^[a-z0-9A-Z]+$"
+        username_regex = re.compile(pattern)
+        return username if username_regex.fullmatch(username) else None
+
+    @staticmethod
+    def validate_username_list(*args):
+        import re
+
+        pattern = r"^[a-z0-9A-Z]+$"
+        username_regex = re.compile(pattern)
+        if len(*args) < 1:
+            raise ValueError("Atleast one argument required. %s" % (args))
+        elif len(args) == 1 and isinstance(args, tuple):
+            if username_regex.fullmatch(args[0]):
+                return str(args[0])
+            else:
+                return None
+        elif len(args) > 1 and (isinstance(args, tuple) or isinstance(args, list)):
+
+            returnargs = []
+            for i in args:
+                if username_regex.fullmatch(i):
+                    returnargs.append(i)
+                else:
+                    print("Invalid username.%s" % (i))
+
+            return returnargs
+
+    @property
+    def valid_username(self):
+        temp = UsernameValidator(self.username)
+        return temp.is_valid
+
+    @staticmethod
+    def validate_phone(phone):
+        if isinstance(phone, dict):
+            if phone.get("country_code", None) and phone.get("phone_no"):
+                phone_no = phone.get("phone_no")
+                country_code = phone.get("country_code")
+                if not country_code.startswith("+"):
+                    country_code = f"+{str(country_code)}"
+
+            else:
+
+                class JsonDecodeError(Exception):
+                    def __init__(
+                        self,
+                        message="Json pattern not matched. { phone_no : value, country_code : value ",
+                    ):
+                        self.message = message
+                        super().__init__(message)
+
+                raise JsonDecodeError()
+        else:
+
+            phone = str(phone)
+            phone = phone.replace(" ", "")
+            if not phone == "" and not phone is None:
+                phone_no = phone[-10:]
+                country_code = phone[:-10]
+        if country_code == "" or country_code is None:
+            print("Warning : Default country code : IN +91")
+            country_code = "+91"
+        for i in str(phone_no):
+            # print("Forloop executed.")
+
+            try:
+                int(i)
+            except ValueError:
+                raise InvalidPhoneNumberException(
+                    "Phone Number should exactly contain digits. (value: %s , phone : %s)"
+                    % (i, phone)
+                )
+            except Exception as e:
+                raise Exception
+
+            if country_code.startswith("+") and len(str(country_code)) < 2:
+                raise InvalidCountryCodeException
+            elif not country_code.startswith("+") and len(phone) > 10:
+                print(phone, "  :  ", len(phone))
+                raise InvalidPhoneNumberException(
+                    "Phone number shouldnot Exceed 10 digits with countrycode mentioned as +ccph"
+                )
+
+        if not phone_no.__len__() == 10 or phone_no is None and phone_no == "":
+            raise InvalidPhoneNumberException(
+                "Phone No should consists of exactly 10 digits. (input : %s )"
+                % (phone_no)
+            )
+        elif phone_no.__len__() == 10:
+            return f"{country_code}{phone_no}".strip()
+
+    @property
+    def valid_phone_no(self):
+        temp = None
+        try:
+            temp = Validators.validate_phone(self.phone_no)
+            return True if temp is not None else False
+        except:
+            return False
+
+    @staticmethod
+    def validate_email(email):
+        email = str(email)
+
+        if not email == "" and not email is None and email.__len__() >= 5:
+            try:
+                userid, domain = email.split("@")
+                host, x = domain.split(".")
+                if host and x and userid:
+                    return f"{userid}@{domain}"
+                else:
+                    raise Exception("Invalud emallil")
+            except:
+                raise InvalidEmailException("Enter a valid emailformat.")
+        else:
+            raise InvalidEmailException(
+                "Empty Email Detected!!"
+                if email == "" or email is None
+                else "Email should be greater than 5 characters...!"
+            )
+
+    @property
+    def valid_email(self):
+        temp = None
+        try:
+            temp = self.validate_email(self.email)
+            return True if temp is not None else False
+        except:
+            return False
+
+    @staticmethod
+    def validate_username(username):
+        return UsernameValidator.validate(username)
+
+    @property
+    def all_valid(self):
+        return (
+            True
+            if self.valid_phone_no and self.valid_username and self.valid_email
+            else False
+        )
+
+
+class URLValidator:
+    class InvalidException(Exception):
+        def __init__(self, *args):
+            self.message = (
+                args[1] or "Invalid url. URL must start with http:// or https://"
+            )
+            super().__init__(*args)
+
+    @staticmethod
+    def validate(*args):
+        if len(args) < 1:
+            raise ValueError("Url argument is required.")
+
+        else:
+            url = URLValidator(args)
+            return url.valid_urls
+
+    def __init__(self, *args):
+        self.urls = args
+
+    @property
+    def valid_urls(self):
+        valid_url = []
+        urls = self.urls
+        for i in urls:
+            if str(i).startswith("https://") or str(i).startswith("http://"):
+
+                valid_url.append(str(i))
+
+        self.valid_url = valid_url
+        # return valid_url
+
+        return valid_url if not len(self.valid_url) > 0 else None
+
+    def validate(self, url):
+        if isinstance(self, str):
+            return

rj_core-0.1.1/rj_core.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: rj-core
+Version: 0.1.1
+Author: rahul
+Requires-Dist: bcrypt
+Requires-Dist: rj-home

rj_core-0.1.1/rj_core.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+pyproject.toml
+rj_core/__init__.py
+rj_core/cli.py
+rj_core/exeptions.py
+rj_core/helpers.py
+rj_core/modules.py
+rj_core/save_data.py
+rj_core/validators.py
+rj_core.egg-info/PKG-INFO
+rj_core.egg-info/SOURCES.txt
+rj_core.egg-info/dependency_links.txt
+rj_core.egg-info/requires.txt
+rj_core.egg-info/top_level.txt

rj_core-0.1.1/rj_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rj_core-0.1.1/rj_core.egg-info/requires.txt

@@ -0,0 +1,2 @@
+bcrypt
+rj-home

rj_core-0.1.1/rj_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+rj_core

rj_core-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+