architect-py 3.2.1__py3-none-any.whl → 5.0.0__py3-none-any.whl

scripts/generate_functions_md.py

@@ -0,0 +1,166 @@
+import ast
+import re
+import sys
+from collections import defaultdict
+
+
+def extract_sections(source_lines):
+    """
+    Look for section header blocks that look like:
+
+        # ------------------------------------------------------------
+        # Some Section Name
+        # ------------------------------------------------------------
+
+    Returns a list of tuples (section_name, lineno) where lineno is the
+    line number (1-indexed) of the section title.
+    """
+    sections = []
+    # Regex for a dashed line
+    dashed_re = re.compile(r"^\s*#\s*-{10,}\s*$")
+    # Regex for a section title line (should start with "#")
+    title_re = re.compile(r"^\s*#\s*(.+\S)\s*$")
+
+    i = 0
+    while i < len(source_lines):
+        if dashed_re.match(source_lines[i]):
+            if i + 1 < len(source_lines) and title_re.match(source_lines[i + 1]):
+                groups = title_re.match(source_lines[i + 1])
+                if groups is not None:
+                    section_name = groups.group(1).strip()
+                else:
+                    continue
+                # Check that the next line (i+2) is also a dashed line
+                if i + 2 < len(source_lines) and dashed_re.match(source_lines[i + 2]):
+                    sections.append(
+                        (section_name, i + 2)
+                    )  # record line number of closing dashed line, or i+1 as desired
+                    i += 3
+                    continue
+        i += 1
+    return sections
+
+
+def find_section_for_lineno(lineno, sections):
+    """
+    Given a line number (1-indexed) and a list of sections (name, lineno),
+    return the name of the last section that occurs before the given line number.
+    If none found, return "No Section".
+    """
+    candidate = None
+    for name, sec_line in sections:
+        if sec_line < lineno:
+            candidate = name
+        else:
+            break
+    return candidate if candidate is not None else "No Section"
+
+
+def get_asyncclient_methods(filename):
+    with open(filename, "r", encoding="utf-8") as f:
+        source = f.read()
+    source_lines = source.splitlines()
+    # Extract sections from source lines
+    sections = extract_sections(source_lines)
+
+    tree = ast.parse(source, filename)
+    methods = []  # list of tuples (section, func_name, doc_summary, lineno)
+
+    # Walk the AST to find the class AsyncClient
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == "AsyncClient":
+            for item in node.body:
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    # Exclude typing overloads
+                    is_fn_overload = False
+                    for decorator in item.decorator_list:
+                        decorator_name = ""
+                        if isinstance(decorator, ast.Call):
+                            decorator_name = (
+                                decorator.func.attr
+                                if isinstance(decorator.func, ast.Attribute)
+                                else getattr(decorator.func, "id", "")
+                            )
+                        else:
+                            decorator_name = (
+                                decorator.attr
+                                if isinstance(decorator, ast.Attribute)
+                                else decorator.id
+                                if isinstance(decorator, ast.Name)
+                                else ""
+                            )
+                        if decorator_name == "overload":
+                            is_fn_overload = True
+
+                    if is_fn_overload:
+                        continue
+
+                    # Get docstring using ast.get_docstring
+                    doc = ast.get_docstring(item)
+                    if doc:
+                        # Extract the first non-empty line from the docstring
+                        first_line = next(
+                            (line.strip() for line in doc.splitlines() if line.strip()),
+                            "",
+                        )
+                    else:
+                        first_line = ""
+                    section = find_section_for_lineno(item.lineno, sections)
+                    methods.append((section, item.name, first_line, item.lineno))
+            break  # found our class, stop searching
+    return methods
+
+
+def group_methods_by_section(methods):
+    grouped = defaultdict(list)
+    for section, name, summary, lineno in methods:
+        grouped[section].append((name, summary, lineno))
+    # Optionally sort sections by the lowest lineno
+    return dict(grouped)
+
+
+def main(filename):
+    methods = get_asyncclient_methods(filename)
+    grouped = group_methods_by_section(methods)
+    # For predictable order, sort sections by the minimum line number among its methods
+    sorted_sections = sorted(
+        grouped.items(),
+        key=lambda item: min(m[2] for m in grouped[item[0]]) if grouped[item[0]] else 0,
+    )
+    # Alternatively, sort by section name alphabetically:
+    # sorted_sections = sorted(grouped.items())
+    for section, funcs in sorted_sections:
+        emoji = emoji_dict.get(section, "")
+        if emoji == "":
+            raise ValueError(f'Section "{section}" does not have an emoji.')
+        print(f"### {emoji} {section}")
+        print()
+        # Sort functions by their line number
+        for name, summary, lineno in sorted(funcs, key=lambda x: x[2]):
+            # Exclude private methods
+            if name.startswith("__"):
+                continue
+            # Only output if summary is non-empty
+            if summary:
+                if summary.startswith("@deprecated"):
+                    continue
+                print(f"- **`{name}`**: {summary}")
+            else:
+                print(f"- **`{name}`**")
+        print("\n---\n")
+
+
+emoji_dict: dict[str, str] = {
+    "Initialization and configuration": "🚀",
+    "Symbology": "🔍",
+    "Portfolio management": "💹",
+    "Order management": "📝",
+    "Order entry": "📣",
+    "Marketdata": "🧮",
+}
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python extract_methods.py <filename>")
+    else:
+        main(sys.argv[1])

scripts/generate_sync_interface.py

@@ -0,0 +1,226 @@
+import argparse
+import collections.abc
+import inspect
+import types
+from decimal import Decimal
+from enum import Enum
+from typing import Annotated, Any, Sequence, Union, get_args, get_origin
+
+from architect_py.async_client import AsyncClient
+from architect_py.graphql_client.base_model import UnsetType
+
+
+def format_type_hint_with_generics(type_hint) -> str:
+    """
+    Format a type hint to a string representation with support for generic types like list[str].
+    """
+
+    if type_hint == inspect.Parameter.empty:
+        return "Any"
+
+    origin = get_origin(type_hint)
+
+    if origin is Annotated:
+        annotated_args = get_args(type_hint)
+        if annotated_args:
+            return format_type_hint_with_generics(annotated_args[0])
+        return "Any"
+
+    # Handle `|` unions (Python 3.10+)
+    if isinstance(
+        type_hint, types.UnionType
+    ):  # `types.UnionType` represents `|` unions
+        args = get_args(type_hint)
+        if type(None) in args:
+            if len(args) == 2:
+                # Handle Optional[X]
+                non_none_type = args[0] if args[1] is type(None) else args[1]
+                return f"Optional[{format_type_hint_with_generics(non_none_type)}]"
+        return (
+            f"Union[{', '.join(format_type_hint_with_generics(arg) for arg in args)}]"
+        )
+
+    if origin is Union:
+        args = get_args(type_hint)
+        if type(None) in args:
+            if len(args) == 2:
+                # Handle Optional[X]
+                non_none_type = args[0] if args[1] is type(None) else args[1]
+                return f"Optional[{format_type_hint_with_generics(non_none_type)}]"
+        return (
+            f"Union[{', '.join(format_type_hint_with_generics(arg) for arg in args)}]"
+        ).replace("NoneType", "None")
+
+    elif origin in (Sequence, collections.abc.Sequence):
+        args = get_args(type_hint)
+        if args:
+            return f"Sequence[{format_type_hint_with_generics(args[0])}]"
+        return "Sequence[Any]"
+
+    elif origin is list:
+        args = get_args(type_hint)
+        if args:
+            return f"list[{format_type_hint_with_generics(args[0])}]"
+        return "list[Any]"
+
+    elif origin is dict:
+        args = get_args(type_hint)
+        if len(args) == 2:
+            return f"dict[{format_type_hint_with_generics(args[0])}, {format_type_hint_with_generics(args[1])}]"
+        return "dict[Any, Any]"
+
+    elif origin is tuple:
+        args = get_args(type_hint)
+        if args:
+            return f"tuple[{', '.join(format_type_hint_with_generics(arg) for arg in args)}]"
+        return "tuple[Any, ...]"
+
+    try:
+        if type_hint.__module__ == "pandas" or type_hint.__module__.startswith(
+            "pandas."
+        ):
+            return f"pd.{type_hint.__name__}"
+        else:
+            return type_hint.__name__
+    except AttributeError:
+        return str(type_hint)
+
+
+def autogenerate_protocol(cls, protocol_name: str) -> str:
+    """
+    Autogenerate a Protocol for the given class for use in static typing.
+    Args:
+        cls: The class to generate a Protocol for.
+        protocol_name: The name of the Protocol to generate.
+    Returns:
+        A string representing the Protocol definition.
+    """
+    methods: dict[str, inspect.Signature] = {}
+    method_decorators: dict[str, list[str]] = {}
+    attributes: dict[str, Any] = {}
+
+    # Inspect class members
+    for name, member in inspect.getmembers(cls):
+        if name.startswith("_"):
+            continue
+        if callable(member):
+            # Collect methods
+            signature = inspect.signature(member)
+            methods[name] = signature
+
+            raw_member = inspect.getattr_static(cls, name)
+            decorators = []
+            if isinstance(raw_member, staticmethod):
+                decorators.append("@staticmethod")
+            elif isinstance(raw_member, classmethod):
+                decorators.append("@classmethod")
+            method_decorators[name] = decorators
+        elif not inspect.isroutine(member):
+            # Collect attributes
+            attributes[name] = getattr(cls, name, Any)
+
+    def format_default(value) -> str:
+        """
+        Format the default value for parameters. Handles special types.
+        """
+        if isinstance(value, Enum):
+            return f"{value.__class__.__name__}.{value.name}"
+        elif isinstance(value, (int, float, str, bool, type(None))):
+            return repr(value)
+        elif isinstance(value, Decimal):
+            return f"Decimal('{value}')"
+        elif isinstance(value, UnsetType):
+            return "UNSET"
+        return type(value).__name__
+
+    protocol_lines = [
+        "# fmt: off\n",
+        "# mypy: ignore-errors\n",
+        "# Autogenerated from generate_sync_interface.py\n",
+        "# If you are here for function definitions, please refer to architect_py/async_client.py",
+        "# This file is so that the sync client has good type hinting",
+        "# It is not used for anything else",
+        "# For maintainers: ensure that the types in this file are correct for correct type hinting",
+        "\n",
+        # "from architect_py.grpc_client.definitions import *",
+        "from typing import Any, Union",
+        "from .graphql_client import *",
+        "from .async_client import *",
+        "from .grpc.models.definitions import *",
+        f"class {protocol_name}:",
+    ]
+
+    # # Add attributes
+    # for attr_name, attr_type in attributes.items():
+    #     protocol_lines.append(
+    #         f"    {attr_name}: {format_type_hint_with_generics(attr_type)}"
+    #     )
+
+    # Add methods
+    for name, signature in methods.items():
+        if any(
+            keyword in name
+            for keyword in ("subscribe", "stream", "unsubscribe", "connect")
+        ):
+            continue
+
+        if "async" in str(signature).lower():
+            continue
+
+        # for decorators like @staticmethod and @classmethod
+        if name in method_decorators:
+            for deco in method_decorators[name]:
+                protocol_lines.append(f"    {deco}")
+
+        params = []
+        keyword_only = False
+        for param_name, param in signature.parameters.items():
+            if param_name == "self":
+                params.append("self")
+                continue
+
+            param_type = format_type_hint_with_generics(param.annotation)
+            if param.kind == inspect.Parameter.POSITIONAL_ONLY:
+                params.append(f"{param_name}: {param_type}")
+            elif param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
+                if param.default != inspect.Parameter.empty:
+                    params.append(
+                        f"{param_name}: {param_type} = {format_default(param.default)}"
+                    )
+                else:
+                    params.append(f"{param_name}: {param_type}")
+            elif param.kind == inspect.Parameter.VAR_POSITIONAL:
+                params.append(f"*{param_name}: {param_type}")
+            elif param.kind == inspect.Parameter.KEYWORD_ONLY:
+                if not keyword_only:
+                    params.append("*")  # Indicate start of keyword-only arguments
+                    keyword_only = True
+                if param.default != inspect.Parameter.empty:
+                    params.append(
+                        f"{param_name}: {param_type} = {format_default(param.default)}"
+                    )
+                else:
+                    params.append(f"{param_name}: {param_type}")
+            elif param.kind == inspect.Parameter.VAR_KEYWORD:
+                params.append(f"**{param_name}: {param_type}")
+
+        params_str = ", ".join(params)
+        return_type = format_type_hint_with_generics(signature.return_annotation)
+        protocol_lines.append(f"    def {name}({params_str}) -> {return_type}: ...")
+
+    return "\n".join(protocol_lines)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Process gRPC service definitions")
+    parser.add_argument(
+        "--file_path",
+        type=str,
+        default="architect_py/grpc_client",
+        help="Path to the Python folder with the gRPC service definitions",
+    )
+    args = parser.parse_args()
+    protocol: str = autogenerate_protocol(AsyncClient, "ClientProtocol")
+
+    with open(args.file_path, "w") as f:
+        f.write(protocol)