arpakitlib 1.8.36__py3-none-any.whl → 1.8.39__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_5/project/tg_bot/util/set_tg_bot_commands.py

@@ -8,8 +8,8 @@ from project.core.settings import get_cached_settings
 from project.core.util import setup_logging
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
-from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
-from project.tg_bot.const import ClientTgBotCommands, AdminTgBotCommands
+from project.tg_bot.blank.general import get_cached_client_tg_bot_blank
+from project.tg_bot.const import GeneralTgBotCommands, AdminTgBotCommands
 from project.tg_bot.tg_bot import get_cached_tg_bot
 
 _logger = logging.getLogger(__name__)
@@ -18,31 +18,31 @@ _logger = logging.getLogger(__name__)
 def get_client_tg_bot_commands_to_set() -> list[BotCommand]:
     res = [
         BotCommand(
-            command=ClientTgBotCommands.start,
+            command=GeneralTgBotCommands.start,
             description=return_str_if_none(
-                get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.start),
-                ClientTgBotCommands.start
+                get_cached_client_tg_bot_blank().command_to_desc().get(GeneralTgBotCommands.start),
+                GeneralTgBotCommands.start
             )
         ),
         BotCommand(
-            command=ClientTgBotCommands.about,
+            command=GeneralTgBotCommands.about,
             description=return_str_if_none(
-                get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.about),
-                ClientTgBotCommands.about
+                get_cached_client_tg_bot_blank().command_to_desc().get(GeneralTgBotCommands.about),
+                GeneralTgBotCommands.about
             )
         ),
         BotCommand(
-            command=ClientTgBotCommands.support,
+            command=GeneralTgBotCommands.support,
             description=return_str_if_none(
-                get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.support),
-                ClientTgBotCommands.support
+                get_cached_client_tg_bot_blank().command_to_desc().get(GeneralTgBotCommands.support),
+                GeneralTgBotCommands.support
             )
         ),
         BotCommand(
-            command=ClientTgBotCommands.author,
+            command=GeneralTgBotCommands.author,
             description=return_str_if_none(
-                get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.author),
-                ClientTgBotCommands.author
+                get_cached_client_tg_bot_blank().command_to_desc().get(GeneralTgBotCommands.author),
+                GeneralTgBotCommands.author
             )
         )
 

arpakitlib/ar_enumeration_util.py

@@ -48,14 +48,14 @@ class Enumeration:
 
             if isinstance(value, str) or isinstance(value, int):
                 if validate is True and value not in cls.values_set():
-                    raise ValueError(f"validate is True and {value} not in {cls.values_set()}")
+                    raise ValueError(f"{value} not in {cls.values_set()}")
                 res.append(value)
 
             elif isinstance(value, Iterable):
                 for value_ in value:
                     if isinstance(value_, str) or isinstance(value_, int):
                         if validate is True and value_ not in cls.values_set():
-                            raise ValueError(f"validate is True and {value_} not in {cls.values_set()}")
+                            raise ValueError(f"{value_} not in {cls.values_set()}")
                         res.append(value_)
                     else:
                         raise TypeError(f"bad type, value={value}, type={type(value)}")

arpakitlib/ar_sqlalchemy_util.py

@@ -73,7 +73,10 @@ class BaseDBM(DeclarativeBase):
             *,
             include_sd_properties: bool = True,
             exclude_columns: set[str] | None = None,
-            exclude_sd_properties: set[str] | None = None
+            only_columns: list[str] | None = None,
+            exclude_sd_properties: set[str] | None = None,
+            only_sd_properties: list[str] | None = None,
+            only_columns_and_sd_properties: list[str] | None = None
     ) -> dict[str, Any]:
         if exclude_columns is None:
             exclude_columns = set()
@@ -84,6 +87,10 @@ class BaseDBM(DeclarativeBase):
 
         # Обрабатываем только колонки текущей модели
         for c in inspect(self).mapper.column_attrs:
+            if only_columns_and_sd_properties is not None and c.key not in only_columns_and_sd_properties:
+                continue  # Пропускаем колонку, если она не в only_columns_and_sd_properties
+            if only_columns is not None and c.key not in only_columns:
+                continue  # Пропускаем колонку, если она не в only_columns
             if c.key in exclude_columns:
                 continue  # Пропускаем колонку, если она в exclude_columns
 
@@ -93,23 +100,32 @@ class BaseDBM(DeclarativeBase):
         # Обработка свойств с префиксом "sdp_"
         if include_sd_properties:
             for attr_name in dir(self):
-                if attr_name.startswith("sdp_") and isinstance(getattr(type(self), attr_name, None), property):
-
-                    sdp_property_name = attr_name.removeprefix("sdp_")
-                    if sdp_property_name in exclude_sd_properties:
-                        continue  # Пропускаем свойство, если оно в exclude_sdp_properties
-
-                    value = getattr(self, attr_name)
-                    if isinstance(value, BaseDBM):
-                        res[sdp_property_name] = value.simple_dict(include_sd_properties=include_sd_properties)
-                    elif isinstance(value, list):
-                        res[sdp_property_name] = [
-                            item.simple_dict(include_sd_properties=include_sd_properties)
-                            if isinstance(item, BaseDBM) else item
-                            for item in value
-                        ]
-                    else:
-                        res[sdp_property_name] = value
+                if not attr_name.startswith("sdp_") or not isinstance(getattr(type(self), attr_name, None), property):
+                    continue
+
+                sd_property_name = attr_name.removeprefix("sdp_")
+
+                if (
+                        only_columns_and_sd_properties is not None
+                        and sd_property_name not in only_columns_and_sd_properties
+                ):
+                    continue  # Пропускаем свойство, если оно не в only_columns_and_sd_properties
+                if only_sd_properties is not None and sd_property_name not in only_sd_properties:
+                    continue  # Пропускаем свойство, если оно не в only_sd_properties
+                if sd_property_name in exclude_sd_properties:
+                    continue  # Пропускаем свойство, если оно в exclude_sd_properties
+
+                value = getattr(self, attr_name)
+                if isinstance(value, BaseDBM):
+                    res[sd_property_name] = value.simple_dict(include_sd_properties=include_sd_properties)
+                elif isinstance(value, list):
+                    res[sd_property_name] = [
+                        item.simple_dict(include_sd_properties=include_sd_properties)
+                        if isinstance(item, BaseDBM) else item
+                        for item in value
+                    ]
+                else:
+                    res[sd_property_name] = value
 
         return res
 
@@ -117,12 +133,18 @@ class BaseDBM(DeclarativeBase):
             self,
             *,
             exclude_columns: set[str] | None = None,
-            exclude_sdp_properties: set[str] | None = None
+            only_columns: list[str] | None = None,
+            exclude_sdp_properties: set[str] | None = None,
+            only_sd_properties: list[str] | None = None,
+            only_columns_and_sd_properties: list[str] | None = None  # Новый параметр
     ) -> dict[str, Any]:
         return self.simple_dict(
             include_sd_properties=True,
             exclude_columns=exclude_columns,
-            exclude_sd_properties=exclude_sdp_properties
+            only_columns=only_columns,
+            exclude_sd_properties=exclude_sdp_properties,
+            only_sd_properties=only_sd_properties,
+            only_columns_and_sd_properties=only_columns_and_sd_properties  # Новый параметр
         )
 
     def simple_dict_json(
@@ -130,16 +152,22 @@ class BaseDBM(DeclarativeBase):
             *,
             include_sd_properties: bool = True,
             exclude_columns: set[str] | None = None,
-            exclude_sdp_properties: set[str] | None = None
+            only_columns: list[str] | None = None,
+            exclude_sd_properties: set[str] | None = None,
+            only_sd_properties: list[str] | None = None,
+            only_columns_and_sd_properties: list[str] | None = None,
+            **transfer_data_to_json_str_kwargs
     ) -> str:
         return transfer_data_to_json_str(
             data=self.simple_dict(
                 include_sd_properties=include_sd_properties,
                 exclude_columns=exclude_columns,
-                exclude_sd_properties=exclude_sdp_properties
+                only_columns=only_columns,
+                exclude_sd_properties=exclude_sd_properties,
+                only_sd_properties=only_sd_properties,
+                only_columns_and_sd_properties=only_columns_and_sd_properties
             ),
-            beautify=True,
-            fast=False
+            **transfer_data_to_json_str_kwargs
         )
 
 

arpakitlib/ar_str_util.py

@@ -98,6 +98,12 @@ def return_str_if_none(value: str | None, value_str: str) -> str:
     return value
 
 
+def strip_if_not_none(v: str | None) -> str | None:
+    if v is None:
+        return v
+    return v.strip()
+
+
 def __example():
     print("str_in:")
     print(str_in(string="hello", main_string="hello world"))

arpakitlib/ar_zabbix_api_client_util.py

@@ -3,10 +3,12 @@ import asyncio
 import logging
 import time
 from datetime import timedelta, datetime
-from typing import Any, Optional, Self
+from typing import Any, Optional, Self, Iterator
 
 from pyzabbix import ZabbixAPI
 
+from arpakitlib.ar_list_util import iter_group_list
+from arpakitlib.ar_logging_util import setup_normal_logging
 from arpakitlib.ar_type_util import raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -41,10 +43,23 @@ class ZabbixApiClient:
             pass
         else:
             raise_for_type(timeout, timedelta)
-        self.zabbix_api = ZabbixAPI(server=self.api_url, timeout=timeout.total_seconds())
+
+        self.zabbix_api = ZabbixAPI(
+            server=self.api_url,
+            timeout=timeout.total_seconds(),
+        )
+        self.zabbix_api.session.verify = False
+
+        self.is_logged_in = False
 
     def login(self) -> Self:
         self.zabbix_api.login(user=self.api_user, password=self.api_password)
+        self.is_logged_in = True
+        return self
+
+    def login_if_not_logged_in(self):
+        if not self.is_logged_in:
+            self.login()
         return self
 
     def is_login_good(self) -> bool:
@@ -57,6 +72,7 @@ class ZabbixApiClient:
 
     def get_host_ids(self) -> list[str]:
         kwargs = {"output": ["hostid"]}
+        self.login_if_not_logged_in()
         host_ids = self.zabbix_api.host.get(**kwargs)
         kwargs["sortfield"] = "hostid"
         kwargs["sortorder"] = "DESC"
@@ -75,10 +91,23 @@ class ZabbixApiClient:
         kwargs["sortfield"] = "hostid"
         kwargs["sortorder"] = "DESC"
 
+        self.login_if_not_logged_in()
         hosts = self.zabbix_api.host.get(**kwargs)
 
         return hosts
 
+    def iter_all_hosts(self) -> Iterator[list[dict[str, Any]]]:
+        host_ids = self.login_if_not_logged_in().get_host_ids()
+        for zabbix_api_host_ids in iter_group_list(list_=host_ids, n=100):
+            hosts = self.get_hosts(host_ids=zabbix_api_host_ids)
+            yield hosts
+
+    def get_all_hosts(self) -> list[dict[str, Any]]:
+        res = []
+        for hosts in self.iter_all_hosts():
+            res += hosts
+        return res
+
     def get_item_ids(
             self,
             *,
@@ -106,6 +135,7 @@ class ZabbixApiClient:
             kwargs["limit"] = limit
         kwargs["sortfield"] = "itemid"
         kwargs["sortorder"] = "DESC"
+        self.login_if_not_logged_in()
         itemid_ids = self.zabbix_api.item.get(**kwargs)
         res = [d["itemid"] for d in itemid_ids]
         return res
@@ -143,6 +173,7 @@ class ZabbixApiClient:
             kwargs["limit"] = limit
         kwargs["sortfield"] = "itemid"
         kwargs["sortorder"] = "DESC"
+        self.login_if_not_logged_in()
         res = self.zabbix_api.item.get(**kwargs)
         return res
 
@@ -178,7 +209,9 @@ class ZabbixApiClient:
                 0, 0
             )))
 
+        self.login_if_not_logged_in()
         histories: list[dict[str, Any]] = self.zabbix_api.history.get(**kwargs)
+
         for history in histories:
             if "clock" in history.keys():
                 clock_ns_as_datetime = datetime.fromtimestamp(int(history["clock"]))
@@ -196,7 +229,14 @@ ZabbixAPIClient = ZabbixApiClient
 
 
 def __example():
-    pass
+    setup_normal_logging()
+    zabbix = ZabbixAPIClient(
+        api_url=...,
+        api_user=...,
+        api_password=...
+    )
+
+    print(zabbix.is_login_good())
 
 
 async def __async_example():

{arpakitlib-1.8.36.dist-info → arpakitlib-1.8.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.8.36
+Version: 1.8.39
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company