MainShortcuts2 2.1.2__tar.gz → 2.2.0__tar.gz

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MainShortcuts2
-Version: 2.1.2
+Version: 2.2.0
 Summary: Сокращение и улучшение функций
 Home-page: https://github.com/MainPlay-TG/MainShortcuts2.py
 Author: MainPlay TG

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/pyproject.toml

@@ -1,5 +1,5 @@
 [tool.poetry]
-version = "2.1.2"
+version = "2.2.0"
 name = "MainShortcuts2"
 description = "Сокращение и улучшение функций"
 authors = [ "MainPlay TG <xbox.roman6666666666@gmail.com>",]
@@ -9,8 +9,8 @@ packages = [
     { include = "MainShortcuts2", from = "src" },
 ]
 
-# [tool.poetry.scripts]
-# ms2-import_example = "MainShortcuts2.__main__:import_example"
+[tool.poetry.scripts]
+ms2-import_example = "MainShortcuts2.__main__:import_example"
 
 [tool.poetry.dependencies]
 python = "^3.6"

mainshortcuts2-2.2.0/src/MainShortcuts2/__main__.py

@@ -0,0 +1,3 @@
+def import_example():
+  print("from MainShortcuts2 import ms")
+  print("exec(ms.import_code)")

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/_module_info.py

@@ -1,2 +1,2 @@
 name = "MainShortcuts2"
-version = "2.1.2"
+version = "2.2.0"

mainshortcuts2-2.2.0/src/MainShortcuts2/advanced.py

@@ -0,0 +1,254 @@
+import re
+from .core import ms
+from .path import Path
+from typing import Any, Union
+
+
+def _check_count(data):
+  if len(data) == 0:
+    raise ValueError("The list is empty")
+
+
+class MultiLang:
+  FORMAT = 1
+
+  def __init__(self, default_lang: Union[dict, Path, str]):
+    self.cache: dict[tuple[str, str, str], str] = {}
+    self.cache_builders: dict = {}
+    self.files: dict[str, Path] = {}
+    self.langs: dict[Union[None, str], dict[str, dict[str, Any]]] = {}
+
+    def cb_lines(text: list[str]) -> str:
+      return "\n".join(text)
+
+    def cb_normal(text: str) -> str:
+      assert type(text) == str
+      return text
+    self.cache_builders["lines"] = cb_lines
+    self.cache_builders["normal"] = cb_normal
+    self.add_lang(None, default_lang, load=True)
+
+  def add_langs(self, langs: dict[str, Union[dict, Path, str]], check_count: bool = True, load: bool = True):
+    """Добавить языки (`dict`) или пути к языковым файлам (`str`, `ms.path.Path`)"""
+    if check_count:
+      _check_count(langs)
+    for k, v in langs.items():
+      self.add_lang(k, v, load=load)
+
+  def add_lang(self, lang_name: str, lang: Union[dict, Path, str], load: bool = True):
+    """Добавить один язык из словаря или пути к файлу"""
+    if type(lang) == dict:
+      for cat_name, cat in lang.items():
+        assert type(cat_name) == str
+        assert type(cat) == dict
+        for text_name, text in cat.items():
+          assert type(text_name) == str
+          if type(text) == dict:
+            if not "allow_cache" in text:
+              text["allow_cache"] = True
+            if not "type" in text:
+              text["type"] = "normal"
+      self.langs[lang_name] = lang
+      return
+    if type(lang) == str:
+      lang = Path(lang)
+    if type(lang) == Path:
+      self.files[lang_name] = lang
+      if load:
+        self.load(lang_name)
+      return
+
+  def load(self, *names: Union[None, str], check_count: bool = True):
+    """Загрузить языковые файлы"""
+    if check_count:
+      _check_count(names)
+    for i in names:
+      path = self.files[i].path
+      data = ms.json.read(path)
+      self.add_lang(i, data["texts"])
+
+  def save(self, *names: Union[None, str], check_count: bool = True, **kw) -> int:
+    """Сохранить языковые файлы"""
+    if check_count:
+      _check_count(names)
+    data = {"format": "MainShortcuts2.advanced.MultiLang/%i" % self.FORMAT}
+    sum = 0
+    for i in names:
+      data["texts"] = self.langs[i]
+      kw["data"] = data
+      kw["path"] = self.files[i].path
+      sum += ms.json.write(**kw)
+    return sum
+
+  def build_cache(self, lang_name: Union[None, str], cat_name: str, text_name: str):
+    cache_name = (lang_name, cat_name, text_name)
+    if cache_name in self.cache:
+      return
+    text = self.langs[lang_name][cat_name][text_name]
+    if type(text) == str:
+      self.cache[cache_name] = text
+      return
+    builder = self.cache_builders[text["type"]]
+    result = builder(text)
+    assert type(result) == str
+    self.cache[cache_name] = result
+
+  def get_text(self, cat: str, name: str, values=None, *, lang: str = None) -> str:
+    if not lang in self.langs:
+      self.load(lang)
+    raw = self.langs[cat][name]
+    if type(raw) == str:
+      text = raw
+    else:
+      if raw.get("allow_cache") == False:
+        text = self.cache_builders[raw["type"]](raw)
+      else:
+        self.build_cache(lang, cat, raw)
+        text = self.cache[lang, cat, name]
+    if values is None:
+      return text
+    return text % values
+
+
+class PermissionSystem:
+  FORMAT = 1
+
+  def __init__(self, path: str):
+    self.path = Path(path)
+    self.load()
+
+  def load(self):
+    data = ms.json.read(self.path.path)
+    self.default_groups = data["default_groups"] if "default_groups" in data else []
+    self.default_perms = data["default_perms"] if "default_perms" in data else {}
+    self.groups = {}
+    self.users = {}
+    for i in ["all", "group", "user"]:
+      if not i in self.default_perms:
+        self.default_perms[i] = {}
+    if "groups" in data:
+      for name, item in data["groups"].items():
+        if not "admin" in item:
+          item["admin"] = False
+        if not "perms" in item:
+          item["perms"] = self.default_perms["all"].copy()
+          item["perms"].update(self.default_perms["groups"])
+        if not "priority" in item:
+          item["priority"] = 0
+        self.groups[name] = item
+    if "users" in data:
+      for name, item in data["users"].items():
+        if not "admin" in item:
+          item["admin"] = False
+        if not "groups" in item:
+          item["groups"] = self.default_groups
+        if not "perms" in item:
+          item["perms"] = self.default_perms["all"].copy()
+          item["perms"].update(self.default_perms["users"])
+        self.groups[name] = item
+
+  def save(self, **kw):
+    kw["path"] = self.path.path
+    kw["data"] = {"format": "MainShortcuts2.advanced.PermissionSystem/%i" % self.FORMAT}
+    kw["data"]["default_groups"] = self.default_groups
+    kw["data"]["default_perms"] = self.default_perms
+    kw["data"]["groups"] = self.groups
+    kw["data"]["users"] = self.users
+    return ms.json.write(**kw)
+
+  def _i_compare(self, perms: dict[str, bool], perm: str) -> bool:
+    for k, v in perms:
+      if re.match(k, perm):
+        return v
+
+  def _verify(self, username: str, permname: str) -> bool:
+    if not username in self.users:
+      return False
+    user = self.users[username]
+    if user["admin"]:
+      return True
+    if permname in user["perms"]:
+      return user["perms"][permname]
+    group = None
+    for i in user["groups"]:
+      if i in self.groups:
+        if self.groups[i]["admin"]:
+          return True
+        if permname in self.groups[i]["perms"]:
+          if group is None:
+            group = self.groups[i]
+            continue
+          if self.groups[i]["priority"] > group["priority"]:
+            group = self.groups[i]
+            continue
+    if group is None:
+      return False
+    return group["perms"][permname]
+
+  def verify(self, username: str, permname: str, raise_error: bool = True) -> bool:
+    """Проверить есть ли у пользователя данное право. Если пользователь является админом или одна из его групп даёт разрешения админа, права есть. Если права не указаны в пользователе, используются права группы с наивысшим приоритетом, в которой указано это право. Если ни у одной группы нет права, значит права отсутствуют"""
+    result = self._verify(username, permname)
+    if raise_error:
+      if not result:
+        raise ms.types.AccessDeniedError(username, permname)
+    return result
+
+  def add_group(self, name: str, perms: dict[str, bool] = None, *, add_defaults_perms: bool = True, admin: bool = False, priority: int = 0):
+    group = {
+        "admin": admin,
+        "perms": {} if perms is None else perms.copy(),
+        "priority": priority,
+    }
+    if add_defaults_perms:
+      for i in self.default_perms["all"]:
+        if not i in group["perms"]:
+          group["perms"][i] = self.default_perms["all"][i]
+      for i in self.default_perms["group"]:
+        if not i in group["perms"]:
+          group["perms"][i] = self.default_perms["group"][i]
+    self.groups[name] = group
+
+  def add_user(self, name: str, perms: dict[str, bool] = None, *, add_defaults_perms: bool = True, admin: bool = False, groups: list[str] = None):
+    user = {
+        "admin": admin,
+        "groups": [] if groups is None else groups,
+        "perms": {} if perms is None else perms.copy(),
+    }
+    if add_defaults_perms:
+      for i in self.default_perms["all"]:
+        if not i in user["perms"]:
+          user["perms"][i] = self.default_perms["all"][i]
+      for i in self.default_perms["user"]:
+        if not i in user["perms"]:
+          user["perms"][i] = self.default_perms["user"][i]
+    self.users[name] = user
+
+  def edit_group(self, name: str, *, admin: bool = None, perms: dict[str, Union[None, bool]] = None, priority: int = None):
+    group = self.groups[name]
+    if not admin is None:
+      group["admin"] = bool(admin)
+    if not priority is None:
+      group["priority"] = int(priority)
+    if not perms is None:
+      for k, v in perms.items():
+        if v is None:
+          if k in group["perms"]:
+            del group["perms"][k]
+          else:
+            group["perms"][k] = v
+
+  def edit_user(self, name: str, *, admin: bool = None, groups: list[str] = None, perms: dict[str, Union[None, bool]] = None):
+    user = self.users[name]
+    if not admin is None:
+      user["admin"] = bool(admin)
+    if not groups is None:
+      for i in groups:
+        assert type(i) == str
+      user["groups"] = groups
+    if not perms is None:
+      for k, v in perms.items():
+        if v is None:
+          if k in user["perms"]:
+            del user["perms"][k]
+          else:
+            user["perms"][k] = v

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/cfg.py

@@ -14,8 +14,8 @@ ext2type = {
 
 
 def _check_type(path: str, type: Union[str, None]):
-  type = type.lower()
   if not type is None:
+    type = type.lower()
     if not type in types:
       raise Exception("Type %r not supported" % type)
     return type
@@ -80,7 +80,7 @@ class cfg:
   """Загрузка, использование и сохранение конфигов"""
   # 2.0.0
 
-  def __init__(self, path: PATH_TYPES, data: dict = None, default: dict = None, type=None):
+  def __init__(self, path: PATH_TYPES, data: dict = None, default: dict = None, type: str = None):
     self.data = {} if data is None else data
     self.default = {} if default is None else default
     self.path = path2str(path, True)

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/core.py

@@ -2,15 +2,26 @@ import os
 import sys
 from . import _module_info
 from logging import Logger
-# 2.0.0
+from typing import Union
 
 
-class NoLogger:
-  def __init__(*a, **b):
-    pass
+def _get_main_file():
+  def func():
+    if hasattr(sys, "frozen"):
+      if sys.frozen:
+        return sys.executable
+    if "__main__" in sys.modules:
+      if hasattr(sys.modules["__main__"], "__file__"):
+        return sys.modules["__main__"].__file__
+  result = func()
+  if result is None:
+    return
+  return os.path.abspath(result).replace("\\", "/")
+
 
-  def __getattr__(self, k):
-    return lambda *a, **b: None
+class NoLogger(Logger):
+  def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False, stacklevel=1):
+    pass
 
 
 class MS2:
@@ -21,6 +32,7 @@ class MS2:
                __name__: str = None,
                logger: Logger = None,
                **kw):
+    self._advanced = None
     self._cfg = None
     self._dict = None
     self._dir = None
@@ -29,18 +41,23 @@ class MS2:
     self._list = None
     self._path = None
     self._proc = None
+    self._regex = None
+    self._special_chars = None
     self._str = None
     self._term = None
     self._types = None
     self._utils = None
     self._win = None
-    self.args = sys.argv
-    self.encoding = "utf-8"
-    self.env = os.environ
-    self.import_code = "from MainShortcuts2 import ms\nms.prog_file,ms.prog_name=__file__,__name__\nms.reload()"
+    self.args: list[str] = sys.argv
+    self.encoding: str = "utf-8"
+    self.env: dict[str, str] = os.environ
+    self.import_code: str = "from MainShortcuts2 import ms\nms.prog_file,ms.prog_name=__file__,__name__\nms.reload()"
     self.log: Logger = NoLogger() if logger is None else logger
-    self.prog_file = __file__
-    self.prog_name = __name__
+    self.MAIN_FILE: Union[None, str] = _get_main_file()
+    self.MAIN_DIR: Union[None, str] = None if self.MAIN_FILE is None else os.path.abspath(self.MAIN_FILE)
+    self.prog_dir: Union[None, str] = None
+    self.prog_file: Union[None, str] = __file__
+    self.prog_name: Union[None, str] = __name__
     self.reload()
 
   def reload(self):
@@ -48,8 +65,8 @@ class MS2:
     if not self.prog_file is None:
       self.prog_dir = os.path.dirname(self.prog_file)
     if not self.prog_name is None:
-      self.imported = self.prog_name != "__main__"
-      self.running = self.prog_name == "__main__"
+      self.imported: bool = self.prog_name != "__main__"
+      self.running: bool = self.prog_name == "__main__"
 
   @property
   def credits(self) -> str:
@@ -73,6 +90,13 @@ class MS2:
     l.append("Спасибо за использование моей библиотеки".center(len(line)))
     return "\n".join(l)
 
+  @property
+  def advanced(self):
+    if self._advanced is None:
+      from . import advanced
+      self._advanced = advanced
+    return self._advanced
+
   @property
   def cfg(self):
     if self._cfg is None:
@@ -129,6 +153,20 @@ class MS2:
       self._proc = proc
     return self._proc
 
+  @property
+  def regex(self):
+    if self._regex is None:
+      from . import regex
+      self._regex = regex
+    return self._regex
+
+  @property
+  def special_chars(self):
+    if self._special_chars is None:
+      from . import special_chars
+      self._special_chars = special_chars
+    return self._special_chars
+
   @property
   def str(self):
     if self._str is None:

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/file.py

@@ -3,12 +3,8 @@ import builtins
 import os
 from .core import ms
 from .path import PATH_TYPES, path2str
+from .types import NotAFileError
 from typing import *
-# 2.0.0
-
-
-class NotAFileError(Exception):
-  pass
 
 
 def _check(path, **kw) -> str:

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/json.py

@@ -8,7 +8,6 @@ try:
   import json5
 except Exception:
   json5 = None
-# 2.0.0
 JSON_TYPES = Union[bool, dict, float, int, list, None, str]
 
 
@@ -42,7 +41,7 @@ def encode(data: JSON_TYPES, mode: str = "c", **kw):
   return json.dumps(**kw)
 
 
-def print(data: JSON_TYPES, mode: str = "p", **kw):
+def print(data: JSON_TYPES, **kw):
   """Напечатать данные в виде текстового JSON"""
   pr_kw = {}
   for i in ["end", "file", "flush", "sep"]:
@@ -50,6 +49,10 @@ def print(data: JSON_TYPES, mode: str = "p", **kw):
       pr_kw[i] = kw.pop(i)
   kw["data"] = data
   kw["mode"] = mode
+  if not "ensure_ascii" in kw:
+    kw["ensure_ascii"] = False
+  if not "mode" in kw:
+    kw["mode"] = "p"
   builtins.print(encode(**kw), **pr_kw)
 
 

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/list.py

@@ -2,7 +2,6 @@
 import re
 from .core import ms
 from typing import *
-# 2.0.0
 
 
 def filter(a: list, whitelist: list = None, blacklist: list = [], regex: str = False, begin: str = None, end: str = None):

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/path.py

@@ -5,7 +5,6 @@ import pathlib
 import shutil
 from .core import ms
 from typing import *
-# 2.0.0
 EXTSEP = "."
 FORBIDDEN_SYMBOLS = [":", "!", "?", "@", "*", "\"", "\n", "%", "+", "<", ">", "|"]
 PATH_TYPES = Union[io.FileIO, pathlib.Path, str]
@@ -25,7 +24,7 @@ def _path2str(path):
 
 def path2str(path: PATH_TYPES, to_abs: bool = False, replace_forbidden_to: str = None) -> str:
   """Преобразовать объект Python в строковый путь"""
-  result = _path2str(path).replace("\\", PATHSEP)
+  result = _path2str(path)
   if not replace_forbidden_to is None:
     for i in FORBIDDEN_SYMBOLS:
       if i in replace_forbidden_to:
@@ -33,32 +32,26 @@ def path2str(path: PATH_TYPES, to_abs: bool = False, replace_forbidden_to: str =
       result = result.replace(i, replace_forbidden_to)
   if to_abs:
     result = os.path.abspath(result)
-  return result
+  return result.replace("\\", PATHSEP)
 
 
-@property
-def cwd():
-  """Текущая рабочая папка"""
+def cwd(set_to: PATH_TYPES = None) -> str:
+  """Получить путь к рабочей папке"""
+  if not set_to is None:
+    os.chdir(path2str(set_to))
   return os.getcwd().replace("\\", PATHSEP)
 
 
-@cwd.setter
-def cwd(v):
-  """Текущая рабочая папка. Можно изменять (наверное)"""
-  os.chdir(path2str(v))
-
-
 class Path:
   """Информация и действия с объектом файловой системы"""
-  # 2.0.0
 
   def __init__(self, path: PATH_TYPES):
     self.cp = self.copy
     self.ln = self.link
     self.mv = self.move
+    self.path = path2str(path, to_abs=True)
     self.rm = self.delete
     self.rn = self.rename
-    self.path = path
 
   def reload(self, full: bool = False):
     """Удаление кешированной информации"""
@@ -351,6 +344,44 @@ def rename(path: PATH_TYPES, name: PATH_TYPES, **kw) -> str:
   return move(**kw)
 
 
+class TempFiles:
+  """Удаление временных файлов по окончании операций с `with`"""
+
+  def __init__(self, *files: PATH_TYPES):
+    self.files: list[str] = []
+    self.add(*files)
+
+  def __enter__(self):
+    return self
+
+  def __exit__(self, a, b, c):
+    self.remove_files()
+
+  def __contains__(self, k):
+    return k in self.files
+
+  def __delitem__(self, k):
+    if type(k) == str:
+      k = self.files.index(k)
+    del self.files[k]
+
+  def add(self, *files: PATH_TYPES):
+    """Добавить файлы в список временных"""
+    for i in files:
+      path = path2str(i, to_abs=True)
+      if not path in self.files:
+        self.files.append(path)
+
+  def remove_files(self, ignore_errors: bool = True):
+    """Удалить все временные файлы"""
+    for i in self.files:
+      try:
+        delete(i)
+      except Exception:
+        if not ignore_errors:
+          raise
+
+
 cp = copy
 ln = link
 mv = move

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/proc.py

@@ -3,7 +3,6 @@ import subprocess
 from .core import ms
 from functools import wraps
 from typing import *
-# 2.0.0
 Popen_kw = {
     "stderr": subprocess.PIPE,
     "stdin": subprocess.PIPE,

mainshortcuts2-2.2.0/src/MainShortcuts2/regex.py

@@ -0,0 +1,6 @@
+FIND_EMAIL = r"\S+@\S+\.\S+"
+FIND_IPv4_ADDR = r"(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
+FIND_MAC_ADDR = r"(?:[0-9A-Fa-f]{2}[:-]){5}(?:[0-9A-Fa-f]{2})"
+FIND_PHONE_NUMBER = r"\+?[1-9][0-9]{7,14}"
+FIND_URL = r"(?P<domain>\w+\.\w{2,3})"
+FIND_URL2 = r"[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b(?:[-a-zA-Z0-9()@:%_\+.~#?&\/=]*)"

mainshortcuts2-2.2.0/src/MainShortcuts2/special_chars.py

@@ -0,0 +1,10 @@
+CIRCLE_EMOJI = {"black": "\u26ab", "blue": "\ud83d\udd35", "brown": "\ud83d\udfe4", "green": "\ud83d\udfe2", "orange": "\ud83d\udfe0", "red": "\ud83d\udd34", "violet": "\ud83d\udfe3", "white": "\u26aa", "yellow": "\ud83d\udfe1"}
+CLOCK_EMOJI = {"00:00": "\ud83d\udd5b", "00:30": "\ud83d\udd67", "01:00": "\ud83d\udd50", "01:30": "\ud83d\udd5c", "02:00": "\ud83d\udd51", "02:30": "\ud83d\udd5d", "03:00": "\ud83d\udd52", "03:30": "\ud83d\udd5e", "04:00": "\ud83d\udd53", "04:30": "\ud83d\udd5f", "05:00": "\ud83d\udd54", "05:30": "\ud83d\udd60", "06:00": "\ud83d\udd55", "06:30": "\ud83d\udd61", "07:00": "\ud83d\udd56", "07:30": "\ud83d\udd62", "08:00": "\ud83d\udd57", "08:30": "\ud83d\udd63", "09:00": "\ud83d\udd58", "09:30": "\ud83d\udd64", "10:00": "\ud83d\udd59", "10:30": "\ud83d\udd65", "11:00": "\ud83d\udd5a", "11:30": "\ud83d\udd66"}
+FONT_EMOJI = {"*": "*\ufe0f\u20e3", "#": "#\ufe0f\u20e3", "0": "0\ufe0f\u20e3", "1": "1\ufe0f\u20e3", "10": "\ud83d\udd1f", "2": "2\ufe0f\u20e3", "3": "3\ufe0f\u20e3", "4": "4\ufe0f\u20e3", "5": "5\ufe0f\u20e3", "6": "6\ufe0f\u20e3", "7": "7\ufe0f\u20e3", "8": "8\ufe0f\u20e3", "9": "9\ufe0f\u20e3", "a": "\ud83c\udd70\ufe0f", "ab": "\ud83c\udd8e", "abc": "\ud83d\udd24", "atm": "\ud83c\udfe7", "b": "\ud83c\udd71\ufe0f", "cl": "\ud83c\udd91", "cool": "\ud83c\udd92", "free": "\ud83c\udd93", "i": "\u2139\ufe0f", "m": "\u24c2\ufe0f", "new": "\ud83c\udd95", "ng": "\ud83c\udd96", "o": "\ud83c\udd7e\ufe0f", "ok": "\ud83c\udd97", "p": "\ud83c\udd7f\ufe0f", "sos": "\ud83c\udd98", "up!": "\ud83c\udd99", "vs": "\ud83c\udd9a", "wc": "\ud83d\udebe"}
+FONT_LOWER = {"0": "\u2080", "1": "\u2081", "2": "\u2082", "3": "\u2083", "4": "\u2084", "5": "\u2085", "6": "\u2086", "7": "\u2087", "8": "\u2088", "9": "\u2089"}
+FONT_UPPER = {"-": "\u207b", "(": "\u207d", ")": "\u207e", "+": "\u207a", "=": "\u207c", "0": "\u2070", "1": "\u00b9", "2": "\u00b2", "3": "\u00b3", "4": "\u2074", "5": "\u2075", "6": "\u2076", "7": "\u2077", "8": "\u2078", "9": "\u2079", "n": "\u207f"}
+HEART_EMOJI = {"black": "\ud83d\udda4", "blue": "\ud83d\udc99", "brown": "\ud83e\udd0e", "green": "\ud83d\udc9a", "orange": "\ud83e\udde1", "red": "\u2764\ufe0f", "violet": "\ud83d\udc9c", "white": "\ud83e\udd0d", "yellow": "\ud83d\udc9b"}
+LANG_EN = "abcdefghijklmnopqrstuvwxyz"
+LANG_NUM = "0123456789"
+LANG_RU = "\u0430\u0431\u0432\u0433\u0434\u0435\u0451\u0436\u0437\u0438\u0439\u043a\u043b\u043c\u043d\u043e\u043f\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044a\u044b\u044c\u044d\u044e\u044f"
+SQUARE_EMOJI = {"black": "\u2b1b", "blue": "\ud83d\udfe6", "brown": "\ud83d\udfeb", "green": "\ud83d\udfe9", "orange": "\ud83d\udfe7", "red": "\ud83d\udfe5", "violet": "\ud83d\udfea", "white": "\u2b1c", "yellow": "\ud83d\udfe8"}

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/str.py

@@ -1,7 +1,6 @@
 """Работа со строками"""
 from .core import ms
 from typing import *
-# 2.0.0
 
 
 def list2str(a: Union[Iterable]) -> list:

mainshortcuts2-2.2.0/src/MainShortcuts2/types.py

@@ -0,0 +1,55 @@
+"""Различные объекты, которые не имеют функционала"""
+
+
+class Base:
+  def __init__(self, *args, **kwargs):
+    self.args = args
+    self.kwargs = kwargs
+    self.type = type(self)
+
+
+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 UserError(Exception):
+  pass
+  """Ошибка, которую допустил пользователь. Например неправильно указал входные данные"""
+
+
+Error401 = AccessDeniedError
+Error403 = AccessDeniedError
+Error404 = NotFoundError
+Inf = Infinity
+NaN = NotANumber

{mainshortcuts2-2.1.2 → mainshortcuts2-2.2.0}/src/MainShortcuts2/utils.py

@@ -4,7 +4,6 @@ import sys
 from .core import ms
 from functools import wraps
 from typing import *
-# 2.0.0
 
 
 class MiddlewareBase:
@@ -19,22 +18,24 @@ class MiddlewareBase:
     self._kwargs = None
     self._result = None
     self._traceback = None
-    self.completed_with_exc = None
-    self.completed = False
+    self.completed_with_exc: Union[None, bool] = None
+    self.completed: bool = False
     self.func = func
-    self.launched = False
+    self.launched: bool = False
     if not hasattr(self, "ignore_exceptions"):
-      self.ignore_exceptions = False
+      self.ignore_exceptions: bool = False
 
   def _check_completed(self):
     if not self.completed:
       raise RuntimeError("The function has not yet been completed")
 
   def _check_launched(self):
-    if not self.completed:
+    if not self.launched:
       raise RuntimeError("The function has not yet been launched")
 
   def _run(self, args, kwargs):
+    if self.launched:
+      raise RuntimeError("You can only start a function once once")
     self._args = args
     self._kwargs = kwargs
     self.launched = True
@@ -70,10 +71,10 @@ class MiddlewareBase:
     return self._kwargs
 
   @property
-  def result(self) -> Any:
+  def result(self) -> Union[Any, NoReturn]:
     self._check_completed()
     if self.completed_with_exc:
-      raise self.exception
+      raise self.exception  # type: ignore
     return self._result
 
   @property
@@ -115,7 +116,7 @@ async def async_download_file(url: str, path: str, *, delete_on_error: bool = Tr
   kw["url"] = url
   if not "method" in kw:
     kw["method"] = "GET"
-  async with async_request(**kw) as resp:
+  async with async_request(**kw) as resp:  # type: ignore
     with open(path, "wb") as fd:
       size = 0
       try:
@@ -286,7 +287,7 @@ def sync_request(method: str, url: str, *, ignore_status: bool = False, **kw):
       raise err
   kw["method"] = method
   kw["url"] = url
-  resp = requests.request(**kw)
+  resp = requests.request(**kw)  # type: ignore
   if not ignore_status:
     resp.raise_for_status()
   return resp
@@ -315,5 +316,34 @@ 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]:
+  """Вставить/заменить шебанг в коде. Если указать имя интерпретатора, путь будет найден с помощью `shutil.which`"""
+  if (exe_name is None) and (exe_path is None):
+    raise TypeError("Specify exe_name or exe_path")
+  if not exe_name is None:
+    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)
+  lines = code.split("\n")
+  if none_if_no_changes:
+    if lines[0] == "#!" + exe_path:
+      return None
+  while len(lines[0].strip()) == 0 or lines[0].startswith("#!"):
+    del lines[0]
+  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:
+  """Вставить/заменить шебанг в файле кода"""
+  result = shebang_code(ms.file.read(path), exe_name=exe_name, exe_path=exe_path, none_if_no_changes=True)
+  if result is None:
+    return 0
+  return ms.file.write(path, result)
+
+
 download_file = sync_download_file
 request = sync_request

mainshortcuts2-2.1.2/src/MainShortcuts2/types.py

@@ -1,30 +0,0 @@
-"""Различные объекты, которые не имеют функционала"""
-
-
-class Base:
-  def __init__(self):
-    self.type = type(self)
-
-
-class UserError(Exception):
-  """Ошибка, которую допустил пользователь. Например неправильно указал входные данные"""
-
-
-class Empty(Base):
-  pass
-
-
-class Infinity(Base):
-  pass
-
-
-class NotANumber(Base):
-  pass
-
-
-class NotFound(Base):
-  pass
-
-
-Inf = Infinity
-NaN = NotANumber