arpakitlib 1.6.47__py3-none-any.whl → 1.7.89__py3-none-any.whl

arpakitlib/ar_file_util.py

@@ -0,0 +1,22 @@
+import os
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def raise_if_path_not_exists(path: str):
+    if not os.path.exists(path):
+        raise Exception(f"path {path} not exists")
+
+
+def clear_text_file(filepath: str):
+    if not os.path.exists(filepath):
+        return
+    with open(filepath, mode="w") as f:
+        f.write("")
+
+
+def create_text_file(filepath: str, text: str = ""):
+    if os.path.exists(filepath):
+        return
+    with open(filepath, mode="w") as f:
+        f.write(text)

arpakitlib/ar_func_util.py

@@ -0,0 +1,55 @@
+import asyncio
+import inspect
+from typing import Callable, Any
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def is_async_function(func: Callable) -> bool:
+    return asyncio.iscoroutinefunction(func)
+
+
+def is_async_object(obj: object) -> bool:
+    return asyncio.iscoroutine(obj)
+
+
+def is_sync_function(func: Callable) -> bool:
+    return inspect.isfunction(func) and not is_async_function(func)
+
+
+def raise_if_not_async_func(func: Callable):
+    if not is_async_function(func):
+        raise TypeError(f"The provided function '{func.__name__}' is not an async function")
+
+
+def raise_if_not_sync_func(func: Callable):
+    if not is_sync_function(func):
+        raise TypeError(f"The provided function '{func.__name__}' is not a sync function")
+
+
+def raise_if_async_func(func: Callable):
+    if is_async_function(func):
+        raise TypeError(f"The provided function '{func.__name__}' should not be async")
+
+
+def raise_if_sync_func(func: Callable):
+    if is_sync_function(func):
+        raise TypeError(f"The provided function '{func.__name__}' should not be sync")
+
+
+def __example():
+    def one():
+        pass
+
+    async def two():
+        pass
+
+    print(is_sync_function(one))
+    print(is_sync_function(two))
+
+    print(is_async_function(one))
+    print(is_async_function(two))
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_http_request_util.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 from datetime import timedelta
+from typing import Any
 
 import aiohttp
 import requests
@@ -20,10 +21,13 @@ def sync_make_http_request(
         *,
         method: str = "GET",
         url: str,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
         max_tries_: int = 9,
         proxy_url_: str | None = None,
         raise_for_status_: bool = False,
         timeout_: timedelta | float = timedelta(seconds=15).total_seconds(),
+        enable_logging_: bool = False,
         **kwargs
 ) -> requests.Response:
     if isinstance(timeout_, float):
@@ -34,26 +38,37 @@ def sync_make_http_request(
 
     kwargs["method"] = method
     kwargs["url"] = url
-    if timeout_ is not None:
-        kwargs["timeout"] = timeout_.total_seconds()
+    if headers is not None:
+        kwargs["headers"] = headers
+    if params is not None:
+        kwargs["params"] = params
     if proxy_url_:
         kwargs["proxies"] = {
             "http": proxy_url_,
             "https": proxy_url_
         }
+    if timeout_ is not None:
+        kwargs["timeout"] = timeout_.total_seconds()
     if "allow_redirects" not in kwargs:
         kwargs["allow_redirects"] = True
 
+    if enable_logging_:
+        _logger.info(f"TRY HTTP {method} {url} {params}")
+
     while True:
         tries_counter += 1
-        _logger.info(f"{method} {url} {kwargs.get('params')}")
         try:
             response = requests.request(**kwargs)
             if raise_for_status_:
                 response.raise_for_status()
+            if enable_logging_:
+                _logger.info(f"GOOD TRY HTTP {method} {url} {params}")
             return response
         except BaseException as exception:
-            _logger.warning(f"{tries_counter}/{max_tries_} {method} {url} {exception}")
+            if enable_logging_:
+                _logger.warning(
+                    f"{tries_counter}/{max_tries_}. RETRY {method} {url} {params}, exception={exception}"
+                )
             if tries_counter >= max_tries_:
                 raise exception
             sync_safe_sleep(timedelta(seconds=0.1).total_seconds())
@@ -64,16 +79,23 @@ async def async_make_http_request(
         *,
         method: str = "GET",
         url: str,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
         max_tries_: int = 9,
         proxy_url_: str | None = None,
         raise_for_status_: bool = False,
         timeout_: timedelta | None = timedelta(seconds=15),
+        enable_logging_: bool = False,
         **kwargs
 ) -> aiohttp.ClientResponse:
     tries_counter = 0
 
     kwargs["method"] = method
     kwargs["url"] = url
+    if headers is not None:
+        kwargs["headers"] = headers
+    if params is not None:
+        kwargs["params"] = params
     if timeout_ is not None:
         kwargs["timeout"] = aiohttp.ClientTimeout(total=timeout_.total_seconds())
     if "allow_redirects" not in kwargs:
@@ -83,18 +105,25 @@ async def async_make_http_request(
     if proxy_url_:
         proxy_connector = ProxyConnector.from_url(proxy_url_)
 
+    if enable_logging_:
+        _logger.info(f"TRY HTTP {method} {url} {params}")
+
     while True:
         tries_counter += 1
-        _logger.info(f"{method} {url} {kwargs.get('params')}")
         try:
             async with aiohttp.ClientSession(connector=proxy_connector) as session:
                 async with session.request(**kwargs) as response:
                     if raise_for_status_:
                         response.raise_for_status()
                     await response.read()
+                    if enable_logging_:
+                        _logger.info(f"GOOD TRY HTTP {method} {url} {params}")
                     return response
         except BaseException as exception:
-            _logger.warning(f"{tries_counter}/{max_tries_} {method} {url} {exception}")
+            if enable_logging_:
+                _logger.warning(
+                    f"{tries_counter}/{max_tries_}. RETRY HTTP {method} {url} {params}, exception={exception}"
+                )
             if tries_counter >= max_tries_:
                 raise exception
             await async_safe_sleep(timedelta(seconds=0.1).total_seconds())

arpakitlib/ar_json_util.py

@@ -1,25 +1,31 @@
 # arpakit
 
 import json
-from typing import Union, Any
+from typing import Any
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def safely_transfer_to_json_obj(data: str) -> Union[dict, list]:
+def safely_transfer_str_to_json_obj(data: str) -> dict[Any, Any] | list[Any] | None:
     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)")
+def safely_transfer_obj_to_json_str(data: dict[Any, Any] | list[Any] | None) -> str:
+    if not isinstance(data, dict) and not isinstance(data, list) and data is not None:
+        raise ValueError("not isinstance(data, dict) and not isinstance(data, list) and data is not None")
     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 safely_transfer_obj_to_json_str_to_json_obj(
+        data: dict[Any, Any] | list[Any] | None
+) -> dict[Any, Any] | list[Any] | None:
+    return safely_transfer_str_to_json_obj(safely_transfer_obj_to_json_str(data))
+
+
+def safely_transfer_str_to_json_obj_to_json_str(data: str) -> str:
+    return safely_transfer_obj_to_json_str(safely_transfer_str_to_json_obj(data))
 
 
 def __example():

arpakitlib/ar_logging_util.py

@@ -8,6 +8,9 @@ _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
 def init_log_file(*, log_filepath: str):
+    directory = os.path.dirname(log_filepath)
+    if directory and not os.path.exists(directory):
+        os.makedirs(directory, exist_ok=True)
     if not os.path.exists(path=log_filepath):
         with open(file=log_filepath, mode="w") as file:
             file.write("")
@@ -30,7 +33,7 @@ def setup_normal_logging(log_filepath: Optional[str] = None):
     stream_handler = logging.StreamHandler()
     stream_handler.setLevel(logging.INFO)
     stream_formatter = logging.Formatter(
-        "%(asctime)s | %(levelname)s | %(name)s - %(message)s",
+        "%(asctime)s | %(levelname)s | %(filename)s | %(funcName)s:%(lineno)d - %(message)s",
         datefmt="%d.%m.%Y %I:%M:%S%p"
     )
     stream_handler.setFormatter(stream_formatter)
@@ -40,7 +43,7 @@ def setup_normal_logging(log_filepath: Optional[str] = None):
         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",
+            "%(asctime)s | %(levelname)s | %(filename)s | %(funcName)s:%(lineno)d - %(message)s",
             datefmt="%d.%m.%Y %I:%M:%S%p"
         )
         file_handler.setFormatter(file_formatter)

arpakitlib/ar_need_type_util.py

@@ -19,7 +19,10 @@ class NeedTypes(Enumeration):
     json = "json"
 
 
-def parse_need_type(value: Any, need_type: str) -> Any:
+def parse_need_type(value: Any, need_type: str, allow_none: bool = False) -> Any:
+    if allow_none and value is None:
+        return None
+
     NeedTypes.parse_and_validate_values(need_type)
 
     if need_type == NeedTypes.str_:
@@ -53,7 +56,14 @@ def parse_need_type(value: Any, need_type: str) -> Any:
 
 
 def __example():
-    pass
+    print(parse_need_type(value=123, need_type="int"))
+    print(parse_need_type(value="True", need_type="bool"))
+    print(parse_need_type(value=123.456, need_type="float"))
+    print(parse_need_type(value='[1, 2, 3]', need_type="list_of_int"))
+    print(parse_need_type(value='["a", "b", "c"]', need_type="list_of_str"))
+    print(parse_need_type(value='[1.1, 2.2, 3.3]', need_type="list_of_float"))
+    print(parse_need_type(value='{"key": "value"}', need_type="json"))
+    print(parse_need_type(value="hello world", need_type="str"))
 
 
 if __name__ == '__main__':

arpakitlib/{ar_openai_util.py → ar_openai_api_client_util.py}

@@ -49,11 +49,25 @@ class OpenAIAPIClient:
 
 
 def __example():
-    pass
+    open_ai = OpenAI(api_key="your-api-key")
+    client = OpenAIAPIClient(open_ai=open_ai)
+
+    print("Checking OpenAI API connection...")
+    if client.is_conn_good():
+        print("Connection to OpenAI API is good")
+    else:
+        print("Failed to connect to OpenAI API")
 
 
 async def __async_example():
-    pass
+    async_open_ai = AsyncOpenAI(api_key="your-api-key")
+    client = OpenAIAPIClient(async_open_ai=async_open_ai)
+
+    print("Checking OpenAI API async connection...")
+    if await client.async_is_conn_good():
+        print("Async connection to OpenAI API is good")
+    else:
+        print("Failed to async connect to OpenAI API")
 
 
 if __name__ == '__main__':