MainShortcuts2 2.4.2__tar.gz → 2.4.4__tar.gz

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MainShortcuts2
-Version: 2.4.2
+Version: 2.4.4
 Summary: Сокращение и улучшение функций + консольные утилиты
 Home-page: https://github.com/MainPlay-TG/MainShortcuts2.py
 Author: MainPlay TG
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Project-URL: Repository, https://github.com/MainPlay-TG/MainShortcuts2.py
 Description-Content-Type: text/markdown
 
-# MainShortcuts
+# MainShortcuts2
 ## Описание
 Сокращение и улучшение функций
 ## Установка
@@ -29,7 +29,6 @@ python3 -m pip install -U MainShortcuts2
 Импорт модуля
 ```python
 from MainShortcuts2 import ms
-exec(ms.import_code)
 ```
 Встроенная информация о модуле
 ```python

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/README.md

@@ -1,4 +1,4 @@
-# MainShortcuts
+# MainShortcuts2
 ## Описание
 Сокращение и улучшение функций
 ## Установка
@@ -10,7 +10,6 @@ python3 -m pip install -U MainShortcuts2
 Импорт модуля
 ```python
 from MainShortcuts2 import ms
-exec(ms.import_code)
 ```
 Встроенная информация о модуле
 ```python

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/pyproject.toml

@@ -1,5 +1,5 @@
 [tool.poetry]
-version = "2.4.2"
+version = "2.4.4"
 name = "MainShortcuts2"
 description = "Сокращение и улучшение функций + консольные утилиты"
 authors = [ "MainPlay TG <xbox.roman6666666666@gmail.com>",]
@@ -21,5 +21,5 @@ nginx-restart = "MainShortcuts2.__main__:nginx_restart"
 python = "^3.6"
 
 [build-system]
-requires = [ "poetry-core",]
 build-backend = "poetry.core.masonry.api"
+requires = [ "poetry-core",]

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/src/MainShortcuts2/__main__.py

@@ -11,17 +11,19 @@ def import_example():
   print("from MainShortcuts2 import ms")
 
 
-def nano_json():
+def nano_json(args: argparse.Namespace = None):
   ms.utils.check_programs("nano")
   import subprocess
-  argp = argparse.ArgumentParser("nano-json", description="форматирование JSON файлов и редактирование в GNU NANO")
-  argp.add_argument("files", nargs="+", help="пути к файлам JSON")
-  argp.add_argument("--encoding", default="utf-8", help="кодировка файлов")
-  argp.add_argument("--nano-help", action="store_true", help="показать помощь nano")
-  argp.add_argument("--no-escape", action="store_false", help="не использовать Unicode Escape")
-  argp.add_argument("-f", "--rcfile", help="использовать только этот файл для настройки nano")
-  argp.add_argument("-m", "--mode", choices=ms.json.MODES, default="p", help="режим сохранения редактирования")
-  args = argp.parse_args()
+  if args is None:
+    argp = argparse.ArgumentParser("nano-json", description="форматирование JSON файлов и редактирование в GNU NANO")
+    argp.add_argument("files", nargs="+", help="пути к файлам JSON")
+    argp.add_argument("--nano-help", action="store_true", help="показать помощь nano")
+    argp.add_argument("-e", "--encoding", default="utf-8", help="кодировка файлов")
+    argp.add_argument("-f", "--rcfile", help="использовать только этот файл для настройки nano")
+    argp.add_argument("-m", "--mode", choices=ms.json.MODES, default="p", help="режим сохранения редактирования")
+    argp.add_argument("-s", "--sort", action="store_true", help="сортировать ключи словаря")
+    argp.add_argument("-u", "--no-escape", action="store_false", help="не использовать Unicode Escape")
+    args = argp.parse_args()
   if args.nano_help:
     return subprocess.call(["nano", "--help"])
   nano_args = ["nano"]
@@ -78,20 +80,22 @@ def nginx_restart():
   sys.exit(subprocess.call(["systemctl", "restart", "nginx"]))
 
 
-def hash_gen():
+def hash_gen(args: argparse.Namespace = None):
   import os
   import hashlib
-  argp = argparse.ArgumentParser("ms2-hash-gen", description="создание контрольной суммы для файла")
-  argp.add_argument("files", nargs="+", help="пути к файлам")
-  argp.add_argument("-b", "--bar", action="store_true", help="показывать прогрессбар (нужен модуль progressbar2)")
-  argp.add_argument("-t", "--type", choices=HASH_TYPES, default="sha512", help="тип контрольной суммы")
-  args = argp.parse_args()
+  if args is None:
+    argp = argparse.ArgumentParser("ms2-hash-gen", description="создание контрольной суммы для файла")
+    argp.add_argument("files", nargs="+", help="пути к файлам")
+    argp.add_argument("-b", "--bar", action="store_true", help="показывать прогрессбар (нужен модуль progressbar2)")
+    argp.add_argument("-t", "--type", choices=HASH_TYPES, default="sha512", help="тип контрольной суммы")
+    args = argp.parse_args()
   if args.bar:
     import progressbar
     pbar_w = [
         progressbar.Percentage(),
         progressbar.GranularBar(left="(", right=")"),
         progressbar.FileTransferSpeed(),
+        " ",
         progressbar.ETA(format="%(eta)8s", format_finished="%(elapsed)8s", format_na="     N/A", format_not_started="--:--:--", format_zero="00:00:00"),
     ]
   data = {}
@@ -119,30 +123,35 @@ def hash_gen():
           c += len(chunk)
           pbar.update(c)
     if args.bar:
-      pbar.finish(dirty=True)
+      pbar.finish()
     data["hash"]["hex"] = hash.hexdigest()
     ms.json.write(file + HASH_SUFFIX, data)
 
 
-def hash_check():
+def hash_check(args: argparse.Namespace = None):
   import hashlib
   import os
   import shlex
-  argp = argparse.ArgumentParser("ms2-hash-check", description="проверка размера и контрольной суммы файла")
-  argp.add_argument("-b", "--bar", action="store_true", help="показывать прогрессбар (нужен модуль progressbar2)")
-  argp.add_argument("files", nargs="+", help="пути к файлам")
-  args = argp.parse_args()
+  if args is None:
+    argp = argparse.ArgumentParser("ms2-hash-check", description="проверка размера и контрольной суммы файла")
+    argp.add_argument("-b", "--bar", action="store_true", help="показывать прогрессбар (нужен модуль progressbar2)")
+    argp.add_argument("files", nargs="+", help="пути к файлам")
+    args = argp.parse_args()
   if args.bar:
     import progressbar
     pbar_w = [
         progressbar.Percentage(),
         progressbar.GranularBar(left="(", right=")"),
         progressbar.FileTransferSpeed(),
+        " ",
         progressbar.ETA(format="%(eta)8s", format_finished="%(elapsed)8s", format_na="     N/A", format_not_started="--:--:--", format_zero="00:00:00"),
     ]
+  completed = []
   for file in args.files:
     if file.lower().endswith(HASH_SUFFIX.lower()):
       file = file[:0 - len(HASH_SUFFIX)]
+    if file in completed:
+      continue
     if not os.path.exists(file + HASH_SUFFIX):
       print("Ошибка: не найден файл " + shlex.quote(file + HASH_SUFFIX), file=sys.stderr)
       continue
@@ -165,10 +174,11 @@ def hash_check():
         hash.update(chunk)
         if args.bar:
           c += len(chunk)
-          pbar.update()
+          pbar.update(c)
     if args.bar:
-      pbar.finish(dirty=True)
+      pbar.finish()
     if data["hash"]["hex"] == hash.hexdigest():
       print("Успех: файл " + shlex.quote(file) + " не изменён")
     else:
       print("Ошибка: файл " + shlex.quote(file) + " изменён")
+    completed.append(file)

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/src/MainShortcuts2/_module_info.py

@@ -1,2 +1,2 @@
 name = "MainShortcuts2"
-version = "2.4.2"
+version = "2.4.4"

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/src/MainShortcuts2/advanced.py

@@ -319,15 +319,18 @@ class DictScriptRunner:
         self.reg_function(name)(func)
 
   def reg_class(self, name: str = None, overwrite: bool = False):
-    def deco(cls: type):
-      if name is None:  # type: ignore
-        name = cls.__module__ + "." + cls.__name__
+    if not name is None:
+      import warnings
+      warnings.warn("The argument 'name' temporarily does not work", FutureWarning)
+
+    def deco(cls: type) -> type:
+      name = cls.__module__ + "." + cls.__name__
       if callable(cls):
-        self.reg_function(name, overwrite=overwrite)(cls)  # type: ignore
+        self.reg_function(name, overwrite=overwrite)(cls)
       for k in dir(cls):
         v = getattr(cls, k)
         if callable(v):
-          self.reg_function(name + "." + k, overwrite=overwrite)  # type: ignore
+          self.reg_function(name + "." + k, overwrite=overwrite)
       return cls
     return deco
 
@@ -359,3 +362,33 @@ class DictScriptRunner:
       if "save_to" in act:
         locals[act["save_to"]] = result
     return locals
+
+
+class CodeModule:
+  """Импорт модуля из исходного кода. Могут быть баги"""
+
+  def __init__(self, source: str, globals: dict = None, locals: dict = None):
+    if globals is None:
+      globals = {}
+    if locals is None:
+      locals = {}
+    args = (source, globals, locals)
+    exec(*args)
+    self.__dict__["source"] = args[0]
+    self.__dict__["globals"] = args[1]
+    self.__dict__["globals"].update(args[2])
+
+  def __delattr__(self, k):
+    del self.__dict__["globals"][k]
+
+  def __dir__(self) -> list[str]:
+    return list(self.__dict__["globals"])
+
+  def __getattr__(self, k):
+    return self.__dict__["globals"][k]
+
+  def __hasattr__(self, k) -> bool:
+    return k in self.__dict__["globals"]
+
+  def __setattr__(self, k, v):
+    self.__dict__["globals"][k] = v

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/src/MainShortcuts2/api/base.py

@@ -2,15 +2,30 @@ import requests
 
 
 class Base:
-  def __init__(self, session: requests.Session = None):
+  def __init__(self, **kw):
+    self._init(**kw)
+
+  def _init(self, session: requests.Session = None):
     self._headers = {}
-    self._http = requests.Session() if session is None else session
+    self._http = session
     self._params = {}
-    self._url_data = {}
     self._url = "https://example.com/api/{method}"
+    self._url_data = {}
+
+  def __enter__(self):
+    return self
+
+  def __exit__(self, *a):
+    self.http.close()
+
+  def __repr__(self) -> str:
+    cls = type(self)
+    return "%s.%s(...)" % (cls.__module__, cls.__name__)
 
   @property
   def http(self) -> requests.Session:
+    if self._http is None:
+      self._http = requests.Session()
     return self._http
 
   def _request(self, http_method: str, api_method: str, *, headers: dict[str, str] = None, params: dict[str, str] = None, raise_for_status: bool = True, url_data: dict[str, str] = None, **kw):

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/src/MainShortcuts2/api/gigachat.py

@@ -9,7 +9,7 @@ class GigaChat(Base):
   def __init__(self, auth_data: str, client_id: str, *,
                cert_path: str = None,
                **kw):
-    Base.__init__(self, **kw)
+    self._init(**kw)
     self._access_token = {"expire_at": 0, "kw": None, "token": None}
     self._auth_data: str = auth_data
     self._client_id: str = client_id

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/src/MainShortcuts2/term.py

@@ -95,7 +95,7 @@ def color_test(colors: list[str] = None):
     cprint("$COLOR_RESET%s: $COLOR_%sEXAMPLE \u2591\u2592\u2593 \u2588\u2588\u2588" % (i, i))
 
 
-def _clear():
+def _clear():  # type: ignore
   """Если функция недоступна для ОС, дать ошибку"""
   raise OSError("The function is not available on %s" % sys.platform)
 

mainshortcuts2-2.4.4/src/MainShortcuts2/types.py

@@ -0,0 +1,419 @@
+"""Различные объекты и исключения"""
+from typing import Union
+
+
+class Base:
+  def __init__(self, *args, **kwargs):
+    self.args = args
+    self.kwargs = kwargs
+    self.type = type(self)
+
+
+class UserError(Exception):
+  pass
+  """Ошибка, которую допустил пользователь. Например неправильно указал входные данные"""
+
+
+class AccessDeniedError(UserError):
+  pass
+  """Ошибка доступа"""
+
+
+class Empty(Base):
+  pass
+  """Пустота (не равно `None`)"""
+
+
+class Infinity(Base):
+  pass
+  """Бесконечное число"""
+
+
+class NotAFileError(Exception):
+  pass
+  """Ошибка 'это не файл'"""
+
+
+class NotANumber(Base):
+  pass
+  """Не число"""
+
+
+class NotFound(Base):
+  pass
+  """Не найдено"""
+
+
+class NotFoundError(Exception):
+  pass
+  """Ошибка 'не найдено'"""
+
+
+class Action:
+  def __init__(self, func, *args, **kwargs):
+    self._closed = False
+    self._completed = False
+    self._error = None
+    self._launched = False
+    self._result = None
+    self.args: tuple = args
+    self.func = func
+    self.kwargs: dict = kwargs
+
+  def __enter__(self):
+    return self
+
+  def __exit__(self, a, b, c):
+    self.close()
+
+  def _check(self, launched: bool = None, completed: bool = None, closed: bool = None):
+    if not launched is None:
+      if launched:
+        if not self.launched:
+          raise RuntimeError("The action has not yet been launched")
+      else:
+        if self.launched:
+          raise RuntimeError("The action has already been launched")
+    if not completed is None:
+      if completed:
+        if not self.completed:
+          raise RuntimeError("The action has not yet been completed")
+      else:
+        if self.completed:
+          raise RuntimeError("The action has already been completed")
+    if not closed is None:
+      if closed:
+        if not self.closed:
+          raise RuntimeError("The action has not yet been closed")
+      else:
+        if self.closed:
+          raise RuntimeError("The action has already been closed")
+
+  def close(self):
+    self._closed = True
+    self._error = None
+    self._result = None
+    self.args = None
+    self.func = None
+    self.kwargs = None
+
+  @property
+  def launched(self) -> bool:
+    return self._launched
+
+  @property
+  def completed(self) -> bool:
+    return self._completed
+
+  @property
+  def exception(self) -> Union[None, Exception]:
+    self._check(launched=True, completed=True, closed=False)
+    return self._error
+
+  @property
+  def result(self):
+    self._check(launched=True, completed=True, closed=False)
+    if not self._error is None:
+      raise self._error  # type: ignore
+    return self._result
+
+  @property
+  def closed(self) -> bool:
+    return self._closed
+
+  def run(self):
+    self._check(launched=False, completed=False, closed=False)
+    self._launched = True
+    try:
+      self._result = self.func(*self.args, **self.kwargs)  # type: ignore
+    except Exception as err:
+      self._error = err
+    self._completed = True
+
+
+class OnlyOneInstanceError(BaseException):
+  """Ошибка для `.utils.OnlyOneInstance`"""
+
+  def __init__(self, *args):
+    if len(args) == 0:
+      args = ("Another instance is already running",)
+    BaseException.__init__(self, *args)
+
+
+class DotDict:
+  def __init__(self, data: dict = None):
+    self._data = {}
+    for k in data:
+      self[k] = data[k]
+
+  def __delattr__(self, k: str):
+    if k.startswith("_"):
+      return object.__delattr__(self, k)
+    del self.data[k]
+
+  def __getattr__(self, k: str):
+    if k.startswith("_"):
+      return object.__getattr__(self, k)
+    return self[k]
+
+  def __setattr__(self, k: str, v):
+    if k.startswith("_"):
+      return object.__setattr__(self, k, v)
+    self[k] = v
+
+  def __contains__(self, k: str):
+    return k in self._data
+
+  def __delitem__(self, k: str):
+    del self._data[k]
+
+  def __getitem__(self, k: str):
+    return self._data[k]
+
+  def __setitem__(self, k: str, v):
+    if "." in k:
+      k, subk = k.split(".", 1)
+      v = {subk: v}
+    if isinstance(v, dict):
+      v = type(self)(v)
+    self._data[k] = v
+
+
+class Color:
+  """Значение цвета"""
+
+  def __init__(self, *args,
+               ahex: str = None,
+               hex: str = None,
+               hexa: str = None,
+               rgb: tuple[int, int, int] = None,
+               rgba: tuple[int, int, int, int] = None,
+               ):
+    self._init_complete = False
+    self._readonly = False
+    self._red = None
+    self._green = None
+    self._blue = None
+    self._alpha = 255
+    largs = len(args)
+    if largs == 0:
+      pass
+    elif largs == 3:
+      self._check_init()
+      self.rgb = args
+    elif largs == 4:
+      self._check_init()
+      self.rgba = args
+    else:
+      raise TypeError("Give from 3 to 4 positional arguments or 1 keyword argument")
+    if not ahex is None:
+      self._check_init()
+      self.ahex = ahex
+    if not hex is None:
+      self._check_init()
+      self.hex = hex
+    if not hexa is None:
+      self._check_init()
+      self.hexa = hexa
+    if not rgb is None:
+      self._check_init()
+      self.rgb = rgb
+    if not rgba is None:
+      self._check_init()
+      self.rgba = rgba
+    if not self._init_complete:
+      raise TypeError("Give from 3 to 4 positional arguments or 1 keyword argument")
+
+  def __repr__(self):
+    cls = type(self)
+    return "%s.%s(rgba=%r)" % (cls.__module__, cls.__name__, self.rgba)
+
+  @property
+  def red(self) -> int:
+    """Уровень красного от 0 до 255"""
+    return self._red
+
+  @red.setter
+  def red(self, v):
+    self._check_ro()
+    self._red = self._check_num(v)
+    self._reset()
+
+  @property
+  def green(self) -> int:
+    """Уровень зелёного от 0 до 255"""
+    return self._green
+
+  @green.setter
+  def green(self, v):
+    self._check_ro()
+    self._green = self._check_num(v)
+    self._reset()
+
+  @property
+  def blue(self) -> int:
+    """Уровень синего от 0 до 255"""
+    return self._blue
+
+  @blue.setter
+  def blue(self, v):
+    self._check_ro()
+    self._blue = self._check_num(v)
+    self._reset()
+
+  @property
+  def alpha(self) -> int:
+    """Уровень прозрачности от 0 до 255"""
+    return self._alpha
+
+  @alpha.setter
+  def alpha(self, v):
+    self._check_ro()
+    self._alpha = self._check_num(v)
+    self._reset()
+
+  @property
+  def ahex(self) -> str:
+    """Цвет в формате AHEX (`aarrggbb`)"""
+    if self._ahex is None:
+      self._ahex = ("%02x" % self.alpha) + self.hex
+    return self._ahex
+
+  @ahex.setter
+  def ahex(self, v):
+    self.alpha, self.red, self.green, self.blue = self._split_hex(v, 4)
+
+  @property
+  def hex(self) -> str:
+    """Цвет в формате HEX (`rrggbb`). **Без прозрачности**"""
+    if self._hex is None:
+      self._hex = "%02x%02x%02x" % self.rgb
+    return self._hex
+
+  @hex.setter
+  def hex(self, v):
+    self.rgb = self._split_hex(v, 3)
+
+  @property
+  def hexa(self) -> str:
+    """Цвет в формате HEXA (`rrggbbaa`)"""
+    if self._hexa is None:
+      self._hexa = self.hex + ("%02x" % self.alpha)
+    return self._hexa
+
+  @hexa.setter
+  def hexa(self, v):
+    self.rgba = self._split_hex(v, 4)
+
+  @property
+  def rgb(self) -> tuple[int, int, int]:
+    """Цвет в формате RGB. **Без прозрачности**"""
+    if self._rgb is None:
+      self._rgb = (self.red, self.green, self.blue)
+    return self._rgb
+
+  @rgb.setter
+  def rgb(self, v):
+    self.red, self.green, self.blue = v
+
+  @property
+  def rgba(self) -> tuple[int, int, int, int]:
+    """Цвет в формате RGBA"""
+    if self._rgba is None:
+      self._rgba = (self.red, self.green, self.blue, self.alpha)
+    return self._rgba
+
+  @rgba.setter
+  def rgba(self, v):
+    self.red, self.green, self.blue, self.alpha = v
+
+  def _check_init(self):
+    if self._init_complete:
+      raise TypeError("Give from 3 to 4 positional arguments or 1 keyword argument")
+    self._init_complete = True
+
+  def _check_num(self, num: int):
+    if not isinstance(num, int):
+      raise TypeError(type(num), int)
+    if (num < 0) or (num > 255):
+      raise ValueError("The number should be in the range from 0 to 255, not %i" % num)
+    return num
+
+  def _check_ro(self):
+    if self._readonly:
+      raise RuntimeError("Read-only object")
+
+  def _reset(self):
+    self._ahex = None
+    self._hex = None
+    self._hexa = None
+    self._rgb = None
+    self._rgba = None
+
+  def _split_hex(self, hex: str, n: int) -> list[int]:
+    if hex[0] == "#":
+      hex = hex[1:]
+    lhex = len(hex)
+    if lhex != n * 2:
+      raise ValueError("Invalid HEX string")
+    nums = [int(num, 16) for num in [hex[i:i + 2] for i in range(0, lhex, 2)]]
+    return nums
+
+  @classmethod
+  def from_random(cls, red: int | range | slice = None, green: int | range | slice = None, blue: int | range | slice = None, alpha: int | range | slice = 255):
+    """Случайный цвет"""
+    from random import randint, randrange
+
+    def random(num: int | range | slice):
+      if num is None:
+        return randint(0, 255)
+      if isinstance(num, range) or isinstance(num, slice):
+        return randrange(num.start, num.stop, num.step)
+      return num
+    return cls(random(red), random(green), random(blue), random(alpha))
+
+
+class _COLORS:
+  BLACK = 0, 0, 0
+  BLUE = 0, 0, 255
+  CYAN = 0, 255, 255
+  GREEN = 0, 255, 0
+  NULL = 0, 0, 0, 0
+  RED = 255, 0, 0
+  VIOLET = 255, 0, 255
+  WHITE = 255, 255, 255
+  YELLOW = 255, 255, 0
+
+  def __init__(self):
+    self._colors = {}
+    for name in dir(self):
+      if name[0] != "_":
+        color = Color(*getattr(self, name))
+        color._readonly = True
+        self._colors[name] = color
+        setattr(self, name, color)
+
+  def __contains__(self, k) -> bool:
+    return k.upper() in self._colors
+
+  def __getitem__(self, k) -> Color:
+    return self._colors[k.upper()]
+
+
+class AutoaddDict(dict):
+  def __init__(self, *args, default_value=None, **kwargs):
+    dict.__init__(self, *args, **kwargs)
+    self.default_value = default_value
+
+  def __getitem__(self, k):
+    if not k in self:
+      self[k] = self.default_value
+    return dict.__getitem__(self, k)
+
+
+COLORS = _COLORS()
+Error401 = AccessDeniedError
+Error403 = AccessDeniedError
+Error404 = NotFoundError
+Inf = Infinity
+NaN = NotANumber

{mainshortcuts2-2.4.2 → mainshortcuts2-2.4.4}/src/MainShortcuts2/utils.py

@@ -317,7 +317,7 @@ def timedelta(time: Union[int, float, dict]):
   return datetime.timedelta(seconds=time)
 
 
-def shebang_code(code: str, *, exe_name: Union[None, str] = None, exe_path: Union[None, str] = None, none_if_no_changes: bool = False) -> Union[None, str]:
+def shebang_code(code: str, *, exe_name: Union[None, str] = None, exe_path: Union[None, str] = None, none_if_no_changes: bool = False, use_env: bool = True) -> Union[None, str]:
   """Вставить/заменить шебанг в коде. Если указать имя интерпретатора, путь будет найден с помощью `shutil.which`"""
   if (exe_name is None) and (exe_path is None):
     raise TypeError("Specify exe_name or exe_path")
@@ -325,10 +325,13 @@ def shebang_code(code: str, *, exe_name: Union[None, str] = None, exe_path: Unio
     if not exe_path is None:
       raise TypeError("exe_name and exe_path cannot be used together")
   if exe_path is None:
-    import shutil
-    exe_path = shutil.which(exe_name)
-    if exe_path is None:
-      raise Exception("Command %s not found in PATH" % exe_name)
+    if use_env:
+      exe_path = "/bin/env " + exe_name
+    else:
+      import shutil
+      exe_path = shutil.which(exe_name)
+      if exe_path is None:
+        raise Exception("Command %s not found in PATH" % exe_name)
   lines = code.split("\n")
   if none_if_no_changes:
     if lines[0] == "#!" + exe_path:
@@ -338,9 +341,11 @@ def shebang_code(code: str, *, exe_name: Union[None, str] = None, exe_path: Unio
   return "#!" + exe_path + "\n" + "\n".join(lines)
 
 
-def shebang_file(path: str, *, exe_name: Union[None, str] = None, exe_path: Union[None, str] = None) -> int:
+def shebang_file(path: str, **kw) -> int:
   """Вставить/заменить шебанг в файле кода"""
-  result = shebang_code(ms.file.read(path), exe_name=exe_name, exe_path=exe_path, none_if_no_changes=True)
+  kw["code"] = ms.file.read(path)
+  kw["none_if_no_changes"] = True
+  result = shebang_code(**kw)
   if result is None:
     return 0
   return ms.file.write(path, result)
@@ -469,5 +474,20 @@ def check_programs(*progs: str, raise_error: bool = True) -> list[str]:
   return failed
 
 
+def handle_exception(on_exception=return_None, reraise: bool = True, exc_type: type[BaseException] = Exception):
+  """Обернуть функцию в `try`/`except`"""
+  def deco(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+      try:
+        return func(*args, **kwargs)
+      except exc_type as exc:
+        on_exception(exc)
+        if reraise:
+          raise
+    return wrapper
+  return deco
+
+
 download_file = sync_download_file
 request = sync_request

mainshortcuts2-2.4.2/src/MainShortcuts2/types.py

@@ -1,147 +0,0 @@
-"""Различные объекты и исключения"""
-from typing import Union
-
-
-class Base:
-  def __init__(self, *args, **kwargs):
-    self.args = args
-    self.kwargs = kwargs
-    self.type = type(self)
-
-
-class UserError(Exception):
-  pass
-  """Ошибка, которую допустил пользователь. Например неправильно указал входные данные"""
-
-
-class AccessDeniedError(UserError):
-  pass
-  """Ошибка доступа"""
-
-
-class Empty(Base):
-  pass
-  """Пустота (не равно `None`)"""
-
-
-class Infinity(Base):
-  pass
-  """Бесконечное число"""
-
-
-class NotAFileError(Exception):
-  pass
-  """Ошибка 'это не файл'"""
-
-
-class NotANumber(Base):
-  pass
-  """Не число"""
-
-
-class NotFound(Base):
-  pass
-  """Не найдено"""
-
-
-class NotFoundError(Exception):
-  pass
-  """Ошибка 'не найдено'"""
-
-
-class Action:
-  def __init__(self, func, *args, **kwargs):
-    self._closed = False
-    self._completed = False
-    self._error = None
-    self._launched = False
-    self._result = None
-    self.args: tuple = args
-    self.func = func
-    self.kwargs: dict = kwargs
-
-  def __enter__(self):
-    return self
-
-  def __exit__(self, a, b, c):
-    self.close()
-
-  def _check(self, launched: bool = None, completed: bool = None, closed: bool = None):
-    if not launched is None:
-      if launched:
-        if not self.launched:
-          raise RuntimeError("The action has not yet been launched")
-      else:
-        if self.launched:
-          raise RuntimeError("The action has already been launched")
-    if not completed is None:
-      if completed:
-        if not self.completed:
-          raise RuntimeError("The action has not yet been completed")
-      else:
-        if self.completed:
-          raise RuntimeError("The action has already been completed")
-    if not closed is None:
-      if closed:
-        if not self.closed:
-          raise RuntimeError("The action has not yet been closed")
-      else:
-        if self.closed:
-          raise RuntimeError("The action has already been closed")
-
-  def close(self):
-    self._closed = True
-    self._error = None
-    self._result = None
-    self.args = None
-    self.func = None
-    self.kwargs = None
-
-  @property
-  def launched(self) -> bool:
-    return self._launched
-
-  @property
-  def completed(self) -> bool:
-    return self._completed
-
-  @property
-  def exception(self) -> Union[None, Exception]:
-    self._check(launched=True, completed=True, closed=False)
-    return self._error
-
-  @property
-  def result(self):
-    self._check(launched=True, completed=True, closed=False)
-    if not self._error is None:
-      raise self._error  # type: ignore
-    return self._result
-
-  @property
-  def closed(self) -> bool:
-    return self._closed
-
-  def run(self):
-    self._check(launched=False, completed=False, closed=False)
-    self._launched = True
-    try:
-      self._result = self.func(*self.args, **self.kwargs)  # type: ignore
-    except Exception as err:
-      self._error = err
-    self._completed = True
-
-
-class OnlyOneInstanceError(BaseException):
-  """Ошибка для `.utils.OnlyOneInstance`"""
-
-  def __init__(self, *args):
-    if len(args) == 0:
-      args = ("Another instance is already running",)
-    BaseException.__init__(self, *args)
-
-
-Error401 = AccessDeniedError
-Error403 = AccessDeniedError
-Error404 = NotFoundError
-Inf = Infinity
-NaN = NotANumber