Download modules/python/src2/typing_stubs_generation/nodes/node.py from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 8.3 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/python/src2/typing_stubs_generation/nodes/node.py
- Command line
-
hf download hf://tgollogly/test/modules/python/src2/typing_stubs_generation/nodes/node.py
-
curl -L -o node.py https://huggingface.co/tgollogly/test/resolve/main/modules/python/src2/typing_stubs_generation/nodes/node.py
8.3 kB
| import abc | |
| import enum | |
| import itertools | |
| from typing import (Iterator, Type, TypeVar, Dict, | |
| Optional, Tuple, DefaultDict) | |
| from collections import defaultdict | |
| import weakref | |
| ASTNodeSubtype = TypeVar("ASTNodeSubtype", bound="ASTNode") | |
| NodeType = Type["ASTNode"] | |
| NameToNode = Dict[str, ASTNodeSubtype] | |
| class ASTNodeType(enum.Enum): | |
| Namespace = enum.auto() | |
| Class = enum.auto() | |
| Function = enum.auto() | |
| Enumeration = enum.auto() | |
| Constant = enum.auto() | |
| class ASTNode: | |
| """Represents an element of the Abstract Syntax Tree produced by parsing | |
| public C++ headers. | |
| NOTE: Every node manages a lifetime of its children nodes. Children nodes | |
| contain only weak references to their direct parents, so there are no | |
| circular dependencies. | |
| """ | |
| def __init__(self, name: str, parent: Optional["ASTNode"] = None, | |
| export_name: Optional[str] = None) -> None: | |
| """ASTNode initializer | |
| Args: | |
| name (str): name of the node, should be unique inside enclosing | |
| context (There can't be 2 classes with the same name defined | |
| in the same namespace). | |
| parent (ASTNode, optional): parent node expressing node context. | |
| None corresponds to globally defined object e.g. root namespace | |
| or function without namespace. Defaults to None. | |
| export_name (str, optional): export name of the node used to resolve | |
| issues in languages without proper overload resolution and | |
| provide more meaningful naming. Defaults to None. | |
| """ | |
| FORBIDDEN_SYMBOLS = ";,*&#/|\\@!()[]^% " | |
| for forbidden_symbol in FORBIDDEN_SYMBOLS: | |
| assert forbidden_symbol not in name, \ | |
| "Invalid node identifier '{}' - contains 1 or more "\ | |
| "forbidden symbols: ({})".format(name, FORBIDDEN_SYMBOLS) | |
| assert ":" not in name, \ | |
| "Name '{}' contains C++ scope symbols (':'). Convert the name to "\ | |
| "Python style and create appropriate parent nodes".format(name) | |
| assert "." not in name, \ | |
| "Trying to create a node with '.' symbols in its name ({}). " \ | |
| "Dots are supposed to be a scope delimiters, so create all nodes in ('{}') " \ | |
| "and add '{}' as a last child node".format( | |
| name, | |
| "->".join(name.split('.')[:-1]), | |
| name.rsplit('.', maxsplit=1)[-1] | |
| ) | |
| self.__name = name | |
| self.export_name = name if export_name is None else export_name | |
| self._parent: Optional["ASTNode"] = None | |
| self.parent = parent | |
| self.is_exported = True | |
| self._children: DefaultDict[ASTNodeType, NameToNode] = defaultdict(dict) | |
| def __str__(self) -> str: | |
| return "{}('{}' exported as '{}')".format( | |
| self.node_type.name, self.name, self.export_name | |
| ) | |
| def __repr__(self) -> str: | |
| return str(self) | |
| def children_types(self) -> Tuple[ASTNodeType, ...]: | |
| """Set of ASTNode types that are allowed to be children of this node | |
| Returns: | |
| Tuple[ASTNodeType, ...]: Types of children nodes | |
| """ | |
| pass | |
| def node_type(self) -> ASTNodeType: | |
| """Type of the ASTNode that can be used to distinguish nodes without | |
| importing all subclasses of ASTNode | |
| Returns: | |
| ASTNodeType: Current node type | |
| """ | |
| pass | |
| def node_type_name(self) -> str: | |
| return f"{self.node_type.name}::{self.name}" | |
| def name(self) -> str: | |
| return self.__name | |
| def native_name(self) -> str: | |
| return self.full_name.replace(".", "::") | |
| def full_name(self) -> str: | |
| return self._construct_full_name("name") | |
| def full_export_name(self) -> str: | |
| return self._construct_full_name("export_name") | |
| def parent(self) -> Optional["ASTNode"]: | |
| return self._parent | |
| def parent(self, value: Optional["ASTNode"]) -> None: | |
| assert value is None or isinstance(value, ASTNode), \ | |
| "ASTNode.parent should be None or another ASTNode, " \ | |
| "but got: {}".format(type(value)) | |
| if value is not None: | |
| value.__check_child_before_add(self, self.name) | |
| # Detach from previous parent | |
| if self._parent is not None: | |
| self._parent._children[self.node_type].pop(self.name) | |
| if value is None: | |
| self._parent = None | |
| return | |
| # Set a weak reference to a new parent and add self to its children | |
| self._parent = weakref.proxy(value) | |
| value._children[self.node_type][self.name] = self | |
| def __check_child_before_add(self, child: ASTNodeSubtype, | |
| name: str) -> None: | |
| assert len(self.children_types) > 0, ( | |
| f"Trying to add child node '{child.node_type_name}' to node " | |
| f"'{self.node_type_name}' that can't have children nodes" | |
| ) | |
| assert child.node_type in self.children_types, \ | |
| "Trying to add child node '{}' to node '{}' " \ | |
| "that supports only ({}) as its children types".format( | |
| child.node_type_name, self.node_type_name, | |
| ",".join(t.name for t in self.children_types) | |
| ) | |
| if self._find_child(child.node_type, name) is not None: | |
| raise ValueError( | |
| f"Node '{self.node_type_name}' already has a " | |
| f"child '{child.node_type_name}'" | |
| ) | |
| def _add_child(self, child_type: Type[ASTNodeSubtype], name: str, | |
| **kwargs) -> ASTNodeSubtype: | |
| """Creates a child of the node with the given type and performs common | |
| validation checks: | |
| - Node can have children of the provided type | |
| - Node doesn't have child with the same name | |
| NOTE: Shouldn't be used directly by a user. | |
| Args: | |
| child_type (Type[ASTNodeSubtype]): Type of the child to create. | |
| name (str): Name of the child. | |
| **kwargs: Extra keyword arguments supplied to child_type.__init__ | |
| method. | |
| Returns: | |
| ASTNodeSubtype: Created ASTNode | |
| """ | |
| return child_type(name, parent=self, **kwargs) | |
| def _find_child(self, child_type: ASTNodeType, | |
| name: str) -> Optional[ASTNodeSubtype]: | |
| """Looks for child node with the given type and name. | |
| Args: | |
| child_type (ASTNodeType): Type of the child node. | |
| name (str): Name of the child node. | |
| Returns: | |
| Optional[ASTNodeSubtype]: child node if it can be found, None | |
| otherwise. | |
| """ | |
| if child_type not in self._children: | |
| return None | |
| return self._children[child_type].get(name, None) | |
| def _construct_full_name(self, property_name: str) -> str: | |
| """Traverses nodes hierarchy upright to the root node and constructs a | |
| full name of the node using original or export names depending on the | |
| provided `property_name` argument. | |
| Args: | |
| property_name (str): Name of the property to quire from node to get | |
| its name. Should be `name` or `export_name`. | |
| Returns: | |
| str: full node name where each node part is divided with a dot. | |
| """ | |
| def get_name(node: ASTNode) -> str: | |
| return getattr(node, property_name) | |
| assert property_name in ('name', 'export_name'), 'Invalid name property' | |
| name_parts = [get_name(self), ] | |
| parent = self.parent | |
| while parent is not None: | |
| name_parts.append(get_name(parent)) | |
| parent = parent.parent | |
| return ".".join(reversed(name_parts)) | |
| def __iter__(self) -> Iterator["ASTNode"]: | |
| return iter(itertools.chain.from_iterable( | |
| node | |
| # Iterate over mapping between node type and nodes dict | |
| for children_nodes in self._children.values() | |
| # Iterate over mapping between node name and node | |
| for node in children_nodes.values() | |
| )) | |