Кран шаровой газовый 11с67п GAS PRO ЦП.01.1 ст. 09Г2С Ду 10-200 под приварку полнопроходной с рукояткой

Таблицы размеров и характеристик

Давление PN 40
Обозначение:	11с67п GAS PRO ЦП.01.1.040.xx

+++++ src/ru/semantic_parsing.py import json from ru.semantic_parser import SemanticParser class SemanticParsing: def __init__(self, model_path: str): self.model = None # type: SemanticParser if not model_path.endswith('.json'): raise ValueError('model path must be a .json file') with open(model_path) as f: data = json.load(f) self.model = SemanticParser(data) def parse(self, text): return self.model.parse(text) +++++ src/ru/semantic_parser.py import re from ru.syntax_tree import SyntaxTree class SemanticParser: def __init__(self, model_data: dict): # TODO: add more models here if needed self.models = { 'text': TextModel(model_data) } @staticmethod def _get_model(text): return text def parse(self, text) -> SyntaxTree: """ Parse the given text and returns a syntax tree. :param text: The text to be parsed. :return: A syntax tree representing the structure of the input text. """ model = self._get_model(text) return model.parse(text) class TextModel: def __init__(self, data): """ Initialize the TextModel with a given configuration. Args: data (dict): The configuration dictionary for initializing the TextModel. It should contain 'sentence_splitter' and 'tokenizer'. - sentence_splitter: A function that splits text into sentences. - tokenizer: A list of regular expressions used to tokenize each word in a sentence. Example: data = { "sentence_splitter": lambda x: re.split(r'\s+', x), "tokenizer": [r'[a-zA-Z]+'] } """ self.sentence_splitter = data.get('sentence_splitter') if not callable(self.sentence_splitter): raise ValueError("The 'sentence_splitter' must be a function.") self.tokenizer = data.get('tokenizer', []) for token in self.tokenizer: if isinstance(token, str) and re.match(r'^[\w\s]*$', token): continue else: raise ValueError(f"Invalid regular expression '{token}' found.") def parse(self, text: str): sentences = [self._split_sentence(sentence) for sentence in self.sentence_splitter(text)] return SyntaxTree('root', children=sentences) @staticmethod def _split_sentence(sentence): """ Splits a given sentence into words based on the tokenizer regular expressions. Args: sentence (str): The input sentence to be split. Example: "Hello world!" Returns: list[str]: A list of tokens representing each word in the sentence. Each token is matched by one or more regex patterns from the tokenizer. Example: ['Hello', 'world'] """ words = [] for pattern in SemanticParser.tokenizer: match = re.search(pattern, sentence) if not match: continue start_index = 0 while True: # Find next occurrence of token using regex pattern match = re.match(r'^\s*', sentence[start_index:]) if not match or len(match.group(1)) == 0: break words.append(sentence[match.start():start_index+len(match.group())]) return SyntaxTree('sentence', children=words) +++++ src/ru/syntax_tree.py class SyntaxTree: def __init__(self, label: str = '', value=None, parent=None): """ Initialize a new instance of the SyntaxTree class. Args: - label (str): The label for this node. Example: 'root' - value : The value associated with this node. It can be any type including None if no specific value is needed. Example: 1234567890 or "Hello" """ self.label = label self.value = value def __repr__(self): return f'SyntaxTree({self.label}, {self.value})' @staticmethod def _print_tree(node, level=0): if node is None: return 'None' result = '\t'*level + str(node) + '\n' for child in node.children: # Recursively print each subtree rooted at the current node's children. result += SyntaxTree._print_tree(child, level+1) return result def __str__(self): """ Returns a string representation of this tree. This method generates and returns a formatted string that represents the structure of this syntax tree. The output includes indentation to visually represent the hierarchical relationships between nodes. """ # If there are no children, return just the label value as a string. if not self.children: return f'{self.label}' result = '\t' * 0 + str(self) + '\n' for child in self.children: # Recursively print each subtree rooted at this node's children result += SyntaxTree._print_tree(child, level=1) return result @property def children(self): """ Returns the list of children nodes. This property provides access to a list containing all child nodes directly connected to this node. It is used for traversing and manipulating tree structures in various algorithms or operations, such as depth-first search, breadth-first search, etc. If no children exist, an empty list will be returned instead of None. Returns: List[SyntaxTree]: A list containing all child nodes directly connected to this node. """ return [] @children.setter def children(self, value): self._children = value # TODO: add more methods here if needed +++++ src/ru/semantic_parser_test.py import unittest from ru.syntax_tree import SyntaxTree from ru.semantic_parsing import SemanticParsing class TestSemanticParser(unittest.TestCase): def test_parse(self): model_path = 'src/models/text_model.json' semantic_parser = SemanticParsing(model_path) text = "Привет мир! Как дела?" result = semantic_parser.parse(text) expected_result = SyntaxTree('root', children=[ SyntaxTree('sentence', children=['Привет']), SyntaxTree('sentence', children=['мир']) ]) self.assertEqual(result, expected_result) if __name__ == '__main__': unittest.main() +++++ src/ru/syntax_tree_test.py import unittest from ru.syntax_tree import SyntaxTree class TestSyntaxTree(unittest.TestCase): def test_str(self): tree = SyntaxTree('root', children=[ SyntaxTree('sentence', value='Привет мир!'), SyntaxTree('sentence', value="Как дела?"), ]) expected_output = 'SyntaxTree(root, None)\n\tSyntaxTree(sentence, Привет мир!)\n' \ '\tSyntaxTree(sentence, Как дела?)\n' self.assertEqual(str(tree), expected_output) if __name__ == '__main__': unittest.main()