MainShortcuts2 2.0.0__py3-none-any.whl

MainShortcuts2/__init__.py

@@ -0,0 +1,9 @@
+"""Упрощение и сокращение вашего кода благодаря этой библиотеке
+Разработчик: MainPlay TG
+https://t.me/MainPlayCh"""
+__all__ = ["ms", "MS2"]
+__scripts__ = ["ms2-import_example"]
+from ._module_info import version as __version__
+# 2.0.0
+from .core import MS2
+ms = MS2()

MainShortcuts2/_module_info.py

@@ -0,0 +1,2 @@
+name = "MainShortcuts2"
+version = "2.0.0"

MainShortcuts2/cfg.py

@@ -0,0 +1,125 @@
+import os
+from .core import MS2
+from .path import PATH_TYPES, path2str
+from typing import *
+ms: MS2 = None
+# 2.0.0
+types = ["json", "json5", "pickle", "toml"]
+ext2type = {
+    "json": "json",
+    "json5": "json5",
+    "pickle": "pickle",
+    "pkl": "pickle",
+    "toml": "toml",
+}
+
+
+def _check_type(path: str, type: Union[str, None]):
+  type = type.lower()
+  if not type is None:
+    if not type in types:
+      raise Exception("Type %r not supported" % type)
+    return type
+  _, ext = os.path.splitext(path).lower()
+  if ext in ext2type:
+    return ext2type[ext]
+  raise Exception("Cannot determine type by extension %r" % ext)
+
+
+def _load_type(cfg):
+  path: str = cfg.path
+  type: str = cfg.type
+  if type == "json":
+    def load(**kw):
+      kw["like_json5"] = False
+      kw["path"] = path
+      return ms.json.read(**kw)
+
+    def save(**kw):
+      kw["data"] = cfg.data
+      kw["path"] = path
+      return ms.json.write(**kw)
+  if type == "json5":
+    def load(**kw):
+      kw["like_json5"] = True
+      kw["path"] = path
+      return ms.json.read(**kw)
+
+    def save(**kw):
+      kw["data"] = cfg.data
+      kw["path"] = path
+      return ms.json.write(**kw)
+  if type == "pickle":
+    import pickle
+
+    def load(**kw):
+      with open(path, "rb") as f:
+        kw["file"] = f
+        return pickle.load(**kw)
+
+    def save(**kw):
+      buf = pickle.dumps(**kw)
+      with open(path, "wb") as f:
+        return f.write(buf)
+  if type == "toml":
+    import toml
+
+    def load(encoding="utf-8", **kw):
+      with open(path, "r", encoding=encoding) as f:
+        kw["f"] = f
+        return toml.load(**kw)
+
+    def save(encoding="utf-8", **kw):
+      kw["o"] = cfg.data
+      buf = toml.dumps(**kw)
+      with open(path, "w", encoding=encoding) as f:
+        return f.write(buf)
+  return load, save
+
+
+class cfg:
+  # 2.0.0
+  def __init__(self, path: PATH_TYPES, data: dict = None, default: dict = None, type=None):
+    self.data = {} if data is None else data
+    self.default = {} if default is None else default
+    self.path = path2str(path, True)
+    self.type = _check_type(path, type)
+    self._load_func, self._save_func = _load_type(self)
+
+  def load(self, **kw):
+    self.data = self._load_func(**kw)
+  read = load
+
+  def save(self, **kw) -> int:
+    return self._save_func(**kw)
+  write = save
+
+  def fill_defaults(self):
+    for i in self.default:
+      if not i in self:
+        self[i] = self.default[i]
+
+  def dload(self, **kw):
+    self.load(**kw)
+    self.fill_defaults()
+
+  def __contains__(self, k):
+    return k in self.data
+
+  def __delitem__(self, k):
+    del self.data[k]
+
+  def __getitem__(self, k):
+    return self.data[k]
+
+  def __setitem__(self, k, v):
+    self.data[k] = v
+
+  def items(self):
+    return self.data.items()
+
+  def keys(self):
+    return self.data.keys()
+
+  def values(self):
+    return self.data.values()

MainShortcuts2/core.py

@@ -0,0 +1,142 @@
+import os
+import sys
+from logging import Logger
+# 2.0.0
+
+
+class NoLogger:
+  def __init__(*a, **b):
+    pass
+
+  def __getattr__(self, k):
+    return lambda *a, **b: None
+
+
+class MS2:
+  def __init__(self, *,
+               __file__: str = None,
+               __name__: str = None,
+               logger: Logger = None,
+               **kw):
+    self._cfg = None
+    self._dict = None
+    self._dir = None
+    self._file = None
+    self._json = None
+    self._list = None
+    self._path = None
+    self._proc = None
+    self._str = None
+    self._term = None
+    self._utils = None
+    self._win = None
+    self.encoding = "utf-8"
+    self.env = os.environ
+    self.log: Logger = NoLogger() if logger is None else logger
+    self.prog_file = __file__
+    self.prog_name = __name__
+    self.reload()
+
+  def reload(self):
+    self.args = sys.argv
+    self.import_code = "from MainShortcuts2 import ms\nms.prog_file,ms.prog_name=__file__,__name__\nms.reload()"
+    self.imported = self.prog_name != "__main__"
+    self.pid = os.getpid()
+    self.prog_dir = os.path.dirname(self.prog_file)
+    self.running = self.prog_name == "__main__"
+
+  @property
+  def cfg(self):
+    if self._cfg is None:
+      from .cfg import cfg
+      self._cfg = cfg
+      self._cfg.ms = self
+    return self._cfg
+
+  @property
+  def dict(self):
+    if self._dict is None:
+      from . import dict
+      self._dict = dict
+      self._dict.ms = self
+    return self._dict
+
+  @property
+  def dir(self):
+    if self._dir is None:
+      from . import dir
+      self._dir = dir
+      self._dir.ms = self
+    return self._dir
+
+  @property
+  def file(self):
+    if self._file is None:
+      from . import file
+      self._file = file
+      self._file.ms = self
+    return self._file
+
+  @property
+  def json(self):
+    if self._json is None:
+      from . import json
+      self._json = json
+      self._json.ms = self
+    return self._json
+
+  @property
+  def list(self):
+    if self._list is None:
+      from . import list
+      self._list = list
+      self._list.ms = self
+    return self._list
+
+  @property
+  def path(self):
+    if self._path is None:
+      from . import path
+      self._path = path
+      self._path.ms = self
+    return self._path
+
+  @property
+  def proc(self):
+    if self._proc is None:
+      from . import proc
+      self._proc = proc
+      self._proc.ms = self
+    return self._proc
+
+  @property
+  def str(self):
+    if self._str is None:
+      from . import str
+      self._str = str
+      self._str.ms = self
+    return self._str
+
+  @property
+  def term(self):
+    if self._term is None:
+      from . import term
+      self._term = term
+      self._term.ms = self
+    return self._term
+
+  @property
+  def utils(self):
+    if self._utils is None:
+      from . import utils
+      self._utils = utils
+      self._utils.ms = self
+    return self._utils
+
+  @property
+  def win(self):
+    if self._win is None:
+      from . import win
+      self._win = win
+      self._win.ms = self
+    return self._win

MainShortcuts2/dict.py

@@ -0,0 +1,45 @@
+from .core import MS2
+from typing import *
+ms: MS2 = None
+# 2.0.0
+
+
+def merge(old: dict, new: dict) -> dict:
+  """Рекурсиво объединить словари"""
+  out = old.copy()
+  for k, v in new.items():
+    if k in out:
+      if type(out[k]) == dict and type(v) == dict:
+        out[k] = merge(out[k], v)
+      else:
+        out[k] = v
+    else:
+      out[k] = v
+  return out
+
+
+def reverse(d: dict) -> dict:
+  """Развернуть порядок ключей"""
+  keys = list(d.keys())[::-1]
+  r = {}
+  for k in keys:
+    r[k] = d[k]
+  return r
+
+
+def sort(d: dict, *, key: None = None, reverse: bool = False) -> dict:
+  """Сортировать порядок ключей"""
+  keys = list(d.keys)
+  keys.sort(key=key, reverse=reverse)
+  r = {}
+  for k in keys:
+    r[k] = d[k]
+  return r
+
+
+def swap(d: dict) -> dict:
+  """Вывернуть словарь (повторяющиеся значения будут перезаписаны)"""
+  r = {}
+  for k, v in d.items():
+    r[v] = k
+  return r

MainShortcuts2/dir.py

@@ -0,0 +1,102 @@
+import os
+from .core import MS2
+from .path import Path, PATH_TYPES, path2str
+from typing import *
+ms: MS2 = None
+# 2.0.0
+
+
+class NotADirError(Exception):
+  pass
+
+
+def _check(path, **kw) -> str:
+  kw["path"] = path
+  path = path2str(**kw)
+  if os.path.exists(path):
+    if not os.path.isdir(path):
+      raise NotADirError(path)
+  return path
+
+
+def create(path: PATH_TYPES, force: bool = True, **kw):
+  path = path2str(path)
+  if os.path.isdir(path):
+    return
+  if force:
+    if os.path.isfile(path):
+      ms.path.delete(path)
+  kw["name"] = _check(path)
+  os.makedirs(**kw)
+
+
+def _list_filter(path: Path, *, exts: Iterable[str], func: Callable[[Path], bool], links: bool, type: str):
+  if not exts is None:
+    if not path.ext in exts:
+      return False
+  if not func is None:
+    if not func(path):
+      return False
+  if not links is None:
+    if os.path.islink(path.path) != links:
+      return False
+  if not type is None:
+    if path.type != type:
+      return False
+  return True
+
+
+def list(path: PATH_TYPES = ".", *, exts: Iterable[str] = None, func: Callable[[Path], bool] = None, links: bool = None, type: str = None) -> list[Path]:
+  r = []
+  kw = {}
+  kw["exts"] = list(exts)
+  kw["func"] = func
+  kw["links"] = bool(links)
+  kw["type"] = type
+  for i in os.listdir(_check(path)):
+    i = Path(i)
+    if _list_filter(i, **kw):
+      r.append(i)
+  return i
+
+
+def copy(path: PATH_TYPES, dest: PATH_TYPES, **kw):
+  kw["dest"] = dest
+  kw["path"] = _check(path)
+  return ms.path.copy(**kw)
+
+
+def delete(path: PATH_TYPES, **kw):
+  kw["path"] = _check(path)
+  return ms.path.delete(**kw)
+
+
+def in_dir(path: str, dir: str, **kw) -> bool:
+  kw["dir"] = dir
+  kw["path"] = _check(path)
+  return ms.path.in_dir(**kw)
+
+
+def link(path: PATH_TYPES, dest: PATH_TYPES, **kw):
+  kw["dest"] = dest
+  kw["path"] = _check(path)
+  return ms.path.link(**kw)
+
+
+def move(path: PATH_TYPES, dest: PATH_TYPES, **kw):
+  kw["dest"] = dest
+  kw["path"] = _check(path)
+  return ms.path.move(**kw)
+
+
+def rename(path: PATH_TYPES, name: PATH_TYPES, **kw):
+  kw["name"] = name
+  kw["path"] = _check(path)
+  return ms.path.rename(**kw)
+
+
+cp = copy
+ln = link
+mv = move
+rm = delete
+rn = rename

MainShortcuts2/file.py

@@ -0,0 +1,92 @@
+import builtins
+import os
+from .core import MS2
+from .path import PATH_TYPES, path2str
+from typing import *
+ms: MS2 = None
+# 2.0.0
+
+
+class NotAFileError(Exception):
+  pass
+
+
+def _check(path, **kw) -> str:
+  kw["path"] = path
+  path = path2str(**kw)
+  if os.path.exists(path):
+    if not os.path.isfile(path):
+      raise NotAFileError(path)
+  return path
+
+
+def read(path: PATH_TYPES, encoding: str = None, **kw) -> str:
+  kw["encoding"] = ms.encoding if encoding is None else encoding
+  kw["file"] = _check(path)
+  kw["mode"] = "r"
+  with builtins.open(**kw) as f:
+    return f.read()
+
+
+def write(path: PATH_TYPES, data: str, encoding: str = None, **kw) -> int:
+  kw["encoding"] = ms.encoding if encoding is None else encoding
+  kw["file"] = _check(path)
+  kw["mode"] = "w"
+  with builtins.open(**kw) as f:
+    return f.write(data)
+
+
+def load(path: PATH_TYPES, **kw) -> bytes:
+  kw["file"] = _check(path)
+  kw["mode"] = "rb"
+  with builtins.open(**kw) as f:
+    return f.read()
+
+
+def save(path: PATH_TYPES, data: bytes, **kw) -> int:
+  kw["file"] = _check(path)
+  kw["mode"] = "wb"
+  with builtins.open(**kw) as f:
+    return f.write(data)
+
+
+def copy(path: PATH_TYPES, dest: PATH_TYPES, **kw):
+  kw["dest"] = dest
+  kw["path"] = _check(path)
+  return ms.path.copy(**kw)
+
+
+def delete(path: PATH_TYPES, **kw):
+  kw["path"] = _check(path)
+  return ms.path.delete(**kw)
+
+
+def in_dir(path: str, dir: str, **kw) -> bool:
+  kw["dir"] = dir
+  kw["path"] = _check(path)
+  return ms.path.in_dir(**kw)
+
+
+def link(path: PATH_TYPES, dest: PATH_TYPES, **kw):
+  kw["dest"] = dest
+  kw["path"] = _check(path)
+  return ms.path.link(**kw)
+
+
+def move(path: PATH_TYPES, dest: PATH_TYPES, **kw):
+  kw["dest"] = dest
+  kw["path"] = _check(path)
+  return ms.path.move(**kw)
+
+
+def rename(path: PATH_TYPES, name: PATH_TYPES, **kw):
+  kw["name"] = name
+  kw["path"] = _check(path)
+  return ms.path.rename(**kw)
+
+
+cp = copy
+ln = link
+mv = move
+rm = delete
+rn = rename

MainShortcuts2/json.py

@@ -0,0 +1,90 @@
+import json
+import builtins
+from .core import MS2
+from .path import PATH_TYPES
+from typing import *
+try:
+  import json5
+except Exception:
+  json5 = None
+ms: MS2 = None
+# 2.0.0
+JSON_TYPES = Union[bool, dict, float, int, list, None, str]
+
+
+def decode(text: str, *, like_json5: bool = False, **kw) -> JSON_TYPES:
+  kw["s"] = text
+  if like_json5:
+    if not json5 is None:
+      return json5.loads(**kw)
+  return json.loads(**kw)
+
+
+def encode(data: JSON_TYPES, mode: str = "c", **kw):
+  kw["obj"] = data
+  mode = mode.lower()
+  if "force" in kw:
+    del kw["force"]
+  if "sort" in kw:
+    kw["sort_keys"] = kw.pop("sort")
+  if mode in ["c", "compress", "min", "zip"]:  # Сжатый
+    kw["indent"] = None
+    kw["separators"] = [",", ":"]
+  if mode in ["p", "pretty", "max", "print"]:  # Развёрнутый
+    if not "indent" in kw:
+      kw["indent"] = 2
+    kw["separators"] = None
+  if mode in ["mp", "mp_tg", "mainplay", "mainplay_tg"]:  # Стиль MainPlay TG
+    kw["indent"] = 2
+    kw["separators"] = [",", ":"]
+  return json.dumps(**kw)
+
+
+def print(data: JSON_TYPES, mode: str = "p", **kw):
+  pr_kw = {}
+  for i in ["end", "file", "flush", "sep"]:
+    if i in kw:
+      pr_kw[i] = kw.pop(i)
+  kw["data"] = data
+  kw["mode"] = mode
+  builtins.print(encode(**kw), **pr_kw)
+
+
+def read(path: PATH_TYPES, **kw) -> JSON_TYPES:
+  f_kw = {}
+  if "encoding" in kw:
+    f_kw["encoding"] = kw.pop("encoding")
+  f_kw["path"] = path
+  kw["text"] = ms.file.read(**f_kw)
+  return decode(**kw)
+
+
+def rebuild(text: str, **kw) -> str:
+  de_kw = {}
+  if "like_json5" in kw:
+    de_kw["like_json5"] = kw.pop("like_json5")
+  de_kw["text"] = text
+  kw["data"] = decode(**de_kw)
+  return encode(**kw)
+
+
+def rewrite(path: PATH_TYPES, **kw) -> int:
+  de_kw = {}
+  if "encoding" in kw:
+    de_kw["encoding"] = kw["encoding"]
+  if "like_json5" in kw:
+    de_kw["like_json5"] = kw.pop("like_json5")
+  de_kw["path"] = path
+  kw["path"] = path
+  kw["text"] = read(**de_kw)
+  return write(**kw)
+
+
+def write(path: PATH_TYPES, data: JSON_TYPES, **kw) -> int:
+  f_kw = {}
+  for i in ["encoding", "force"]:
+    if i in kw:
+      f_kw[i] = kw.pop(i)
+  f_kw["path"] = path
+  f_kw["text"] = encode(**kw)
+  return ms.file.write(**f_kw)

MainShortcuts2/list.py

@@ -0,0 +1,84 @@
+import re
+from .core import MS2
+from typing import *
+ms: MS2 = None
+# 2.0.0
+
+
+def filter(a: list, whitelist: list = None, blacklist: list = [], regex: str = False, begin: str = None, end: str = None):
+  """Фильтровать список
+  whitelist - удалить всё, чего нет в этом списке
+  blacklist - удалить всё, что есть в этом списке
+  regex - сортировка с регулярным выражением (строки)"""
+  a = list(a)
+  if whitelist == None:
+    whitelist = a
+  if type(whitelist) == str:
+    whitelist = [whitelist]
+  if type(blacklist) == str:
+    blacklist = [blacklist]
+  b = []
+  for i in a:
+    add = True
+    if begin != None:
+      if str(i).startswith(str(begin)):
+        add = True
+      else:
+        add = False
+    if end != None and add:
+      if str(i).endswith(str(end)):
+        add = True
+      else:
+        add = False
+    if regex and add:
+      reW = False
+      for i2 in whitelist:
+        if re.match(str(i2), str(i)) != None:
+          reW = True
+          break
+      reB = False
+      for i2 in blacklist:
+        if re.match(str(i2), str(i)) != None:
+          reB = True
+          break
+      if reW and not reB:
+        add = True
+      else:
+        add = False
+    if add and not regex:
+      if (i in whitelist) and (not i in blacklist):
+        add = True
+      else:
+        add = False
+    if add:
+      b.append(i)
+  return b
+
+
+def rm_duplicates(a: list, trim: bool = False, case: bool = False, func=lambda i: i):
+  """Удалить дублирующиеся элементы
+  trim - True: использовать strip()
+         l: использовать lstrip()
+         r: использовать rstrip()
+  case - lower/upper/capitalize
+  func - обработать каждый элемент этой функцией"""
+  b = []
+  trim = str(trim).lower()
+  case = str(case).lower()
+  for i in a:
+    if trim in ["true", "lr", "rl", "all"]:
+      i = i.strip()
+    elif trim in ["l", "left"]:
+      i = i.lstrip()
+    elif trim in ["r", "right"]:
+      i = i.rstrip()
+    if case in ["l", "lower", "low"]:
+      i = i.lower()
+    elif case in ["u", "upper", "up"]:
+      i = i.upper()
+    elif case in ["capitalize", "cap"]:
+      i = i.capitalize()
+    i = func(i)
+    if not i in b:
+      b.append(i)
+  return b