arpakitlib 1.4.0__py3-none-any.whl

arpakitlib/ar_json_db.py

@@ -0,0 +1,231 @@
+import json
+import logging
+import os
+import shutil
+from typing import Any, Optional, Self
+
+from arpakitlib.ar_type_util import raise_for_type
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class JSONDbFile:
+
+    def __init__(self, *, filepath: str, use_memory: bool = True, beautify_json: bool = True):
+        self._logger = logging.getLogger(self.__class__.__name__)
+        raise_for_type(filepath, str)
+        filepath = os.path.abspath(filepath.strip())
+        if not filepath:
+            raise ValueError("not filepath")
+
+        self.filepath = filepath
+        self.use_memory = use_memory
+        self.beautify_json = beautify_json
+        self.saved_json_data: Optional[dict[str, Any]] = None
+
+    def __str__(self) -> str:
+        return f"JSONDbFile ({self.filepath}) ({self.count_records()})"
+
+    def __repr__(self) -> str:
+        return f"JSONDbFile ({self.filepath}) ({self.count_records()})"
+
+    def __len__(self) -> int:
+        return self.count_records()
+
+    @property
+    def filename(self) -> str:
+        return os.path.split(self.filepath)[1]
+
+    @property
+    def dirpath(self) -> str:
+        return os.path.split(self.filepath)[0]
+
+    def write_json_data(self, json_data: dict[str, Any]):
+        raise_for_type(json_data, dict)
+
+        if self.dirpath and not os.path.exists(self.dirpath):
+            os.makedirs(self.dirpath, exist_ok=True)
+
+        with open(self.filepath, mode="w", encoding="utf-8") as f:
+            f.write(json.dumps(json_data, ensure_ascii=False, indent=2 if self.beautify_json else None))
+
+        if self.use_memory is True:
+            self.saved_json_data = json_data
+
+    def read_json_data(self) -> dict[str, Any]:
+        if self.use_memory is True and self.saved_json_data is not None:
+            return self.saved_json_data
+
+        if not self.check_exists():
+            self.write_json_data({})
+
+        with open(self.filepath, mode="r", encoding="utf-8") as f:
+            text_from_file = f.read()
+        json_data = json.loads(text_from_file)
+
+        if self.use_memory is True:
+            self.saved_json_data = json_data
+
+        return json_data
+
+    def init(self):
+        if not self.check_exists():
+            self.write_json_data({})
+
+    def reinit(self):
+        self.drop()
+        self.init()
+
+    def refresh_saved_json_data(self):
+        if self.use_memory is True:
+            self.saved_json_data = self.read_json_data()
+
+    def get_records(self) -> list[(str, dict[str, Any])]:
+        return [(record_id, record) for record_id, record in self.read_json_data().items()]
+
+    def get_record_ids(self) -> list[str]:
+        return [record_id for record_id in self.read_json_data().keys()]
+
+    def check_exists(self) -> bool:
+        return os.path.exists(self.filepath)
+
+    def check_record_id_exists(self, record_id: str) -> bool:
+        return self.get_record(record_id=record_id) is not None
+
+    def count_records(self) -> int:
+        return len(self.read_json_data().keys())
+
+    def get_record(self, record_id: str) -> Optional[dict[str, Any]]:
+        raise_for_type(record_id, str)
+        json_data = self.read_json_data()
+        return json_data[record_id] if record_id in json_data.keys() else None
+
+    def generate_record_id(self) -> str:
+        record_ids = set(self.get_record_ids())
+        res = len(record_ids)
+        while str(res) in record_ids:
+            res += 1
+        return str(res)
+
+    def create_record(
+            self,
+            record: dict[str, Any],
+            record_id: Optional[str] = None,
+    ) -> (str, dict[str, Any]):
+        if record_id is None:
+            record_id = self.generate_record_id()
+        raise_for_type(record_id, str)
+
+        json_data = self.read_json_data()
+        if record_id in json_data.keys():
+            raise KeyError(f"record with record_id={record_id} already exists")
+
+        json_data[record_id] = record
+        self.write_json_data(json_data=json_data)
+
+        return record_id, record
+
+    def update_record(
+            self,
+            *,
+            record_id: str,
+            record: dict[str, Any]
+    ) -> dict[str, Any]:
+        raise_for_type(record_id, str)
+        raise_for_type(record, dict)
+
+        json_data = self.read_json_data()
+        if record_id not in json_data.keys():
+            raise ValueError(f"record with record_id='{record_id}' not exists")
+
+        json_data[record_id] = record
+        self.write_json_data(json_data)
+
+        return record
+
+    def rm_record(self, record_id: str):
+        json_data = self.read_json_data()
+        if record_id not in json_data.keys():
+            return
+        del json_data[record_id]
+        self.write_json_data(json_data)
+
+    def rm_records(self, record_ids: list[str]):
+        json_data = self.read_json_data()
+        for record_id, record in json_data.items():
+            if record_id not in record_ids:
+                continue
+            del json_data[record_id]
+        self.write_json_data(json_data)
+
+    def rm_all_records(self):
+        self.write_json_data({})
+
+    def copy(self, to_filepath: str):
+        self.init()
+        shutil.copy(self.filepath, to_filepath)
+        return JSONDbFile(filepath=to_filepath, use_memory=self.use_memory, beautify_json=self.beautify_json)
+
+    def drop(self):
+        if self.check_exists():
+            os.remove(self.filepath)
+
+
+class JSONDb:
+
+    def __init__(self, json_db_files: Optional[list[JSONDbFile]] = None):
+        self._logger = logging.getLogger(self.__class__.__name__)
+        if json_db_files is None:
+            json_db_files = []
+        self.json_db_files: list[JSONDbFile] = json_db_files
+
+    def __str__(self) -> str:
+        return f"JSONDbFiles ({len(self.json_db_files)})"
+
+    def __repr__(self) -> str:
+        return f"JSONDbFiles ({len(self.json_db_files)})"
+
+    def __len__(self) -> int:
+        return len(self.json_db_files)
+
+    def create_json_db_file(self, filepath: str, use_memory: bool = False, beautify_json: bool = False) -> JSONDbFile:
+        json_db_file = JSONDbFile(filepath=filepath, use_memory=use_memory, beautify_json=beautify_json)
+        self.json_db_files.append(json_db_file)
+        return json_db_file
+
+    def add_json_db_file(self, json_db_file: JSONDbFile):
+        self.json_db_files.append(json_db_file)
+
+    def init(self):
+        for file in self.json_db_files:
+            file.init()
+
+    def reinit(self):
+        for file in self.json_db_files:
+            file.reinit()
+
+    def drop(self):
+        for file in self.json_db_files:
+            file.drop()
+
+    def rm_all_records(self):
+        for json_db_file in self.json_db_files:
+            json_db_file.rm_all_records()
+
+    def copy_files_to_dir(self, to_dirpath: str) -> Self:
+        json_db = JSONDb()
+        for json_db_file in self.json_db_files:
+            filepath = os.path.join(to_dirpath, json_db_file.filename)
+            json_db_file.copy(filepath)
+            json_db.create_json_db_file(
+                filepath=filepath, use_memory=json_db_file.use_memory, beautify_json=json_db_file.beautify_json
+            )
+        return json_db
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_json_util.py

@@ -0,0 +1,28 @@
+import json
+from typing import Union, Any
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def safely_transfer_to_json_obj(data: str) -> Union[dict, list]:
+    if not isinstance(data, str):
+        raise ValueError("not isinstance(data, str)")
+    return json.loads(data)
+
+
+def safely_transfer_to_json_str(data: Union[dict[str, Any], list[Any]]) -> str:
+    if not isinstance(data, dict) and not isinstance(data, list):
+        raise ValueError("not isinstance(data, dict) and not isinstance(data, list)")
+    return json.dumps(data, ensure_ascii=False, indent=2, default=str)
+
+
+def safely_transfer_to_json_str_to_json_obj(data: Union[dict[str, Any], list[Any]]) -> Union[dict, list]:
+    return safely_transfer_to_json_obj(safely_transfer_to_json_str(data))
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_jwt_util.py

@@ -0,0 +1,38 @@
+from typing import Any, Optional
+
+import jwt
+from jwt import PyJWTError
+
+from arpakitlib.ar_type_util import raise_for_type
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def encode_jwt_token(
+        *,
+        jwt_payload: dict[str, Any],
+        jwt_secret: str
+) -> str:
+    raise_for_type(jwt_secret, str)
+    return jwt.encode(jwt_payload, jwt_secret, algorithm="HS256")
+
+
+def decode_jwt_token(
+        *,
+        jwt_token: str,
+        jwt_secret: str
+) -> Optional[dict[str, Any]]:
+    raise_for_type(jwt_token, str)
+    raise_for_type(jwt_secret, str)
+    try:
+        return jwt.decode(jwt_token, jwt_secret, algorithms=["HS256"])
+    except PyJWTError:
+        return None
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_list_of_dicts_to_xlsx.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+import pandas
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def list_of_dicts_to_xlsx(
+        list_of_dicts: list[dict[str, Any]],
+        out_filepath: str = "out.xlsx",
+        sheet_name: str = "Sheet 1"
+) -> str:
+    data_frame = pandas.DataFrame(list_of_dicts)
+
+    writer = pandas.ExcelWriter(out_filepath, engine="xlsxwriter")
+    data_frame.to_excel(writer, index=False, sheet_name=sheet_name)
+
+    for i, col in enumerate(data_frame.columns):
+        width = max(data_frame[col].apply(lambda x: len(str(x))).max(), len(col))
+        writer.sheets[sheet_name].set_column(i, i, width * 1.1)
+
+    writer._save()
+
+    return out_filepath
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_list_util.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def iter_group_list(list_: list[Any], n: int):
+    part = []
+    for v in list_:
+        if len(part) < n:
+            part.append(v)
+        else:
+            yield part.copy()
+            part = [v]
+    yield part
+
+
+def group_list(list_: list[Any], n: int):
+    return list(iter_group_list(list_=list_, n=n))
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_logging_util.py

@@ -0,0 +1,45 @@
+import logging
+import os
+from typing import Optional
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def init_log_file(*, log_filepath: str):
+    if not os.path.exists(path=log_filepath):
+        with open(file=log_filepath, mode="w") as file:
+            file.write("")
+
+
+def setup_normal_logging(log_filepath: Optional[str] = None):
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    stream_formatter = logging.Formatter(
+        "%(asctime)s | %(levelname)s | %(name)s - %(message)s",
+        datefmt="%d.%m.%Y %I:%M:%S%p"
+    )
+    stream_handler.setFormatter(stream_formatter)
+    logger.addHandler(stream_handler)
+
+    if log_filepath:
+        file_handler = logging.FileHandler(log_filepath)
+        file_handler.setLevel(logging.WARNING)
+        file_formatter = logging.Formatter(
+            "%(asctime)s | %(levelname)s | %(name)s | %(filename)s:%(lineno)d - %(message)s",
+            datefmt="%d.%m.%Y %I:%M:%S%p"
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+
+    logger.info("normal logging was setup")
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_mongodb_util.py

@@ -0,0 +1,143 @@
+import asyncio
+import logging
+from abc import abstractmethod
+from random import randint
+from typing import Optional
+from urllib.parse import quote
+
+from pymongo import MongoClient
+from pymongo.collection import Collection
+from pymongo.database import Database
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def generate_mongo_uri(
+        *,
+        mongo_user: Optional[str] = None,
+        mongo_password: Optional[str] = None,
+        mongo_hostname: str = "localhost",
+        mongo_port: int = 27017,
+        mongo_auth_db: Optional[str] = None
+) -> str:
+    res: str = f'mongodb://'
+    if mongo_user:
+        res += f"{mongo_user}"
+        if mongo_password:
+            res += f":{quote(mongo_password)}"
+        res += "@"
+    res += f"{mongo_hostname}:{mongo_port}"
+    if mongo_auth_db is not None:
+        res += f"/?authSource={mongo_auth_db}"
+
+    return res
+
+
+class EasyMongoDb:
+    def __init__(
+            self,
+            *,
+            db_name: str,
+            username: str | None = None,
+            password: str | None = None,
+            hostname: str = "127.0.0.1",
+            port: int = 27017,
+            auth_source: str | None = None,
+    ):
+        self._logger = logging.getLogger(self.__class__.__name__)
+        self.hostname = hostname
+        self.username = username
+        self.password = password
+        self.auth_source = auth_source
+        self.port = port
+        self.db_name = db_name
+        self.used_collections: list[Collection] = []
+
+    def init(self):
+        self.ensure_indexes()
+
+    def reinit(self):
+        self.drop_all_collections()
+        self.init()
+
+    def get_pymongo_client(self) -> MongoClient:
+        kwargs = {
+            "host": self.hostname,
+            "port": self.port,
+            "tz_aware": True
+        }
+        if self.username is not None:
+            kwargs["username"] = self.username
+        if self.password is not None:
+            kwargs["password"] = self.password
+        if self.auth_source is not None:
+            kwargs["authSource"] = self.auth_source
+        kwargs["timeoutMS"] = 5000
+        kwargs["connectTimeoutMS"] = 5000
+        kwargs["socketTimeoutMS"] = 5000
+        kwargs["serverSelectionTimeoutMS"] = 5000
+        return MongoClient(**kwargs)
+
+    def check_conn(self):
+        self.get_pymongo_client().server_info()
+
+    def is_db_conn_good(self) -> bool:
+        try:
+            self.get_pymongo_client().server_info()
+        except Exception as e:
+            self._logger.error(e)
+            return False
+        return True
+
+    def get_pymongo_db(self) -> Database:
+        return self.get_pymongo_client().get_database(self.db_name)
+
+    def drop_all_collections(self):
+        for collection in self.get_pymongo_db().list_collections():
+            self.get_pymongo_db().get_collection(collection["name"]).drop()
+
+    def drop_used_collections(self):
+        for collection in self.used_collections:
+            collection.drop()
+
+    def generate_collection_int_id(self, collection: Collection) -> int:
+        existing_ids = set(
+            doc["id"] for doc in collection.find({}, {"id": True}) if "id" in doc.keys()
+        )
+        if existing_ids:
+            res = max(existing_ids) + 1
+        else:
+            res = 1
+        while res in existing_ids:
+            res += 1
+        return res
+
+    def generate_collection_rand_int_id(self, collection: Collection, max_rand_int: int = 30) -> int:
+        existing_ids = set(
+            doc["id"] for doc in collection.find({}, {"id": True}) if "id" in doc.keys()
+        )
+
+        id_ = self.generate_collection_int_id(collection=collection)
+        res = id_ + randint(1, max_rand_int)
+        while res in existing_ids:
+            id_ += 1
+            res = id_ + randint(1, max_rand_int)
+
+        return res
+
+    @abstractmethod
+    def ensure_indexes(self):
+        raise NotImplemented()
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/ar_need_type_util.py

@@ -0,0 +1,58 @@
+import json
+from typing import Any
+
+from arpakitlib.ar_enumeration import EasyEnumeration
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class NeedTypes(EasyEnumeration):
+    str_ = "str"
+    int_ = "int"
+    bool_ = "bool"
+    float_ = "float"
+    list_of_int = "list_of_int"
+    list_of_str = "list_of_str"
+    list_of_float = "list_of_float"
+    json = "json"
+
+
+def parse_need_type(value: Any, need_type: str) -> Any:
+    NeedTypes.parse_and_validate_values(need_type)
+
+    if need_type == NeedTypes.str_:
+        res = value
+    elif need_type == NeedTypes.int_:
+        res = int(value)
+    elif need_type == NeedTypes.bool_:
+        if value.lower() in ["true", "1"]:
+            res = True
+        elif value.lower() in ["false", "0"]:
+            res = False
+        else:
+            raise ValueError(f"value {value} is not bool type")
+    elif need_type == NeedTypes.float_:
+        res = float(value)
+    elif need_type == NeedTypes.list_of_int:
+        res = value.removeprefix("[").removesuffix("]")
+        res = [int(num.strip()) for num in res.split(",")]
+    elif need_type == NeedTypes.list_of_str:
+        res = value.removeprefix("[").removesuffix("]")
+        res = [num.strip() for num in res.split(",")]
+    elif need_type == NeedTypes.list_of_float:
+        res = value.removeprefix("[").removesuffix("]")
+        res = [float(num.strip()) for num in res.split(",")]
+    elif need_type == NeedTypes.json:
+        res = json.loads(value)
+    else:
+        raise ValueError(f"bad need_type {need_type}")
+
+    return res
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_openai_util.py

@@ -0,0 +1,59 @@
+import asyncio
+import logging
+from typing import Optional
+
+from openai import OpenAI, AsyncOpenAI
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+"""
+https://platform.openai.com/docs/
+"""
+
+
+class EasyOpenAI:
+    def __init__(
+            self,
+            *,
+            open_ai: Optional[OpenAI] = None,
+            async_open_ai: Optional[AsyncOpenAI] = None
+    ):
+        self._logger = logging.getLogger(self.__class__.__name__)
+
+        self.open_ai = open_ai
+        self.async_open_ai = async_open_ai
+
+    def check_conn(self):
+        self.open_ai.models.list()
+
+    def is_conn_good(self) -> bool:
+        try:
+            self.check_conn()
+            return True
+        except Exception as e:
+            self._logger.error(e)
+        return False
+
+    async def async_check_conn(self):
+        await self.async_open_ai.models.list()
+
+    async def async_is_conn_good(self) -> bool:
+        try:
+            await self.async_check_conn()
+            return True
+        except Exception as e:
+            self._logger.error(e)
+        return False
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())