architect-py 5.0.0b3__py3-none-any.whl → 5.1.0__py3-none-any.whl

scripts/correct_sync_interface.py

@@ -0,0 +1,143 @@
+import argparse
+import inspect
+import re
+import textwrap
+
+from architect_py import Client
+
+
+def delete_method_and_docstring(names: list[str], lines: list[str]) -> list[str]:
+    """
+    Delete a method and its docstring from the lines of a file if the method name
+    contains any of the names in the provided list.
+    """
+    i = 0
+    delete_flag = False
+    while i < len(lines):
+        line = lines[i]
+        if "def" in line or "@" in line:
+            delete_flag = False
+
+        if delete_flag:
+            del lines[i]
+        else:
+            if "def" in line and (any(word in line for word in names)):
+                delete_flag = True
+                del lines[i]
+                if "@" in lines[i - 1]:
+                    del lines[i - 1]
+                    i -= 1
+            else:
+                i += 1
+    return lines
+
+
+def add_correct_docstring_and_correct_the_init(content: str):
+    lines = content.splitlines()
+
+    cls_doc = inspect.getdoc(Client)
+    indented_cls_doc = textwrap.indent(f'"""\n{cls_doc}\n"""', "    ")
+
+    init_method = Client.__init__
+    init_sig = inspect.signature(init_method)
+    init_doc = inspect.getdoc(init_method)
+    indented_init_doc = textwrap.indent(f'"""\n{init_doc}\n"""', " " * 8)
+
+    params = list(init_sig.parameters.values())
+    if params and params[0].name == "self":
+        params = params[1:]
+
+    pos_params = [
+        p
+        for p in params
+        if p.kind
+        in (
+            inspect.Parameter.POSITIONAL_ONLY,
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+        )
+    ]
+    kwonly_params = [p for p in params if p.kind is inspect.Parameter.KEYWORD_ONLY]
+    if kwonly_params:
+        param_parts = (
+            [str(p) for p in pos_params] + ["*"] + [str(p) for p in kwonly_params]
+        )
+    else:
+        param_parts = [str(p) for p in pos_params]
+
+    # turn Optional[Type] into Type | None
+    opt_re = re.compile(r"\b(?:Optional|Option)\[([^]]+)]")
+    param_parts = [opt_re.sub(r"\1 | None", s) for s in param_parts]
+
+    param_str = ", ".join(param_parts)
+
+    return_str = (
+        "None"
+        if init_sig.return_annotation is inspect.Signature.empty
+        else init_sig.return_annotation
+    )
+
+    i = 0
+    while i < len(lines):
+        if "class" in lines[i]:
+            lines.insert(i + 1, indented_cls_doc)
+            break
+        i += 1
+
+    i = 0
+    while i < len(lines):
+        if "def __init__" in lines[i]:
+            break
+        i += 1
+
+    delete_method_and_docstring(["__init__"], lines)
+
+    lines.insert(i - 1, indented_init_doc)
+    init_params = f", {param_str}" if param_str else ""
+    lines.insert(i - 1, f"    def __init__(self{init_params}) -> {return_str}:")
+
+    return "\n".join(lines)
+
+
+def correct_sync_interface(content: str):
+    """
+    Correct the sync interface in the gRPC service definitions.
+
+    These lines are sensitive to the order of the lines in the file.
+    """
+
+    content = f"# fmt: off\n# mypy: ignore-errors\n# ruff: noqa\n{content}"
+
+    # Remove all stream, orderflow, and subscribe methods
+    lines = content.splitlines()
+    delete_method_and_docstring(["stream", "orderflow", "subscribe", "connect"], lines)
+    content = "\n".join(lines)
+
+    # Replace the async method definitions with sync method definitions
+    content = content.replace("async def", "def")
+    content = content.replace("await ", "")
+    content = content.replace("AsyncClient", "Client")
+
+    return content
+
+
+def main(content: str) -> str:
+    content = correct_sync_interface(content)
+    content = add_correct_docstring_and_correct_the_init(content)
+
+    return content
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Process gRPC service definitions")
+    parser.add_argument(
+        "--file_path",
+        type=str,
+        help="Path to the async_client.pyi file",
+    )
+    args = parser.parse_args()
+
+    with open(args.file_path, "r") as f:
+        content = f.read()
+    content = main(content)
+    with open(args.file_path, "w") as f:
+        f.write(content)

scripts/postprocess_grpc.py

@@ -19,9 +19,6 @@ from typing import Annotated, List, Tuple, Union, get_args, get_origin
 # Regular Expressions (Constants)
 # --------------------------------------------------------------------
 
-REMOVE_ORDERDIR_RE = re.compile(
-    r"^class\s+OrderDir\b.*?(?=^class\s+\w|\Z)", re.DOTALL | re.MULTILINE
-)
 IMPORT_FIX_RE = re.compile(r"^from\s+(\.+)(\w*)\s+import\s+(.+)$")
 CLASS_HEADER_RE = re.compile(r"^(\s*)class\s+(\w+)\([^)]*Enum[^)]*\)\s*:")
 MEMBER_RE = re.compile(r"^(\s*)(\w+)\s*=\s*([0-9]+)(.*)")
@@ -304,6 +301,8 @@ def create_tagged_subtypes_for_variant_types(content: str, json_data: dict) -> s
 def fix_lines(content: str) -> str:
     """
     Fixes type annotations and adds necessary imports.
+
+    Replaces OrderDir and TimeInForce with its handrolled versions.
     """
     lines = content.splitlines(keepends=True)
 
@@ -312,13 +311,23 @@ def fix_lines(content: str) -> str:
 
     lines = [line.replace("Dir", "OrderDir") for line in lines]
     lines = [line.replace("definitions.OrderDir", "OrderDir") for line in lines]
-    lines = [line.replace("(Struct)", "(Struct, omit_defaults=True)") for line in lines]
+    lines = [line.replace("definitions.TimeInForce", "TimeInForce") for line in lines]
+
+    order_dir_exists = any("OrderDir" in line for line in lines)
+    time_in_force_exists = any("TimeInForce" in line for line in lines)
+    if order_dir_exists:
+        if not time_in_force_exists:
+            lines.insert(4, "from architect_py.common_types import OrderDir\n")
+        else:
+            lines.insert(
+                4, "from architect_py.common_types import OrderDir, TimeInForce\n"
+            )
 
-    if any("OrderDir" in line for line in lines):
-        lines.insert(4, "from architect_py.common_types import OrderDir\n")
+    lines = [line.replace("(Struct)", "(Struct, omit_defaults=True)") for line in lines]
+    delete_class(["OrderDir", "TimeInForceEnum", "GoodTilDate"], lines)
 
     content = "".join(lines)
-    content = REMOVE_ORDERDIR_RE.sub("", content)
+
     return content
 
 
@@ -355,7 +364,11 @@ def add_post_processing_to_unflattened_types(content: str, json_data: dict) -> s
         conditional = "if" if i == 0 else "elif"
         title = properties[enum_tag]["title"]
         req_keys_subset = [key for key in required_keys if key not in common_keys]
-        should_be_empty_keys = list(union_keys - set(required_keys))
+        should_be_empty_keys: list[str] = list(union_keys - set(required_keys))
+
+        req_keys_subset.sort()
+        should_be_empty_keys.sort()
+
         lines.append(
             f'        {conditional} self.{enum_tag} == "{enum_value}":\n'
             f"            if not all(getattr(self, key) is not None for key in {req_keys_subset}):\n"
@@ -459,6 +472,38 @@ def generate_stub(content: str, json_data: dict) -> str:
     return "".join(lines)
 
 
+def delete_class(names: list[str], lines: list[str]) -> list[str]:
+    """
+    Delete a method and its docstring from the lines of a file if the method name
+    contains any of the names in the provided list.
+    """
+    class_keywords = ["class", "Union"]
+
+    i = 0
+    delete_bool = False
+    while i < len(lines):
+        line = lines[i]
+        if any(word in line for word in class_keywords) and "@" not in line:
+            delete_bool = False
+        elif lines[i : i + 2] == ["\n", "\n"]:
+            delete_bool = False
+
+        if delete_bool:
+            del lines[i]
+        else:
+            if any(c in line for c in class_keywords) and (
+                any(word in line for word in names)
+            ):
+                delete_bool = True
+                del lines[i]
+                if "@" in lines[i - 1]:
+                    i = -1
+                    del lines[i]
+            else:
+                i += 1
+    return lines
+
+
 def fix_enum_member_names(content: str, json_data: dict) -> str:
     """
     Fixes enum member names based on JSON definitions.
@@ -575,13 +620,14 @@ def part_1(py_file_path: str, json_data: dict) -> None:
 
 def part_2(py_file_path: str, json_data: dict) -> None:
     content = read_file(py_file_path)
-    if not py_file_path.endswith("definitions.py"):
+    if py_file_path.endswith("definitions.py"):
         """
         we write and then read the same file because we need to update the content for when we do the import for the variant types
         """
-        content = generate_stub(content, json_data)
-    else:
         content = content.replace('    "SENTINAL_VALUE"', "")
+        content = content.replace("Model = Any", "")
+    else:
+        content = generate_stub(content, json_data)
 
     write_file(py_file_path, content)
 

scripts/preprocess_grpc_schema.py

@@ -389,6 +389,8 @@ def correct_enums_with_descriptions(schema: Dict[str, Any]) -> None:
 
     If a enum value has a description, the json gets separated
 
+    This renames the enum to the description and adds a new enum
+
     See TimeInForce for an example
     """
     if "definitions" not in schema:

scripts/prune_graphql_schema.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+Strips unused object-types, enums, inputs, interfaces and unions
+from a GraphQL schema, keeping only what is referenced by the operations
+in queries.graphql.  Any root operation (mutation / subscription) whose
+type definition is pruned away is also removed from the `schema { … }`
+block.
+
+As a part of the update_schema.py, this script is OPTIONAL but a good idea
+
+Usage:
+    python prune_schema.py full_schema.graphql queries.graphql schema.graphql
+"""
+
+import sys
+from pathlib import Path
+from typing import Set, cast
+
+from graphql import (
+    ListTypeNode,
+    NonNullTypeNode,
+    TypeInfo,
+    build_ast_schema,
+    get_named_type,
+    parse,
+    print_ast,
+    visit,
+)
+from graphql.language import (
+    DocumentNode,
+    EnumTypeDefinitionNode,
+    InputObjectTypeDefinitionNode,
+    InterfaceTypeDefinitionNode,
+    NamedTypeNode,
+    ObjectTypeDefinitionNode,
+    SchemaDefinitionNode,
+    UnionTypeDefinitionNode,
+    Visitor,
+)
+from graphql.utilities import TypeInfoVisitor
+
+SDL_KINDS_TO_PRUNE = (
+    ObjectTypeDefinitionNode,
+    EnumTypeDefinitionNode,
+    InputObjectTypeDefinitionNode,
+    InterfaceTypeDefinitionNode,
+    UnionTypeDefinitionNode,
+)
+
+
+# ───────────────────────── helpers ──────────────────────────
+def _named(node) -> NamedTypeNode:
+    """Strip List/NonNull wrappers and return the leaf NamedTypeNode."""
+    while isinstance(node, (ListTypeNode, NonNullTypeNode)):
+        node = node.type
+    return cast(NamedTypeNode, node)
+
+
+def fix_docstring_indentation(sdl: str) -> str:
+    """Indent docstring bodies by two spaces so they remain readable."""
+    lines = sdl.splitlines()
+    in_doc = False
+    for i, line in enumerate(lines):
+        if line.startswith('"""'):
+            in_doc = not in_doc
+        elif in_doc:
+            lines[i] = f"  {line}"
+    return "\n".join(lines)
+
+
+# ────────────── reachability (what types are used) ──────────────
+def _reachable_types(schema_sdl: str, queries_sdl: str) -> Set[str]:
+    schema_ast = parse(schema_sdl)
+    schema = build_ast_schema(schema_ast)
+
+    used: Set[str] = set()
+    tinfo = TypeInfo(schema)
+
+    class _Recorder(Visitor):
+        def enter(self, *_):
+            if typ := tinfo.get_type() or tinfo.get_input_type():
+                used.add(get_named_type(typ).name)
+            if (parent := tinfo.get_parent_type()) is not None:
+                used.add(parent.name)
+
+    visit(parse(queries_sdl), TypeInfoVisitor(tinfo, _Recorder()))
+
+    used.update(
+        x
+        for x in (
+            "Int",
+            "Float",
+            "String",
+            "Boolean",
+            "ID",
+            schema.query_type and schema.query_type.name,
+            schema.mutation_type and schema.mutation_type.name,
+            schema.subscription_type and schema.subscription_type.name,
+        )
+        if x
+    )
+    return used
+
+
+# ─────────────────────── pruning ──────────────────────────────
+def _prune_ast(schema_ast: DocumentNode, keep: Set[str]) -> DocumentNode:
+    # Pass 1 – drop defs never referenced
+    schema_ast.definitions = tuple(
+        d
+        for d in schema_ast.definitions
+        if not (isinstance(d, SDL_KINDS_TO_PRUNE) and d.name.value not in keep)
+    )
+
+    # Pass 2 – repeatedly:
+    #   • remove fields whose types were pruned
+    #   • drop container types left with zero fields
+    changed = True
+    while changed:
+        changed = False
+
+        new_defs = []
+        for d in schema_ast.definitions:
+            if isinstance(d, ObjectTypeDefinitionNode):
+                kept_fields = tuple(
+                    f for f in (d.fields or []) if _named(f.type).name.value in keep
+                )
+                if len(kept_fields) != len(d.fields or ()):
+                    changed = True
+                if kept_fields:
+                    new_defs.append(
+                        d.__class__(  # recreate node with surviving fields
+                            name=d.name,
+                            interfaces=d.interfaces,
+                            directives=d.directives,
+                            fields=kept_fields,
+                            description=getattr(d, "description", None),
+                            loc=d.loc,
+                        )
+                    )
+                else:
+                    changed = True  # container emptied → drop it
+            else:
+                new_defs.append(d)
+        schema_ast.definitions = tuple(new_defs)
+
+    # Pass 3 – trim mutation/subscription in the schema block
+    live_names = {
+        d.name.value
+        for d in schema_ast.definitions
+        if isinstance(d, SDL_KINDS_TO_PRUNE)
+    }
+    for defn in schema_ast.definitions:
+        if isinstance(defn, SchemaDefinitionNode):
+            defn.operation_types = tuple(
+                op
+                for op in defn.operation_types
+                if op.operation == "query" or op.type.name.value in live_names
+            )
+
+    return schema_ast
+
+
+# ─────────────────────── main entry-point ─────────────────────
+def main(schema_path: str, queries_path: str, out_path: str | None = None) -> None:
+    schema_src = Path(schema_path).read_text()
+    query_src = Path(queries_path).read_text()
+
+    keep = _reachable_types(schema_src, query_src)
+    pruned_ast = _prune_ast(parse(schema_src), keep)
+
+    sdl_out = "\n\n".join(print_ast(defn).strip() for defn in pruned_ast.definitions)
+    sdl_out = fix_docstring_indentation(sdl_out)
+
+    if out_path:
+        Path(out_path).write_text(sdl_out)
+    else:
+        print(sdl_out)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        sys.stderr.write(
+            "USAGE: uv run prune_schema.py schema.graphql queries.graphql "
+            "[pruned_schema.graphql]\n"
+        )
+        sys.exit(1)
+    main(sys.argv[1], sys.argv[2], sys.argv[3] if len(sys.argv) > 3 else None)

architect_py/client_interface.py

@@ -1,63 +0,0 @@
-# fmt: off
-
-# mypy: ignore-errors
-
-# Autogenerated from generate_sync_interface.py
-
-# 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
-
-
-from typing import Any, Union
-from .graphql_client import *
-from .async_client import *
-from .grpc.models.definitions import *
-class ClientProtocol:
-    def cancel_all_orders(self, account: Optional[str] = None, execution_venue: Optional[str] = None, trader: Optional[str] = None) -> bool: ...
-    def cancel_order(self, order_id: str) -> Cancel: ...
-    def core(self) -> GrpcClient: ...
-    def discover_marketdata(self) -> Any: ...
-    def enable_orderflow(self) -> Any: ...
-    def get_account_history(self, account: str, from_inclusive: Optional[datetime] = None, to_exclusive: Optional[datetime] = None) -> list[AccountSummary]: ...
-    def get_account_summaries(self, accounts: Optional[list[str]] = None, trader: Optional[str] = None) -> list[AccountSummary]: ...
-    def get_account_summary(self, account: str) -> AccountSummary: ...
-    def get_all_open_orders(self) -> list[Order]: ...
-    def get_cme_first_notice_date(self, symbol: str) -> Optional[date]: ...
-    def get_cme_future_from_root_month_year(self, root: str, month: int, year: int) -> str: ...
-    def get_cme_futures_series(self, series: str) -> list[tuple[date, str]]: ...
-    def get_execution_info(self, symbol: Union[TradableProduct, str], execution_venue: str) -> Optional[ExecutionInfoFields]: ...
-    def get_execution_infos(self, symbols: Optional[list[TradableProduct]], execution_venue: Optional[str] = None) -> Sequence[ExecutionInfoFields]: ...
-    @staticmethod
-    def get_expiration_from_CME_name(name: str) -> Optional[date]: ...
-    def get_fills(self, from_inclusive: Optional[datetime] = None, to_exclusive: Optional[datetime] = None, venue: Optional[str] = None, account: Optional[str] = None, order_id: Optional[str] = None, limit: Optional[int] = None) -> HistoricalFillsResponse: ...
-    def get_future_series(self, series_symbol: str) -> list[str]: ...
-    def get_futures_series(self, series_symbol: str) -> list[str]: ...
-    def get_historical_candles(self, symbol: Union[TradableProduct, str], venue: str, candle_width: CandleWidth, start: datetime, end: datetime, *, as_dataframe: bool = False) -> Union[list[Candle], pd.DataFrame]: ...
-    def get_historical_orders(self, order_ids: Optional[list[str]] = None, from_inclusive: Optional[datetime] = None, to_exclusive: Optional[datetime] = None, venue: Optional[str] = None, account: Optional[str] = None, parent_order_id: Optional[str] = None) -> list[Order]: ...
-    def get_l1_book_snapshot(self, symbol: Union[TradableProduct, str], venue: str) -> L1BookSnapshot: ...
-    def get_l1_book_snapshots(self, symbols: list[Union[TradableProduct, str]], venue: str) -> Sequence[L1BookSnapshot]: ...
-    def get_l2_book_snapshot(self, symbol: Union[TradableProduct, str], venue: str) -> L2BookSnapshot: ...
-    def get_market_snapshot(self, symbol: Union[TradableProduct, str], venue: str) -> L1BookSnapshot: ...
-    def get_market_snapshots(self, symbols: list[Union[TradableProduct, str]], venue: str) -> Sequence[L1BookSnapshot]: ...
-    def get_market_status(self, symbol: Union[TradableProduct, str], venue: str) -> MarketStatus: ...
-    def get_open_orders(self, order_ids: Optional[list[str]] = None, venue: Optional[str] = None, account: Optional[str] = None, trader: Optional[str] = None, symbol: Optional[str] = None, parent_order_id: Optional[str] = None) -> list[Order]: ...
-    def get_order(self, order_id: str) -> Optional[Order]: ...
-    def get_orders(self, order_ids: list[str]) -> list[Optional[Order]]: ...
-    def get_product_info(self, symbol: str) -> Optional[ProductInfoFields]: ...
-    def get_product_infos(self, symbols: Optional[list[str]]) -> Sequence[ProductInfoFields]: ...
-    def get_ticker(self, symbol: Union[TradableProduct, str], venue: str) -> Ticker: ...
-    def hmart(self) -> GrpcClient: ...
-    def list_accounts(self) -> list[AccountWithPermissions]: ...
-    def list_symbols(self, *, marketdata: Optional[str] = None) -> list[str]: ...
-    def marketdata(self, venue: str) -> GrpcClient: ...
-    def place_limit_order(self, *, id: Optional[str] = None, symbol: Union[TradableProduct, str], execution_venue: Optional[str] = None, dir: Optional[OrderDir] = None, quantity: Decimal, limit_price: Decimal, order_type: OrderType = OrderType.LIMIT, time_in_force: Union[GoodTilDate, TimeInForceEnum] = TimeInForceEnum.DAY, price_round_method: Optional[TickRoundMethod] = None, account: Optional[str] = None, trader: Optional[str] = None, post_only: bool = False, trigger_price: Optional[Decimal] = None, **kwargs: Any) -> Order: ...
-    def refresh_jwt(self, force: bool = False) -> Any: ...
-    def search_symbols(self, search_string: Optional[str] = None, execution_venue: Optional[str] = None, offset: int = 0, limit: int = 20) -> list[TradableProduct]: ...
-    def send_limit_order(self, *args: Any, **kwargs: Any) -> Order: ...
-    def send_market_pro_order(self, *, id: Optional[str] = None, symbol: Union[TradableProduct, str], execution_venue: str, odir: OrderDir, quantity: Decimal, time_in_force: Union[GoodTilDate, TimeInForceEnum] = TimeInForceEnum.DAY, account: Optional[str] = None, fraction_through_market: Decimal = Decimal('0.001')) -> Order: ...
-    def set_hmart(self, endpoint: str) -> Any: ...
-    def set_jwt(self, jwt: Optional[str], jwt_expiration: Optional[datetime] = None) -> Any: ...
-    def set_marketdata(self, venue: str, endpoint: str) -> Any: ...
-    def who_am_i(self) -> tuple[str, str]: ...

architect_py/common_types/scalars.py

@@ -1,25 +0,0 @@
-from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from architect_py.graphql_client.base_model import UnsetType
-
-
-def convert_datetime_to_utc_str(dt: "Optional[datetime] | UnsetType") -> Optional[str]:
-    if not isinstance(dt, datetime):
-        return None
-
-    if dt.tzinfo is None:
-        raise ValueError(
-            "in a datetime sent to the backend, the good_til_date must be timezone-aware. Try \n"
-            "from zoneinfo import ZoneInfo\n"
-            "datetime(..., tzinfo={your_local_timezone}) or "
-            "datetime.now(tz=ZoneInfo('UTC'))\n"
-            "# examples of local timezones:\n"
-            "ZoneInfo('America/New_York'), "
-            "ZoneInfo('America/Los_Angeles'), ZoneInfo('America/Chicago')"
-        )
-    utc_str = dt.astimezone(timezone.utc).isoformat()[:-6]
-    # [:-6] removes the utc offset
-
-    return f"{utc_str}Z"

architect_py/graphql_client/cancel_all_orders_mutation.py

@@ -1,17 +0,0 @@
-# Generated by ariadne-codegen
-# Source: queries.graphql
-
-from pydantic import Field
-
-from .base_model import BaseModel
-
-
-class CancelAllOrdersMutation(BaseModel):
-    oms: "CancelAllOrdersMutationOms"
-
-
-class CancelAllOrdersMutationOms(BaseModel):
-    cancel_all_orders: bool = Field(alias="cancelAllOrders")
-
-
-CancelAllOrdersMutation.model_rebuild()

architect_py/graphql_client/cancel_order_mutation.py

@@ -1,23 +0,0 @@
-# Generated by ariadne-codegen
-# Source: queries.graphql
-
-from pydantic import Field
-
-from .base_model import BaseModel
-from .fragments import CancelFields
-
-
-class CancelOrderMutation(BaseModel):
-    oms: "CancelOrderMutationOms"
-
-
-class CancelOrderMutationOms(BaseModel):
-    cancel_order: "CancelOrderMutationOmsCancelOrder" = Field(alias="cancelOrder")
-
-
-class CancelOrderMutationOmsCancelOrder(CancelFields):
-    pass
-
-
-CancelOrderMutation.model_rebuild()
-CancelOrderMutationOms.model_rebuild()

architect_py/graphql_client/create_jwt.py

@@ -1,17 +0,0 @@
-# Generated by ariadne-codegen
-# Source: queries.graphql
-
-from pydantic import Field
-
-from .base_model import BaseModel
-
-
-class CreateJwt(BaseModel):
-    user: "CreateJwtUser"
-
-
-class CreateJwtUser(BaseModel):
-    create_jwt: str = Field(alias="createJwt")
-
-
-CreateJwt.model_rebuild()

architect_py/graphql_client/get_account_history_query.py

@@ -1,27 +0,0 @@
-# Generated by ariadne-codegen
-# Source: queries.graphql
-
-from typing import List
-
-from pydantic import Field
-
-from .base_model import BaseModel
-from .fragments import AccountSummaryFields
-
-
-class GetAccountHistoryQuery(BaseModel):
-    folio: "GetAccountHistoryQueryFolio"
-
-
-class GetAccountHistoryQueryFolio(BaseModel):
-    account_history: List["GetAccountHistoryQueryFolioAccountHistory"] = Field(
-        alias="accountHistory"
-    )
-
-
-class GetAccountHistoryQueryFolioAccountHistory(AccountSummaryFields):
-    pass
-
-
-GetAccountHistoryQuery.model_rebuild()
-GetAccountHistoryQueryFolio.model_rebuild()

architect_py/graphql_client/get_account_query.py

@@ -1,23 +0,0 @@
-# Generated by ariadne-codegen
-# Source: queries.graphql
-
-from typing import Optional
-
-from .base_model import BaseModel
-from .fragments import AccountWithPermissionsFields
-
-
-class GetAccountQuery(BaseModel):
-    user: "GetAccountQueryUser"
-
-
-class GetAccountQueryUser(BaseModel):
-    account: Optional["GetAccountQueryUserAccount"]
-
-
-class GetAccountQueryUserAccount(AccountWithPermissionsFields):
-    pass
-
-
-GetAccountQuery.model_rebuild()
-GetAccountQueryUser.model_rebuild()

architect_py/graphql_client/get_account_summaries_query.py

@@ -1,27 +0,0 @@
-# Generated by ariadne-codegen
-# Source: queries.graphql
-
-from typing import List
-
-from pydantic import Field
-
-from .base_model import BaseModel
-from .fragments import AccountSummaryFields
-
-
-class GetAccountSummariesQuery(BaseModel):
-    folio: "GetAccountSummariesQueryFolio"
-
-
-class GetAccountSummariesQueryFolio(BaseModel):
-    account_summaries: List["GetAccountSummariesQueryFolioAccountSummaries"] = Field(
-        alias="accountSummaries"
-    )
-
-
-class GetAccountSummariesQueryFolioAccountSummaries(AccountSummaryFields):
-    pass
-
-
-GetAccountSummariesQuery.model_rebuild()
-GetAccountSummariesQueryFolio.model_rebuild()