try 1/n

Co-authored-by: HitaloM <[email protected]>

Author: SpEcHiDe

compiler/api/compiler.py

@@ -123,19 +123,18 @@ def get_type_hint(type: str) -> str:
     if type in ["Object", "!X"]:
         return "TLObject"
 
-    if re.match("^vector", type, re.I):
+    if re.match(r"^vector", type, re.IGNORECASE):
         is_core = True
 
         sub_type = type.split("<")[1][:-1]
         type = f"list[{get_type_hint(sub_type)}]"
 
     if is_core:
         return f"Optional[{type}] = None" if is_flag else type
-    else:
-        ns, name = type.split(".") if "." in type else ("", type)
-        type = f'"raw.base.' + ".".join([ns, name]).strip(".") + '"'
+    ns, name = type.split(".") if "." in type else ("", type)
+    type = '"raw.base.' + ".".join([ns, name]).strip(".") + '"'
 
-        return f'{type}{" = None" if is_flag else ""}'
+    return f'{type}{" = None" if is_flag else ""}'
 
 
 def sort_args(args):
@@ -168,25 +167,23 @@ def get_docstring_arg_type(t: str):
     if t in CORE_TYPES:
         if t == "long":
             return "``int`` ``64-bit``"
-        elif "int" in t:
+        if "int" in t:
             size = INT_RE.match(t)
             return f"``int`` ``{size.group(1)}-bit``" if size else "``int`` ``32-bit``"
-        elif t == "double":
+        if t == "double":
             return "``float`` ``64-bit``"
-        elif t == "string":
+        if t == "string":
             return "``str``"
-        elif t == "true":
+        if t == "true":
             return "``bool``"
-        else:
-            return f"``{t.lower()}``"
-    elif t == "TLObject" or t == "X":
+        return f"``{t.lower()}``"
+    if t == "TLObject" or t == "X":
         return "Any object from :obj:`~pyrogram.raw.types`"
-    elif t == "!X":
+    if t == "!X":
         return "Any function from :obj:`~pyrogram.raw.functions`"
-    elif t.lower().startswith("vector"):
+    if t.lower().startswith("vector"):
         return "List of " + get_docstring_arg_type(t.split("<", 1)[1][:-1])
-    else:
-        return f":obj:`{t} <pyrogram.raw.base.{t}>`"
+    return f":obj:`{t} <pyrogram.raw.base.{t}>`"
 
 
 def get_references(t: str, kind: str):
@@ -258,7 +255,7 @@ def start(format: bool = False):
             qualtype = ".".join([typespace, type]).lstrip(".")
 
             # Pingu!
-            has_flags = not not FLAGS_RE_3.findall(line)
+            has_flags = bool(FLAGS_RE_3.findall(line))
 
             args = ARGS_RE.findall(line)
 
@@ -412,7 +409,7 @@ def start(format: bool = False):
                 "{} ({}{}):\n            {}\n".format(
                     arg_name,
                     get_docstring_arg_type(arg_type),
-                    ", *optional*".format(flag_number) if is_optional else "",
+                    ", *optional*" if is_optional else "",
                     arg_docs
                 )
             )
@@ -433,11 +430,11 @@ def start(format: bool = False):
             if function_docs:
                 docstring += function_docs["desc"] + "\n"
             else:
-                docstring += f"Telegram API function."
+                docstring += "Telegram API function."
 
         docstring += f"\n\n    Details:\n        - Layer: ``{layer}``\n        - ID: ``{c.id[2:].upper()}``\n\n"
-        docstring += f"    Parameters:\n        " + \
-                     (f"\n        ".join(docstring_args) if docstring_args else "No parameters required.\n")
+        docstring += "    Parameters:\n        " + \
+                     ("\n        ".join(docstring_args) if docstring_args else "No parameters required.\n")
 
         if c.section == "functions":
             docstring += "\n    Returns:\n        " + get_docstring_arg_type(c.qualtype)
@@ -517,31 +514,30 @@ def start(format: bool = False):
 
                     read_types += "\n        "
                     read_types += f"{arg_name} = TLObject.read(b) if flags{number} & (1 << {index}) else None\n        "
-            else:
-                if arg_type in CORE_TYPES:
-                    write_types += "\n        "
-                    write_types += f"b.write({arg_type.title()}(self.{arg_name}))\n        "
-
-                    read_types += "\n        "
-                    read_types += f"{arg_name} = {arg_type.title()}.read(b)\n        "
-                elif "vector" in arg_type.lower():
-                    sub_type = arg_type.split("<")[1][:-1]
-
-                    write_types += "\n        "
-                    write_types += "b.write(Vector(self.{}{}))\n        ".format(
-                        arg_name, f", {sub_type.title()}" if sub_type in CORE_TYPES else ""
-                    )
+            elif arg_type in CORE_TYPES:
+                write_types += "\n        "
+                write_types += f"b.write({arg_type.title()}(self.{arg_name}))\n        "
+
+                read_types += "\n        "
+                read_types += f"{arg_name} = {arg_type.title()}.read(b)\n        "
+            elif "vector" in arg_type.lower():
+                sub_type = arg_type.split("<")[1][:-1]
+
+                write_types += "\n        "
+                write_types += "b.write(Vector(self.{}{}))\n        ".format(
+                    arg_name, f", {sub_type.title()}" if sub_type in CORE_TYPES else ""
+                )
 
-                    read_types += "\n        "
-                    read_types += "{} = TLObject.read(b{})\n        ".format(
-                        arg_name, f", {sub_type.title()}" if sub_type in CORE_TYPES else ""
-                    )
-                else:
-                    write_types += "\n        "
-                    write_types += f"b.write(self.{arg_name}.write())\n        "
+                read_types += "\n        "
+                read_types += "{} = TLObject.read(b{})\n        ".format(
+                    arg_name, f", {sub_type.title()}" if sub_type in CORE_TYPES else ""
+                )
+            else:
+                write_types += "\n        "
+                write_types += f"b.write(self.{arg_name}.write())\n        "
 
-                    read_types += "\n        "
-                    read_types += f"{arg_name} = TLObject.read(b)\n        "
+                read_types += "\n        "
+                read_types += f"{arg_name} = TLObject.read(b)\n        "
 
         slots = ", ".join([f'"{i[0]}"' for i in sorted_args])
         return_arguments = ", ".join([f"{i[0]}={i[0]}" for i in sorted_args])
@@ -651,8 +647,8 @@ def start(format: bool = False):
         f.write("\n}\n")
 
 
-if "__main__" == __name__:
-    HOME_PATH = Path(".")
+if __name__ == "__main__":
+    HOME_PATH = Path()
     DESTINATION_PATH = Path("../../pyrogram/raw")
     NOTICE_PATH = Path("../../NOTICE")
 

compiler/docs/compiler.py

@@ -100,14 +100,14 @@ def build(path, level=0):
 
         if k != base:
             inner_path = base + "/" + k + "/index" + ".rst"
-            module = "pyrogram.raw.{}.{}".format(base, k)
+            module = f"pyrogram.raw.{base}.{k}"
         else:
             for i in sorted(list(all_entities), reverse=True):
                 if i != base:
-                    entities.insert(0, "{0}/index".format(i))
+                    entities.insert(0, f"{i}/index")
 
             inner_path = base + "/index" + ".rst"
-            module = "pyrogram.raw.{}".format(base)
+            module = f"pyrogram.raw.{base}"
 
         with open(DESTINATION + "/" + inner_path, "w", encoding="utf-8") as f:
             if k == base:
@@ -433,23 +433,23 @@ def get_title_list(s: str) -> list:
 
         for k, v in categories.items():
             name, *methods = get_title_list(v)
-            fmt_keys.update({k: "\n    ".join("{0} <{0}>".format(m) for m in methods)})
+            fmt_keys.update({k: "\n    ".join(f"{m} <{m}>" for m in methods)})
 
             for method in methods:
-                with open(root + "/{}.rst".format(method), "w") as f2:
-                    title = "{}()".format(method)
+                with open(root + f"/{method}.rst", "w") as f2:
+                    title = f"{method}()"
 
                     f2.write(title + "\n" + "=" * len(title) + "\n\n")
-                    f2.write(".. automethod:: pyrogram.Client.{}()".format(method))
+                    f2.write(f".. automethod:: pyrogram.Client.{method}()")
 
             functions = ["idle", "compose"]
 
             for func in functions:
-                with open(root + "/{}.rst".format(func), "w") as f2:
-                    title = "{}()".format(func)
+                with open(root + f"/{func}.rst", "w") as f2:
+                    title = f"{func}()"
 
                     f2.write(title + "\n" + "=" * len(title) + "\n\n")
-                    f2.write(".. autofunction:: pyrogram.{}()".format(func))
+                    f2.write(f".. autofunction:: pyrogram.{func}()")
 
         f.write(template.format(**fmt_keys))
 
@@ -712,11 +712,11 @@ def get_title_list(s: str) -> list:
 
             # noinspection PyShadowingBuiltins
             for type in types:
-                with open(root + "/{}.rst".format(type), "w") as f2:
-                    title = "{}".format(type)
+                with open(root + f"/{type}.rst", "w") as f2:
+                    title = f"{type}"
 
                     f2.write(title + "\n" + "=" * len(title) + "\n\n")
-                    f2.write(".. autoclass:: pyrogram.types.{}()\n".format(type))
+                    f2.write(f".. autoclass:: pyrogram.types.{type}()\n")
 
         f.write(template.format(**fmt_keys))
 
@@ -850,18 +850,18 @@ def get_title_list(s: str) -> list:
         for k, v in categories.items():
             name, *bound_methods = get_title_list(v)
 
-            fmt_keys.update({"{}_hlist".format(k): "\n    ".join("- :meth:`~{}`".format(bm) for bm in bound_methods)})
+            fmt_keys.update({f"{k}_hlist": "\n    ".join(f"- :meth:`~{bm}`" for bm in bound_methods)})
 
             fmt_keys.update(
-                {"{}_toctree".format(k): "\n    ".join("{} <{}>".format(bm.split(".")[1], bm) for bm in bound_methods)})
+                {f"{k}_toctree": "\n    ".join("{} <{}>".format(bm.split(".")[1], bm) for bm in bound_methods)})
 
             # noinspection PyShadowingBuiltins
             for bm in bound_methods:
-                with open(root + "/{}.rst".format(bm), "w") as f2:
-                    title = "{}()".format(bm)
+                with open(root + f"/{bm}.rst", "w") as f2:
+                    title = f"{bm}()"
 
                     f2.write(title + "\n" + "=" * len(title) + "\n\n")
-                    f2.write(".. automethod:: pyrogram.types.{}()".format(bm))
+                    f2.write(f".. automethod:: pyrogram.types.{bm}()")
 
         f.write(template.format(**fmt_keys))
 
@@ -916,18 +916,18 @@ def get_title_list(s: str) -> list:
         for k, v in categories.items():
             name, *enums = get_title_list(v)
 
-            fmt_keys.update({"{}_hlist".format(k): "\n    ".join("{}".format(enum) for enum in enums)})
+            fmt_keys.update({f"{k}_hlist": "\n    ".join(f"{enum}" for enum in enums)})
 
             fmt_keys.update(
-                {"{}_toctree".format(k): "\n    ".join("{}".format(enum) for enum in enums)})
+                {f"{k}_toctree": "\n    ".join(f"{enum}" for enum in enums)})
 
             # noinspection PyShadowingBuiltins
             for enum in enums:
-                with open(root + "/{}.rst".format(enum), "w") as f2:
-                    title = "{}".format(enum)
+                with open(root + f"/{enum}.rst", "w") as f2:
+                    title = f"{enum}"
 
                     f2.write(title + "\n" + "=" * len(title) + "\n\n")
-                    f2.write(".. autoclass:: pyrogram.enums.{}()".format(enum))
+                    f2.write(f".. autoclass:: pyrogram.enums.{enum}()")
                     f2.write("\n    :members:\n")
 
                     f2.write("\n.. raw:: html\n    :file: ./cleanup.html\n")
@@ -936,8 +936,7 @@ def get_title_list(s: str) -> list:
 
 
 def start():
-    global page_template
-    global toctree
+    global page_template, toctree
 
     shutil.rmtree(DESTINATION, ignore_errors=True)
 
@@ -953,7 +952,7 @@ def start():
     pyrogram_api()
 
 
-if "__main__" == __name__:
+if __name__ == "__main__":
     FUNCTIONS_PATH = "../../pyrogram/raw/functions"
     TYPES_PATH = "../../pyrogram/raw/types"
     BASE_PATH = "../../pyrogram/raw/base"