diff --git a/.ci/aptPackagesToInstall.txt b/.ci/aptPackagesToInstall.txt new file mode 100644 index 0000000..e69de29 diff --git a/.ci/pythonPackagesToInstallFromGit.txt b/.ci/pythonPackagesToInstallFromGit.txt new file mode 100644 index 0000000..e69de29 diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..49ce462 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,12 @@ +root = true + +[*] +charset = utf-8 +indent_style = tab +indent_size = 4 +insert_final_newline = true +end_of_line = lf + +[*.{yml,yaml,yug}] +indent_style = space +indent_size = 2 diff --git a/.github/.templateMarker b/.github/.templateMarker new file mode 100644 index 0000000..5e3a3e0 --- /dev/null +++ b/.github/.templateMarker @@ -0,0 +1 @@ +KOLANICH/python_project_boilerplate.py diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..89ff339 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,8 @@ +version: 2 +updates: + - package-ecosystem: "pip" + directory: "/" + schedule: + interval: "daily" + allow: + - dependency-type: "all" diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 0000000..7fe33b3 --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,15 @@ +name: CI +on: + push: + branches: [master] + pull_request: + branches: [master] + +jobs: + build: + runs-on: ubuntu-22.04 + steps: + - name: typical python workflow + uses: KOLANICH-GHActions/typical-python-workflow@master + with: + github_token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a8e925a --- /dev/null +++ b/.gitignore @@ -0,0 +1,13 @@ +*.log +*.pdf + +__pycache__ +*.py[co] +/*.egg-info +*.srctrlbm +*.srctrldb +build +dist +.eggs +monkeytype.sqlite3 +/.ipynb_checkpoints diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..6c124dc --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,51 @@ +image: registry.gitlab.com/kolanich-subgroups/docker-images/fixed_python:latest + +variables: + DOCKER_DRIVER: overlay2 + SAST_ANALYZER_IMAGE_TAG: latest + SAST_DISABLE_DIND: "true" + SAST_CONFIDENCE_LEVEL: 5 + CODECLIMATE_VERSION: latest + +include: + - template: SAST.gitlab-ci.yml + - template: Code-Quality.gitlab-ci.yml + - template: License-Management.gitlab-ci.yml + +build: + tags: + - shared + - linux + stage: build + variables: + GIT_DEPTH: "1" + PYTHONUSERBASE: ${CI_PROJECT_DIR}/python_user_packages + + before_script: + - export PATH="$PATH:$PYTHONUSERBASE/bin" # don't move into `variables` + - apt-get update + # todo: + #- apt-get -y install + #- pip3 install --upgrade + #- python3 ./fix_python_modules_paths.py + + script: + - python3 -m build -nw bdist_wheel + - mv ./dist/*.whl ./dist/FullingMotorModelDecoder-0.CI-py3-none-any.whl + - pip3 install --upgrade ./dist/*.whl + - coverage run --source=FullingMotorModelDecoder -m --branch pytest --junitxml=./rspec.xml ./tests/test.py + - coverage report -m + - coverage xml + + coverage: "/^TOTAL(?:\\s+\\d+){4}\\s+(\\d+%).+/" + + cache: + paths: + - $PYTHONUSERBASE + + artifacts: + paths: + - dist + reports: + junit: ./rspec.xml + cobertura: ./coverage.xml diff --git a/Code_Of_Conduct.md b/Code_Of_Conduct.md new file mode 100644 index 0000000..bcaa2bf --- /dev/null +++ b/Code_Of_Conduct.md @@ -0,0 +1 @@ +No codes of conduct! \ No newline at end of file diff --git a/FullingMotorModelDecoder/__init__.py b/FullingMotorModelDecoder/__init__.py new file mode 100644 index 0000000..e765042 --- /dev/null +++ b/FullingMotorModelDecoder/__init__.py @@ -0,0 +1,141 @@ +from pathlib import Path +from warnings import warn +import typing + +from UniGrammarRuntime.ParserBundle import ParserBundle + +_thisDir = Path(__file__).parent + +bundleDir = _thisDir / "parserBundle" +bundle = ParserBundle(bundleDir) +grammar = bundle.grammars["fulling_motor_name"] +wrapper = grammar.getWrapper("antlr4") + + +def decodeShaftsCount(letter: str) -> int: + return ord(letter.upper()) - ord("A") + 1 + +from icecream import ic + +def _decodeParsed(p) -> dict: + res = {} + res["size"] = int(p.size) + tpd = p.typed + series = tpd.__class__.__name__[:-2] + res["type"] = series + # + m = tpd.type_marker + + def processSuffix(stepsLower: typing.Optional[int] = None): + sfx = tpd.suffix + if sfx: + sb = sfx.suffix_body + try: + # current_rated current_peak_max current_per_phase current_unloaded + res["current_per_phase"] = int(sb.current) / 10 ** (len(sb.current) - 1) + except AttributeError: + st = sb + else: + st = sb.tail + + res["variant"] = int(st.variant) + res["encoder"] = bool(st.encoder) + res["key_way"] = bool(st.key_way) + res["screwed_shaft"] = bool(st.screwed_shaft) + res["unknown_F"] = bool(st.unknown_F) + res["hollow"] = bool(st.hollow) + + scsr = st.shafts_count_and_step_rate_any_order + if scsr.shafts_count: + res["shafts_count"] = decodeShaftsCount(scsr.shafts_count) + if stepsLower is not None: + res["steps_per_revolution"] = stepsLower * 2 if scsr.step_rate else stepsLower + + if st.gearbox: + res["gearbox"] = float(st.gearbox.ratio) + else: + res["gearbox"] = None + + #res[series] = True + if series == "brushless": + for k in m.__slots__: + if getattr(m, k): + res[k[3:]] = True + + modifier = tpd.modifier + + try: + res["motor_body_length"] = int(modifier.motor_body_length) + except AttributeError: + res["poles_or_other"] = modifier.poles_or_other # usually determines count of poles, A models have more poles (usually 10) than non-lettered models (usually 8), B models have more poles (usually 6) than non-lettered models, but some B models have no A analogues and have 8 poles and C models usually have no analogues and also have 8 poles. + res["variant"] = int(modifier.variant) + else: + if modifier.tail: # ToDo: from the parsed ones I see no tail + try: + res['electronics'] = bool(modifier.tail.has_electronics) + except AttributeError: + cfg = modifier.tail + else: + cfg = modifier.tail.cfg + else: + cfg = None + + if cfg: + unit2Name = { + "V": 'voltage', + "A": "current" + } + + quantityKeyName = unit2Name[cfg.unit] + "_rated" + res[quantityKeyName] = int(cfg.number) + + elif series == "stepper": + res["motor_body_length"] = int(tpd.motor_body_length) + markers = { + None: "standard", + "T": "standard", + 'H': "hybrid" + } + res["series"] = markers[m.series] + + if tpd.stepper_modifiers: + modifiers = { + 'H': {"high_torque": True}, + 'C': {"hyper_torque": True}, + } + res.update(modifiers[tpd.stepper_modifiers]) + + processSuffix(200) + + elif series == "permanent": + res["motor_body_length"] = int(tpd.motor_body_length) + processSuffix(None) # usually stepsLower=20, but not always + elif series == "three_phase": + res["motor_body_length"] = int(tpd.motor_body_length) + sfx = tpd.suffix + if sfx: + res["current_per_phase"] = int(sfx.current_per_phase_over_ten) / 10 + if sfx.leads: + res["input_count"] = int(sfx.leads) + if sfx.shafts_count: + res["shafts_count"] = decodeShaftsCount(sfx.shafts_count) + + else: + raise ValueError(series) + + + steps = res.get("steps_per_revolution", None) + if steps: + res['angle_step'] = 360 / steps + + for shapeType in ("round", "square"): + if res.get(shapeType, None): + del res[shapeType] + res["shape"] = shapeType + + return res + +def decodeModel(s: str) -> dict: + p = wrapper(s) + #print(p) + return _decodeParsed(p) diff --git a/FullingMotorModelDecoder/__main__.py b/FullingMotorModelDecoder/__main__.py new file mode 100644 index 0000000..df29249 --- /dev/null +++ b/FullingMotorModelDecoder/__main__.py @@ -0,0 +1,95 @@ +import sys, json, re +from . import decodeModel +from collections import OrderedDict +#from .utils import makeSerializeable + +import importlib.util + + +def ifModExists(modName): + return importlib.util.find_spec(modName) is not None + + +useML = ifModExists("numpy") and ifModExists("pandas") and ifModExists("xgboost") and ifModExists("Chassis") and ifModExists("AutoXGBoost") + +try: + from RichConsole import groups, rsjoin + + styles = { + "prefix": groups.Fore.lightcyanEx, + "cli": groups.Fore.lightgreenEx, + "help": groups.Fore.lightmagentaEx, + } +except: + styles = { + "prefix": lambda x: x, + "cli": lambda x: x, + "help": lambda x: x, + } + + def rsjoin(self, *args, **kwargs): + return self.join(*args, **kwargs) + + +endMainRx = re.compile("\.__main__$") +wsRx = re.compile("\s") + + +def splitByWhitespaces(file): + for l in file: + yield from wsRx.split(l) + + +def showHelp(): + if sys.platform == "win32": + try: + import colorama + + colorama.init() + except: + pass + prefix = styles["prefix"](rsjoin(" ", ("python -m", endMainRx.sub("", __spec__.name)))) + print(rsjoin("\n", (styles["cli"](rsjoin(" ", (prefix, cliArg))) + styles["help"](" - " + par[1]) for cliArg, par in singleArgLUT.items()))) + + +def getModelObj(mn): + #return makeSerializeable(decodeModel(mn, useML, True)) + return decodeModel(mn) + + +def whole(modelNames): + json.dump(OrderedDict(((el, getModelObj(el)) for el in modelNames)), sys.stdout, indent="\t") + + +def fromStdinByOne(): + for el in filter(None, splitByWhitespaces(sys.stdin)): + json.dump(getModelObj(el), sys.stdout, indent="\t") + sys.stdout.write("\n") + sys.stdout.flush() + + +def fromStdinWhole(): + whole(filter(None, splitByWhitespaces(sys.stdin))) + + +singleArgLUT = OrderedDict(( + ("model_name_1, model_name_2, ...", (None, "to pass models namebers as parameters")), + ("--", (fromStdinByOne, "to pipe models namebers into stdin and get the results as JSON one by one")), + ("-", (fromStdinWhole, "to pipe models namebers file into stdin and get the results as a JSON array")), + ("-h", (showHelp, "shows help")), + ("--help", (showHelp, "shows help")), +)) + + +def main(): + if len(sys.argv) < 2: + showHelp() + elif len(sys.argv) == 2 and sys.argv[1] in singleArgLUT: + singleArgLUT[sys.argv[1]][0]() + else: + whole(sys.argv[1:]) + sys.stdout.write("\n") + + +if __name__ == "__main__": + main() diff --git a/FullingMotorModelDecoder/parserBundle/__init__.py b/FullingMotorModelDecoder/parserBundle/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/compiled/TatSu/fulling_motor_name.py b/FullingMotorModelDecoder/parserBundle/compiled/TatSu/fulling_motor_name.py new file mode 100644 index 0000000..ee3a831 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/TatSu/fulling_motor_name.py @@ -0,0 +1,1048 @@ +#!/usr/bin/env python + +# CAVEAT UTILITOR +# +# This file was automatically generated by TatSu. +# +# https://pypi.python.org/pypi/tatsu/ +# +# Any changes you make to it will be overwritten the next time +# the file is generated. + +from __future__ import annotations + +import sys + +from tatsu.buffering import Buffer +from tatsu.parsing import Parser +from tatsu.parsing import tatsumasu +from tatsu.parsing import leftrec, nomemo, isname # noqa +from tatsu.infos import ParserConfig +from tatsu.util import re, generic_main # noqa + + +KEYWORDS = {} # type: ignore + + +class fulling_motor_nameBuffer(Buffer): + def __init__(self, text, /, config: ParserConfig = None, **settings): + config = ParserConfig.new( + config, + owner=self, + whitespace=None, + nameguard=None, + comments_re=None, + eol_comments_re=None, + ignorecase=False, + namechars='', + parseinfo=False, + ) + config = config.replace(**settings) + super().__init__(text, config=config) + + +class fulling_motor_nameParser(Parser): + def __init__(self, /, config: ParserConfig = None, **settings): + config = ParserConfig.new( + config, + owner=self, + whitespace=None, + nameguard=None, + comments_re=None, + eol_comments_re=None, + ignorecase=False, + namechars='', + parseinfo=False, + keywords=KEYWORDS, + ) + config = config.replace(**settings) + super().__init__(config=config) + + @tatsumasu() + def _main_(self): # noqa + with self._optional(): + self._fl_() + self._two_or_three_digit_number_() + self.name_last_node('size') + self._type_specific_() + self.name_last_node('typed') + self._define( + ['size', 'typed'], + [] + ) + + @tatsumasu() + def _gearbox_specifier_(self): # noqa + self._G_() + self._float_number_() + self.name_last_node('ratio') + self._define( + ['ratio'], + [] + ) + + @tatsumasu() + def _type_specific_(self): # noqa + with self._choice(): + with self._option(): + self._stepper_t_() + self.name_last_node('stepper') + self._define( + ['stepper'], + [] + ) + with self._option(): + self._permanent_t_() + self.name_last_node('permanent') + self._define( + ['permanent'], + [] + ) + with self._option(): + self._brushless_t_() + self.name_last_node('brushless') + self._define( + ['brushless'], + [] + ) + with self._option(): + self._three_phase_t_() + self.name_last_node('three_phase') + self._define( + ['three_phase'], + [] + ) + self._error( + 'expecting one of: ' + ' ' + ' ' + '' + ' ' + ' ' + ) + self._define( + ['brushless', 'permanent', 'stepper', 'three_phase'], + [] + ) + + @tatsumasu() + def _three_phase_t_(self): # noqa + self._three_phase_marker_() + self.name_last_node('type_marker') + self._two_or_three_digit_number_() + self.name_last_node('motor_body_length') + self._three_phase_suffix_opt_our_() + self.name_last_node('suffix') + self._define( + ['motor_body_length', 'suffix', 'type_marker'], + [] + ) + + @tatsumasu() + def _three_phase_suffix_opt_our_(self): # noqa + with self._optional(): + self._three_phase_suffix_t_() + + @tatsumasu() + def _three_phase_suffix_t_(self): # noqa + self._Dash_() + self._two_digit_number_() + self.name_last_node('current_per_phase_over_ten') + self._two_digit_number_() + self.name_last_node('leads') + self._shafts_count_marker_opt_our_() + self.name_last_node('shafts_count') + self._define( + ['current_per_phase_over_ten', 'leads', 'shafts_count'], + [] + ) + + @tatsumasu() + def _stepper_suffix_t_(self): # noqa + self._Dash_() + self._suffix_with_or_without_tail_() + self.name_last_node('suffix_body') + self._define( + ['suffix_body'], + [] + ) + + @tatsumasu() + def _suffix_with_or_without_tail_(self): # noqa + with self._choice(): + with self._option(): + self._suffix_with_current_() + self.name_last_node('with_current') + self._define( + ['with_current'], + [] + ) + with self._option(): + self._stepper_suffix_tail_() + self.name_last_node('without_current') + self._define( + ['without_current'], + [] + ) + self._error( + 'expecting one of: ' + ' ' + '' + '' + ) + self._define( + ['with_current', 'without_current'], + [] + ) + + @tatsumasu() + def _suffix_with_current_(self): # noqa + self._three_digit_number_() + self.name_last_node('current') + self._stepper_suffix_tail_() + self.name_last_node('tail') + self._define( + ['current', 'tail'], + [] + ) + + @tatsumasu() + def _double_step_rate_marker_(self): # noqa + with self._optional(): + self._M_() + + @tatsumasu() + def _encoder_presence_marker_(self): # noqa + with self._optional(): + self._E_() + + @tatsumasu() + def _unknown_marker_F_(self): # noqa + with self._optional(): + self._F_() + + @tatsumasu() + def _keyway_marker_(self): # noqa + with self._optional(): + self._K_() + + @tatsumasu() + def _screwed_shaft_marker_(self): # noqa + with self._optional(): + self._C_() + + @tatsumasu() + def _gearbox_specifier_opt_our_(self): # noqa + with self._optional(): + self._gearbox_specifier_() + + @tatsumasu() + def _hollow_specifier_opt_our_(self): # noqa + with self._optional(): + self._hollow_specifier_() + + @tatsumasu() + def _shafts_count_marker_opt_our_(self): # noqa + with self._optional(): + self._shafts_count_marker_() + + @tatsumasu() + def _shafts_count_and_step_rate_any_order_1_t_(self): # noqa + self._shafts_count_marker_opt_our_() + self.name_last_node('shafts_count') + self._double_step_rate_marker_() + self.name_last_node('step_rate') + self._define( + ['shafts_count', 'step_rate'], + [] + ) + + @tatsumasu() + def _shafts_count_and_step_rate_any_order_2_t_(self): # noqa + self._double_step_rate_marker_() + self.name_last_node('step_rate') + self._shafts_count_marker_opt_our_() + self.name_last_node('shafts_count') + self._define( + ['shafts_count', 'step_rate'], + [] + ) + + @tatsumasu() + def _shafts_count_and_step_rate_any_order_t_(self): # noqa + with self._choice(): + with self._option(): + self._shafts_count_and_step_rate_any_order_1_t_() + self.name_last_node('shafts_count_and_step_rate_any_order_1') + self._define( + ['shafts_count_and_step_rate_any_order_1'], + [] + ) + with self._option(): + self._shafts_count_and_step_rate_any_order_2_t_() + self.name_last_node('shafts_count_and_step_rate_any_order_2') + self._define( + ['shafts_count_and_step_rate_any_order_2'], + [] + ) + self._error( + 'expecting one of: ' + ' ' + ' ' + '' + ) + self._define( + ['shafts_count_and_step_rate_any_order_1', 'shafts_count_and_step_rate_any_order_2'], + [] + ) + + @tatsumasu() + def _stepper_suffix_tail_(self): # noqa + self._digit_() + self.name_last_node('variant') + self._shafts_count_and_step_rate_any_order_t_() + self.name_last_node('shafts_count_and_step_rate_any_order') + self._encoder_presence_marker_() + self.name_last_node('encoder') + self._unknown_marker_F_() + self.name_last_node('unknown_F') + self._keyway_marker_() + self.name_last_node('key_way') + self._screwed_shaft_marker_() + self.name_last_node('screwed_shaft') + self._gearbox_specifier_opt_our_() + self.name_last_node('gearbox') + self._hollow_specifier_opt_our_() + self.name_last_node('hollow') + self._define( + ['encoder', 'gearbox', 'hollow', 'key_way', 'screwed_shaft', 'shafts_count_and_step_rate_any_order', 'unknown_F', 'variant'], + [] + ) + + @tatsumasu() + def _stepper_modifiers_opt_our_(self): # noqa + with self._optional(): + self._stepper_modifiers_t_() + + @tatsumasu() + def _stepper_t_(self): # noqa + self._stepper_marker_() + self.name_last_node('type_marker') + self._stepper_modifiers_opt_our_() + self.name_last_node('stepper_modifiers') + self._two_or_three_digit_number_() + self.name_last_node('motor_body_length') + self._stepper_suffix_t_() + self.name_last_node('suffix') + self._define( + ['motor_body_length', 'stepper_modifiers', 'suffix', 'type_marker'], + [] + ) + + @tatsumasu() + def _stepper_series_opt_our_(self): # noqa + with self._optional(): + self._stepper_series_() + + @tatsumasu() + def _stepper_marker_(self): # noqa + self._S_() + self._stepper_series_opt_our_() + self.name_last_node('series') + self._define( + ['series'], + [] + ) + + @tatsumasu() + def _permanent_t_(self): # noqa + self._permanent_marker_() + self.name_last_node('type_marker') + self._two_digit_number_() + self.name_last_node('motor_body_length') + self._stepper_suffix_t_() + self.name_last_node('suffix') + self._define( + ['motor_body_length', 'suffix', 'type_marker'], + [] + ) + + @tatsumasu() + def _brushless_marker_(self): # noqa + self._price_performance_or_unknown_C_marker_() + self.name_last_node('is_price_performance') + self._rounded_marker_() + self.name_last_node('is_round') + self._brushless_marker_base_() + self._brushless_flat_marker_() + self.name_last_node('is_flat') + self._square_marker_() + self.name_last_node('is_square') + self._price_performance_or_unknown_C_marker_() + self.name_last_node('is_unknown_C') + self._define( + ['is_flat', 'is_price_performance', 'is_round', 'is_square', 'is_unknown_C'], + [] + ) + + @tatsumasu() + def _execution_configuration_t_(self): # noqa + self._Dash_() + self._any_integer_() + self.name_last_node('number') + self._electrical_unit_() + self.name_last_node('unit') + self._define( + ['number', 'unit'], + [] + ) + + @tatsumasu() + def _brushless_modifier_variants_(self): # noqa + with self._choice(): + with self._option(): + self._brushless_modifier_poles_torque_() + self.name_last_node('poles_torque') + self._define( + ['poles_torque'], + [] + ) + with self._option(): + self._brushless_modifier_length_electronics_electrics_() + self.name_last_node('length_electronics_electrics') + self._define( + ['length_electronics_electrics'], + [] + ) + self._error( + 'expecting one of: ' + '' + '' + '' + '' + ) + self._define( + ['length_electronics_electrics', 'poles_torque'], + [] + ) + + @tatsumasu() + def _brushless_modifier_poles_torque_(self): # noqa + self._brushless_modifier_poles_torque_letter_() + self.name_last_node('poles_or_other') + self._two_digit_number_() + self.name_last_node('variant') + self._define( + ['poles_or_other', 'variant'], + [] + ) + + @tatsumasu() + def _brushless_modifier_length_electronics_electrics_(self): # noqa + self._two_or_three_digit_number_() + self.name_last_node('motor_body_length') + self._brushless_tail_opt_our_() + self.name_last_node('tail') + self._define( + ['motor_body_length', 'tail'], + [] + ) + + @tatsumasu() + def _brushless_tail_opt_our_(self): # noqa + with self._optional(): + self._brushless_tail_() + + @tatsumasu() + def _brushless_t_(self): # noqa + self._brushless_marker_() + self.name_last_node('type_marker') + self._brushless_modifier_variants_() + self.name_last_node('modifier') + self._define( + ['modifier', 'type_marker'], + [] + ) + + @tatsumasu() + def _brushless_tail_(self): # noqa + with self._choice(): + with self._option(): + self._brushless_electronic_tail_() + self.name_last_node('electronic') + self._define( + ['electronic'], + [] + ) + with self._option(): + self._execution_configuration_t_() + self.name_last_node('no_electronic') + self._define( + ['no_electronic'], + [] + ) + self._error( + 'expecting one of: ' + ' ' + '' + ' [–-]' + ) + self._define( + ['electronic', 'no_electronic'], + [] + ) + + @tatsumasu() + def _execution_configuration_opt_our_(self): # noqa + with self._optional(): + self._execution_configuration_t_() + + @tatsumasu() + def _brushless_electronic_tail_(self): # noqa + self._integrated_electronic_marker_() + self.name_last_node('has_electronics') + self._execution_configuration_opt_our_() + self.name_last_node('cfg') + self._define( + ['cfg', 'has_electronics'], + [] + ) + + @tatsumasu() + def _digit_(self): # noqa + with self._choice(): + with self._option(): + self._RestOfDigits_() + with self._option(): + self._Three_() + self._error( + 'expecting one of: ' + "'3' [0-24-9]" + ) + + @tatsumasu() + def _square_marker_(self): # noqa + with self._optional(): + self._S_() + + @tatsumasu() + def _stepper_series_(self): # noqa + with self._choice(): + with self._option(): + self._T_() + self.name_last_node('standard') + self._define( + ['standard'], + [] + ) + with self._option(): + self._H_() + self.name_last_node('hybrid') + self._define( + ['hybrid'], + [] + ) + self._error( + 'expecting one of: ' + "'H' 'T'" + ) + self._define( + ['hybrid', 'standard'], + [] + ) + + @tatsumasu() + def _stepper_modifiers_t_(self): # noqa + with self._group(): + with self._choice(): + with self._option(): + self._H_() + with self._option(): + self._C_() + self._error( + 'expecting one of: ' + "'C' 'H'" + ) + self.name_last_node('stepper_modifiers') + self._define( + ['stepper_modifiers'], + [] + ) + + @tatsumasu() + def _price_performance_or_unknown_C_marker_(self): # noqa + with self._optional(): + self._C_() + + @tatsumasu() + def _electrical_unit_(self): # noqa + with self._choice(): + with self._option(): + self._A_() + with self._option(): + self._V_() + self._error( + 'expecting one of: ' + "'A' 'V'" + ) + + @tatsumasu() + def _shafts_count_marker_(self): # noqa + with self._choice(): + with self._option(): + self._A_() + with self._option(): + self._B_() + self._error( + 'expecting one of: ' + "'A' 'B'" + ) + + @tatsumasu() + def _one_or_two_digit_number_(self): # noqa + self._digit_() + with self._optional(): + self._digit_() + + @tatsumasu() + def _two_digit_number_(self): # noqa + self._digit_() + self._digit_() + + @tatsumasu() + def _three_digit_number_(self): # noqa + self._two_digit_number_() + self._digit_() + + @tatsumasu() + def _two_or_three_digit_number_(self): # noqa + self._two_digit_number_() + with self._optional(): + self._digit_() + + @tatsumasu() + def _any_integer_(self): # noqa + + def block0(): + self._digit_() + self._positive_closure(block0) + + @tatsumasu() + def _fractional_part_(self): # noqa + self._dot_() + with self._optional(): + self._any_integer_() + + @tatsumasu() + def _float_number_(self): # noqa + self._any_integer_() + with self._optional(): + self._fractional_part_() + + @tatsumasu() + def _integrated_electronic_marker_(self): # noqa + self._Dash_() + self._I_() + self._E_() + + @tatsumasu() + def _brushless_modifier_poles_torque_letter_(self): # noqa + with self._choice(): + with self._option(): + self._A_() + with self._option(): + self._B_() + self._error( + 'expecting one of: ' + "'A' 'B'" + ) + + @tatsumasu() + def _three_phase_marker_(self): # noqa + self._Three_() + self._P_() + + @tatsumasu() + def _hollow_specifier_(self): # noqa + self._Dash_() + self._H_() + + @tatsumasu() + def _Three_(self): # noqa + self._token('3') + + @tatsumasu() + def _RestOfDigits_(self): # noqa + self._pattern('[0-24-9]') + + @tatsumasu() + def _Dash_(self): # noqa + self._pattern('[–-]') + + @tatsumasu() + def _dot_(self): # noqa + self._token('.') + + @tatsumasu() + def _A_(self): # noqa + self._token('A') + + @tatsumasu() + def _B_(self): # noqa + self._token('B') + + @tatsumasu() + def _C_(self): # noqa + self._token('C') + + @tatsumasu() + def _E_(self): # noqa + self._token('E') + + @tatsumasu() + def _F_(self): # noqa + self._token('F') + + @tatsumasu() + def _G_(self): # noqa + self._token('G') + + @tatsumasu() + def _H_(self): # noqa + self._token('H') + + @tatsumasu() + def _I_(self): # noqa + self._token('I') + + @tatsumasu() + def _K_(self): # noqa + self._token('K') + + @tatsumasu() + def _L_(self): # noqa + self._token('L') + + @tatsumasu() + def _M_(self): # noqa + self._token('M') + + @tatsumasu() + def _P_(self): # noqa + self._token('P') + + @tatsumasu() + def _R_(self): # noqa + self._token('R') + + @tatsumasu() + def _S_(self): # noqa + self._token('S') + + @tatsumasu() + def _T_(self): # noqa + self._token('T') + + @tatsumasu() + def _V_(self): # noqa + self._token('V') + + @tatsumasu() + def _W_(self): # noqa + self._token('W') + + @tatsumasu() + def _fl_(self): # noqa + self._F_() + self._L_() + + @tatsumasu() + def _permanent_marker_(self): # noqa + self._P_() + self._M_() + + @tatsumasu() + def _brushless_marker_base_(self): # noqa + self._B_() + self._L_() + + @tatsumasu() + def _rounded_marker_(self): # noqa + with self._optional(): + self._R_() + + @tatsumasu() + def _brushless_flat_marker_(self): # noqa + with self._optional(): + self._W_() + + +class fulling_motor_nameSemantics: + def main(self, ast): # noqa + return ast + + def gearbox_specifier(self, ast): # noqa + return ast + + def type_specific(self, ast): # noqa + return ast + + def three_phase_t(self, ast): # noqa + return ast + + def three_phase_suffix_opt_our(self, ast): # noqa + return ast + + def three_phase_suffix_t(self, ast): # noqa + return ast + + def stepper_suffix_t(self, ast): # noqa + return ast + + def suffix_with_or_without_tail(self, ast): # noqa + return ast + + def suffix_with_current(self, ast): # noqa + return ast + + def double_step_rate_marker(self, ast): # noqa + return ast + + def encoder_presence_marker(self, ast): # noqa + return ast + + def unknown_marker_F(self, ast): # noqa + return ast + + def keyway_marker(self, ast): # noqa + return ast + + def screwed_shaft_marker(self, ast): # noqa + return ast + + def gearbox_specifier_opt_our(self, ast): # noqa + return ast + + def hollow_specifier_opt_our(self, ast): # noqa + return ast + + def shafts_count_marker_opt_our(self, ast): # noqa + return ast + + def shafts_count_and_step_rate_any_order_1_t(self, ast): # noqa + return ast + + def shafts_count_and_step_rate_any_order_2_t(self, ast): # noqa + return ast + + def shafts_count_and_step_rate_any_order_t(self, ast): # noqa + return ast + + def stepper_suffix_tail(self, ast): # noqa + return ast + + def stepper_modifiers_opt_our(self, ast): # noqa + return ast + + def stepper_t(self, ast): # noqa + return ast + + def stepper_series_opt_our(self, ast): # noqa + return ast + + def stepper_marker(self, ast): # noqa + return ast + + def permanent_t(self, ast): # noqa + return ast + + def brushless_marker(self, ast): # noqa + return ast + + def execution_configuration_t(self, ast): # noqa + return ast + + def brushless_modifier_variants(self, ast): # noqa + return ast + + def brushless_modifier_poles_torque(self, ast): # noqa + return ast + + def brushless_modifier_length_electronics_electrics(self, ast): # noqa + return ast + + def brushless_tail_opt_our(self, ast): # noqa + return ast + + def brushless_t(self, ast): # noqa + return ast + + def brushless_tail(self, ast): # noqa + return ast + + def execution_configuration_opt_our(self, ast): # noqa + return ast + + def brushless_electronic_tail(self, ast): # noqa + return ast + + def digit(self, ast): # noqa + return ast + + def square_marker(self, ast): # noqa + return ast + + def stepper_series(self, ast): # noqa + return ast + + def stepper_modifiers_t(self, ast): # noqa + return ast + + def price_performance_or_unknown_C_marker(self, ast): # noqa + return ast + + def electrical_unit(self, ast): # noqa + return ast + + def shafts_count_marker(self, ast): # noqa + return ast + + def one_or_two_digit_number(self, ast): # noqa + return ast + + def two_digit_number(self, ast): # noqa + return ast + + def three_digit_number(self, ast): # noqa + return ast + + def two_or_three_digit_number(self, ast): # noqa + return ast + + def any_integer(self, ast): # noqa + return ast + + def fractional_part(self, ast): # noqa + return ast + + def float_number(self, ast): # noqa + return ast + + def integrated_electronic_marker(self, ast): # noqa + return ast + + def brushless_modifier_poles_torque_letter(self, ast): # noqa + return ast + + def three_phase_marker(self, ast): # noqa + return ast + + def hollow_specifier(self, ast): # noqa + return ast + + def Three(self, ast): # noqa + return ast + + def RestOfDigits(self, ast): # noqa + return ast + + def Dash(self, ast): # noqa + return ast + + def dot(self, ast): # noqa + return ast + + def A(self, ast): # noqa + return ast + + def B(self, ast): # noqa + return ast + + def C(self, ast): # noqa + return ast + + def E(self, ast): # noqa + return ast + + def F(self, ast): # noqa + return ast + + def G(self, ast): # noqa + return ast + + def H(self, ast): # noqa + return ast + + def I(self, ast): # noqa + return ast + + def K(self, ast): # noqa + return ast + + def L(self, ast): # noqa + return ast + + def M(self, ast): # noqa + return ast + + def P(self, ast): # noqa + return ast + + def R(self, ast): # noqa + return ast + + def S(self, ast): # noqa + return ast + + def T(self, ast): # noqa + return ast + + def V(self, ast): # noqa + return ast + + def W(self, ast): # noqa + return ast + + def fl(self, ast): # noqa + return ast + + def permanent_marker(self, ast): # noqa + return ast + + def brushless_marker_base(self, ast): # noqa + return ast + + def rounded_marker(self, ast): # noqa + return ast + + def brushless_flat_marker(self, ast): # noqa + return ast + + +def main(filename, start=None, **kwargs): + if start is None: + start = 'main' + if not filename or filename == '-': + text = sys.stdin.read() + else: + with open(filename) as f: + text = f.read() + parser = fulling_motor_nameParser() + return parser.parse( + text, + rule_name=start, + filename=filename, + **kwargs + ) + + +if __name__ == '__main__': + import json + from tatsu.util import asjson + + ast = generic_main(main, fulling_motor_nameParser, name='fulling_motor_name') + data = asjson(ast) + print(json.dumps(data, indent=2)) diff --git a/FullingMotorModelDecoder/parserBundle/compiled/__init__.py b/FullingMotorModelDecoder/parserBundle/compiled/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/compiled/antlr4/__init__.py b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.interp b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.interp new file mode 100644 index 0000000..c6fc2d2 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.interp @@ -0,0 +1,80 @@ +token literal names: +null +'.' +'3' +null +null +'A' +'B' +'C' +'E' +'F' +'G' +'H' +'I' +'K' +'L' +'M' +'P' +'R' +'S' +'T' +'V' +'W' + +token symbolic names: +null +null +Three +RestOfDigits +Dash +A +B +C +E +F +G +H +I +K +L +M +P +R +S +T +V +W + +rule names: +T__0 +Three +RestOfDigits +Dash +A +B +C +E +F +G +H +I +K +L +M +P +R +S +T +V +W + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 21, 85, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 0, 0, 21, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 1, 0, 2, 2, 0, 48, 50, 52, 57, 2, 0, 45, 45, 8211, 8211, 84, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 1, 43, 1, 0, 0, 0, 3, 45, 1, 0, 0, 0, 5, 47, 1, 0, 0, 0, 7, 49, 1, 0, 0, 0, 9, 51, 1, 0, 0, 0, 11, 53, 1, 0, 0, 0, 13, 55, 1, 0, 0, 0, 15, 57, 1, 0, 0, 0, 17, 59, 1, 0, 0, 0, 19, 61, 1, 0, 0, 0, 21, 63, 1, 0, 0, 0, 23, 65, 1, 0, 0, 0, 25, 67, 1, 0, 0, 0, 27, 69, 1, 0, 0, 0, 29, 71, 1, 0, 0, 0, 31, 73, 1, 0, 0, 0, 33, 75, 1, 0, 0, 0, 35, 77, 1, 0, 0, 0, 37, 79, 1, 0, 0, 0, 39, 81, 1, 0, 0, 0, 41, 83, 1, 0, 0, 0, 43, 44, 5, 46, 0, 0, 44, 2, 1, 0, 0, 0, 45, 46, 5, 51, 0, 0, 46, 4, 1, 0, 0, 0, 47, 48, 7, 0, 0, 0, 48, 6, 1, 0, 0, 0, 49, 50, 7, 1, 0, 0, 50, 8, 1, 0, 0, 0, 51, 52, 5, 65, 0, 0, 52, 10, 1, 0, 0, 0, 53, 54, 5, 66, 0, 0, 54, 12, 1, 0, 0, 0, 55, 56, 5, 67, 0, 0, 56, 14, 1, 0, 0, 0, 57, 58, 5, 69, 0, 0, 58, 16, 1, 0, 0, 0, 59, 60, 5, 70, 0, 0, 60, 18, 1, 0, 0, 0, 61, 62, 5, 71, 0, 0, 62, 20, 1, 0, 0, 0, 63, 64, 5, 72, 0, 0, 64, 22, 1, 0, 0, 0, 65, 66, 5, 73, 0, 0, 66, 24, 1, 0, 0, 0, 67, 68, 5, 75, 0, 0, 68, 26, 1, 0, 0, 0, 69, 70, 5, 76, 0, 0, 70, 28, 1, 0, 0, 0, 71, 72, 5, 77, 0, 0, 72, 30, 1, 0, 0, 0, 73, 74, 5, 80, 0, 0, 74, 32, 1, 0, 0, 0, 75, 76, 5, 82, 0, 0, 76, 34, 1, 0, 0, 0, 77, 78, 5, 83, 0, 0, 78, 36, 1, 0, 0, 0, 79, 80, 5, 84, 0, 0, 80, 38, 1, 0, 0, 0, 81, 82, 5, 86, 0, 0, 82, 40, 1, 0, 0, 0, 83, 84, 5, 87, 0, 0, 84, 42, 1, 0, 0, 0, 1, 0, 0] \ No newline at end of file diff --git a/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.py b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.py new file mode 100644 index 0000000..1035745 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.py @@ -0,0 +1,96 @@ +# Generated from grammar.g4 by ANTLR 4.12.0 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + return [ + 4,0,21,85,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2, + 6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13, + 7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19, + 2,20,7,20,1,0,1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,4,1,4,1,5,1,5,1,6,1, + 6,1,7,1,7,1,8,1,8,1,9,1,9,1,10,1,10,1,11,1,11,1,12,1,12,1,13,1,13, + 1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,18,1,18,1,19,1,19,1,20, + 1,20,0,0,21,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11, + 23,12,25,13,27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,1,0, + 2,2,0,48,50,52,57,2,0,45,45,8211,8211,84,0,1,1,0,0,0,0,3,1,0,0,0, + 0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0, + 15,1,0,0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0, + 25,1,0,0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0, + 35,1,0,0,0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,1,43,1,0,0,0,3, + 45,1,0,0,0,5,47,1,0,0,0,7,49,1,0,0,0,9,51,1,0,0,0,11,53,1,0,0,0, + 13,55,1,0,0,0,15,57,1,0,0,0,17,59,1,0,0,0,19,61,1,0,0,0,21,63,1, + 0,0,0,23,65,1,0,0,0,25,67,1,0,0,0,27,69,1,0,0,0,29,71,1,0,0,0,31, + 73,1,0,0,0,33,75,1,0,0,0,35,77,1,0,0,0,37,79,1,0,0,0,39,81,1,0,0, + 0,41,83,1,0,0,0,43,44,5,46,0,0,44,2,1,0,0,0,45,46,5,51,0,0,46,4, + 1,0,0,0,47,48,7,0,0,0,48,6,1,0,0,0,49,50,7,1,0,0,50,8,1,0,0,0,51, + 52,5,65,0,0,52,10,1,0,0,0,53,54,5,66,0,0,54,12,1,0,0,0,55,56,5,67, + 0,0,56,14,1,0,0,0,57,58,5,69,0,0,58,16,1,0,0,0,59,60,5,70,0,0,60, + 18,1,0,0,0,61,62,5,71,0,0,62,20,1,0,0,0,63,64,5,72,0,0,64,22,1,0, + 0,0,65,66,5,73,0,0,66,24,1,0,0,0,67,68,5,75,0,0,68,26,1,0,0,0,69, + 70,5,76,0,0,70,28,1,0,0,0,71,72,5,77,0,0,72,30,1,0,0,0,73,74,5,80, + 0,0,74,32,1,0,0,0,75,76,5,82,0,0,76,34,1,0,0,0,77,78,5,83,0,0,78, + 36,1,0,0,0,79,80,5,84,0,0,80,38,1,0,0,0,81,82,5,86,0,0,82,40,1,0, + 0,0,83,84,5,87,0,0,84,42,1,0,0,0,1,0,0 + ] + +class fulling_motor_nameLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + T__0 = 1 + Three = 2 + RestOfDigits = 3 + Dash = 4 + A = 5 + B = 6 + C = 7 + E = 8 + F = 9 + G = 10 + H = 11 + I = 12 + K = 13 + L = 14 + M = 15 + P = 16 + R = 17 + S = 18 + T = 19 + V = 20 + W = 21 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "'.'", "'3'", "'A'", "'B'", "'C'", "'E'", "'F'", "'G'", "'H'", + "'I'", "'K'", "'L'", "'M'", "'P'", "'R'", "'S'", "'T'", "'V'", + "'W'" ] + + symbolicNames = [ "", + "Three", "RestOfDigits", "Dash", "A", "B", "C", "E", "F", "G", + "H", "I", "K", "L", "M", "P", "R", "S", "T", "V", "W" ] + + ruleNames = [ "T__0", "Three", "RestOfDigits", "Dash", "A", "B", "C", + "E", "F", "G", "H", "I", "K", "L", "M", "P", "R", "S", + "T", "V", "W" ] + + grammarFileName = "grammar.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.12.0") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.tokens b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.tokens new file mode 100644 index 0000000..51cd124 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameLexer.tokens @@ -0,0 +1,40 @@ +T__0=1 +Three=2 +RestOfDigits=3 +Dash=4 +A=5 +B=6 +C=7 +E=8 +F=9 +G=10 +H=11 +I=12 +K=13 +L=14 +M=15 +P=16 +R=17 +S=18 +T=19 +V=20 +W=21 +'.'=1 +'3'=2 +'A'=5 +'B'=6 +'C'=7 +'E'=8 +'F'=9 +'G'=10 +'H'=11 +'I'=12 +'K'=13 +'L'=14 +'M'=15 +'P'=16 +'R'=17 +'S'=18 +'T'=19 +'V'=20 +'W'=21 diff --git a/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameListener.py b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameListener.py new file mode 100644 index 0000000..f7ae40a --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameListener.py @@ -0,0 +1,552 @@ +# Generated from grammar.g4 by ANTLR 4.12.0 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .fulling_motor_nameParser import fulling_motor_nameParser +else: + from fulling_motor_nameParser import fulling_motor_nameParser + +# This class defines a complete listener for a parse tree produced by fulling_motor_nameParser. +class fulling_motor_nameListener(ParseTreeListener): + + # Enter a parse tree produced by fulling_motor_nameParser#main. + def enterMain(self, ctx:fulling_motor_nameParser.MainContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#main. + def exitMain(self, ctx:fulling_motor_nameParser.MainContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#gearbox_specifier. + def enterGearbox_specifier(self, ctx:fulling_motor_nameParser.Gearbox_specifierContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#gearbox_specifier. + def exitGearbox_specifier(self, ctx:fulling_motor_nameParser.Gearbox_specifierContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#type_specific. + def enterType_specific(self, ctx:fulling_motor_nameParser.Type_specificContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#type_specific. + def exitType_specific(self, ctx:fulling_motor_nameParser.Type_specificContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#three_phase_t. + def enterThree_phase_t(self, ctx:fulling_motor_nameParser.Three_phase_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#three_phase_t. + def exitThree_phase_t(self, ctx:fulling_motor_nameParser.Three_phase_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#three_phase_suffix_opt_our. + def enterThree_phase_suffix_opt_our(self, ctx:fulling_motor_nameParser.Three_phase_suffix_opt_ourContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#three_phase_suffix_opt_our. + def exitThree_phase_suffix_opt_our(self, ctx:fulling_motor_nameParser.Three_phase_suffix_opt_ourContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#three_phase_suffix_t. + def enterThree_phase_suffix_t(self, ctx:fulling_motor_nameParser.Three_phase_suffix_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#three_phase_suffix_t. + def exitThree_phase_suffix_t(self, ctx:fulling_motor_nameParser.Three_phase_suffix_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#stepper_suffix_t. + def enterStepper_suffix_t(self, ctx:fulling_motor_nameParser.Stepper_suffix_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#stepper_suffix_t. + def exitStepper_suffix_t(self, ctx:fulling_motor_nameParser.Stepper_suffix_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#suffix_with_or_without_tail. + def enterSuffix_with_or_without_tail(self, ctx:fulling_motor_nameParser.Suffix_with_or_without_tailContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#suffix_with_or_without_tail. + def exitSuffix_with_or_without_tail(self, ctx:fulling_motor_nameParser.Suffix_with_or_without_tailContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#suffix_with_current. + def enterSuffix_with_current(self, ctx:fulling_motor_nameParser.Suffix_with_currentContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#suffix_with_current. + def exitSuffix_with_current(self, ctx:fulling_motor_nameParser.Suffix_with_currentContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#double_step_rate_marker. + def enterDouble_step_rate_marker(self, ctx:fulling_motor_nameParser.Double_step_rate_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#double_step_rate_marker. + def exitDouble_step_rate_marker(self, ctx:fulling_motor_nameParser.Double_step_rate_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#encoder_presence_marker. + def enterEncoder_presence_marker(self, ctx:fulling_motor_nameParser.Encoder_presence_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#encoder_presence_marker. + def exitEncoder_presence_marker(self, ctx:fulling_motor_nameParser.Encoder_presence_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#unknown_marker_F. + def enterUnknown_marker_F(self, ctx:fulling_motor_nameParser.Unknown_marker_FContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#unknown_marker_F. + def exitUnknown_marker_F(self, ctx:fulling_motor_nameParser.Unknown_marker_FContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#keyway_marker. + def enterKeyway_marker(self, ctx:fulling_motor_nameParser.Keyway_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#keyway_marker. + def exitKeyway_marker(self, ctx:fulling_motor_nameParser.Keyway_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#screwed_shaft_marker. + def enterScrewed_shaft_marker(self, ctx:fulling_motor_nameParser.Screwed_shaft_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#screwed_shaft_marker. + def exitScrewed_shaft_marker(self, ctx:fulling_motor_nameParser.Screwed_shaft_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#gearbox_specifier_opt_our. + def enterGearbox_specifier_opt_our(self, ctx:fulling_motor_nameParser.Gearbox_specifier_opt_ourContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#gearbox_specifier_opt_our. + def exitGearbox_specifier_opt_our(self, ctx:fulling_motor_nameParser.Gearbox_specifier_opt_ourContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#hollow_specifier_opt_our. + def enterHollow_specifier_opt_our(self, ctx:fulling_motor_nameParser.Hollow_specifier_opt_ourContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#hollow_specifier_opt_our. + def exitHollow_specifier_opt_our(self, ctx:fulling_motor_nameParser.Hollow_specifier_opt_ourContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#shafts_count_marker_opt_our. + def enterShafts_count_marker_opt_our(self, ctx:fulling_motor_nameParser.Shafts_count_marker_opt_ourContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#shafts_count_marker_opt_our. + def exitShafts_count_marker_opt_our(self, ctx:fulling_motor_nameParser.Shafts_count_marker_opt_ourContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#shafts_count_and_step_rate_any_order_1_t. + def enterShafts_count_and_step_rate_any_order_1_t(self, ctx:fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_1_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#shafts_count_and_step_rate_any_order_1_t. + def exitShafts_count_and_step_rate_any_order_1_t(self, ctx:fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_1_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#shafts_count_and_step_rate_any_order_2_t. + def enterShafts_count_and_step_rate_any_order_2_t(self, ctx:fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_2_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#shafts_count_and_step_rate_any_order_2_t. + def exitShafts_count_and_step_rate_any_order_2_t(self, ctx:fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_2_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#shafts_count_and_step_rate_any_order_t. + def enterShafts_count_and_step_rate_any_order_t(self, ctx:fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#shafts_count_and_step_rate_any_order_t. + def exitShafts_count_and_step_rate_any_order_t(self, ctx:fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#stepper_suffix_tail. + def enterStepper_suffix_tail(self, ctx:fulling_motor_nameParser.Stepper_suffix_tailContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#stepper_suffix_tail. + def exitStepper_suffix_tail(self, ctx:fulling_motor_nameParser.Stepper_suffix_tailContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#stepper_modifiers_opt_our. + def enterStepper_modifiers_opt_our(self, ctx:fulling_motor_nameParser.Stepper_modifiers_opt_ourContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#stepper_modifiers_opt_our. + def exitStepper_modifiers_opt_our(self, ctx:fulling_motor_nameParser.Stepper_modifiers_opt_ourContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#stepper_t. + def enterStepper_t(self, ctx:fulling_motor_nameParser.Stepper_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#stepper_t. + def exitStepper_t(self, ctx:fulling_motor_nameParser.Stepper_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#stepper_series_opt_our. + def enterStepper_series_opt_our(self, ctx:fulling_motor_nameParser.Stepper_series_opt_ourContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#stepper_series_opt_our. + def exitStepper_series_opt_our(self, ctx:fulling_motor_nameParser.Stepper_series_opt_ourContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#stepper_marker. + def enterStepper_marker(self, ctx:fulling_motor_nameParser.Stepper_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#stepper_marker. + def exitStepper_marker(self, ctx:fulling_motor_nameParser.Stepper_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#permanent_t. + def enterPermanent_t(self, ctx:fulling_motor_nameParser.Permanent_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#permanent_t. + def exitPermanent_t(self, ctx:fulling_motor_nameParser.Permanent_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_marker. + def enterBrushless_marker(self, ctx:fulling_motor_nameParser.Brushless_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_marker. + def exitBrushless_marker(self, ctx:fulling_motor_nameParser.Brushless_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#execution_configuration_t. + def enterExecution_configuration_t(self, ctx:fulling_motor_nameParser.Execution_configuration_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#execution_configuration_t. + def exitExecution_configuration_t(self, ctx:fulling_motor_nameParser.Execution_configuration_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_modifier_variants. + def enterBrushless_modifier_variants(self, ctx:fulling_motor_nameParser.Brushless_modifier_variantsContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_modifier_variants. + def exitBrushless_modifier_variants(self, ctx:fulling_motor_nameParser.Brushless_modifier_variantsContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_modifier_poles_torque. + def enterBrushless_modifier_poles_torque(self, ctx:fulling_motor_nameParser.Brushless_modifier_poles_torqueContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_modifier_poles_torque. + def exitBrushless_modifier_poles_torque(self, ctx:fulling_motor_nameParser.Brushless_modifier_poles_torqueContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_modifier_length_electronics_electrics. + def enterBrushless_modifier_length_electronics_electrics(self, ctx:fulling_motor_nameParser.Brushless_modifier_length_electronics_electricsContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_modifier_length_electronics_electrics. + def exitBrushless_modifier_length_electronics_electrics(self, ctx:fulling_motor_nameParser.Brushless_modifier_length_electronics_electricsContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_tail_opt_our. + def enterBrushless_tail_opt_our(self, ctx:fulling_motor_nameParser.Brushless_tail_opt_ourContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_tail_opt_our. + def exitBrushless_tail_opt_our(self, ctx:fulling_motor_nameParser.Brushless_tail_opt_ourContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_t. + def enterBrushless_t(self, ctx:fulling_motor_nameParser.Brushless_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_t. + def exitBrushless_t(self, ctx:fulling_motor_nameParser.Brushless_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_tail. + def enterBrushless_tail(self, ctx:fulling_motor_nameParser.Brushless_tailContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_tail. + def exitBrushless_tail(self, ctx:fulling_motor_nameParser.Brushless_tailContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#execution_configuration_opt_our. + def enterExecution_configuration_opt_our(self, ctx:fulling_motor_nameParser.Execution_configuration_opt_ourContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#execution_configuration_opt_our. + def exitExecution_configuration_opt_our(self, ctx:fulling_motor_nameParser.Execution_configuration_opt_ourContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_electronic_tail. + def enterBrushless_electronic_tail(self, ctx:fulling_motor_nameParser.Brushless_electronic_tailContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_electronic_tail. + def exitBrushless_electronic_tail(self, ctx:fulling_motor_nameParser.Brushless_electronic_tailContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#digit. + def enterDigit(self, ctx:fulling_motor_nameParser.DigitContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#digit. + def exitDigit(self, ctx:fulling_motor_nameParser.DigitContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#square_marker. + def enterSquare_marker(self, ctx:fulling_motor_nameParser.Square_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#square_marker. + def exitSquare_marker(self, ctx:fulling_motor_nameParser.Square_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#stepper_series. + def enterStepper_series(self, ctx:fulling_motor_nameParser.Stepper_seriesContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#stepper_series. + def exitStepper_series(self, ctx:fulling_motor_nameParser.Stepper_seriesContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#stepper_modifiers_t. + def enterStepper_modifiers_t(self, ctx:fulling_motor_nameParser.Stepper_modifiers_tContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#stepper_modifiers_t. + def exitStepper_modifiers_t(self, ctx:fulling_motor_nameParser.Stepper_modifiers_tContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#price_performance_or_unknown_C_marker. + def enterPrice_performance_or_unknown_C_marker(self, ctx:fulling_motor_nameParser.Price_performance_or_unknown_C_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#price_performance_or_unknown_C_marker. + def exitPrice_performance_or_unknown_C_marker(self, ctx:fulling_motor_nameParser.Price_performance_or_unknown_C_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#electrical_unit. + def enterElectrical_unit(self, ctx:fulling_motor_nameParser.Electrical_unitContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#electrical_unit. + def exitElectrical_unit(self, ctx:fulling_motor_nameParser.Electrical_unitContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#shafts_count_marker. + def enterShafts_count_marker(self, ctx:fulling_motor_nameParser.Shafts_count_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#shafts_count_marker. + def exitShafts_count_marker(self, ctx:fulling_motor_nameParser.Shafts_count_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#one_or_two_digit_number. + def enterOne_or_two_digit_number(self, ctx:fulling_motor_nameParser.One_or_two_digit_numberContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#one_or_two_digit_number. + def exitOne_or_two_digit_number(self, ctx:fulling_motor_nameParser.One_or_two_digit_numberContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#two_digit_number. + def enterTwo_digit_number(self, ctx:fulling_motor_nameParser.Two_digit_numberContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#two_digit_number. + def exitTwo_digit_number(self, ctx:fulling_motor_nameParser.Two_digit_numberContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#three_digit_number. + def enterThree_digit_number(self, ctx:fulling_motor_nameParser.Three_digit_numberContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#three_digit_number. + def exitThree_digit_number(self, ctx:fulling_motor_nameParser.Three_digit_numberContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#two_or_three_digit_number. + def enterTwo_or_three_digit_number(self, ctx:fulling_motor_nameParser.Two_or_three_digit_numberContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#two_or_three_digit_number. + def exitTwo_or_three_digit_number(self, ctx:fulling_motor_nameParser.Two_or_three_digit_numberContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#any_integer. + def enterAny_integer(self, ctx:fulling_motor_nameParser.Any_integerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#any_integer. + def exitAny_integer(self, ctx:fulling_motor_nameParser.Any_integerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#fractional_part. + def enterFractional_part(self, ctx:fulling_motor_nameParser.Fractional_partContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#fractional_part. + def exitFractional_part(self, ctx:fulling_motor_nameParser.Fractional_partContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#float_number. + def enterFloat_number(self, ctx:fulling_motor_nameParser.Float_numberContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#float_number. + def exitFloat_number(self, ctx:fulling_motor_nameParser.Float_numberContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#integrated_electronic_marker. + def enterIntegrated_electronic_marker(self, ctx:fulling_motor_nameParser.Integrated_electronic_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#integrated_electronic_marker. + def exitIntegrated_electronic_marker(self, ctx:fulling_motor_nameParser.Integrated_electronic_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_modifier_poles_torque_letter. + def enterBrushless_modifier_poles_torque_letter(self, ctx:fulling_motor_nameParser.Brushless_modifier_poles_torque_letterContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_modifier_poles_torque_letter. + def exitBrushless_modifier_poles_torque_letter(self, ctx:fulling_motor_nameParser.Brushless_modifier_poles_torque_letterContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#three_phase_marker. + def enterThree_phase_marker(self, ctx:fulling_motor_nameParser.Three_phase_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#three_phase_marker. + def exitThree_phase_marker(self, ctx:fulling_motor_nameParser.Three_phase_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#hollow_specifier. + def enterHollow_specifier(self, ctx:fulling_motor_nameParser.Hollow_specifierContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#hollow_specifier. + def exitHollow_specifier(self, ctx:fulling_motor_nameParser.Hollow_specifierContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#fl. + def enterFl(self, ctx:fulling_motor_nameParser.FlContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#fl. + def exitFl(self, ctx:fulling_motor_nameParser.FlContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#permanent_marker. + def enterPermanent_marker(self, ctx:fulling_motor_nameParser.Permanent_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#permanent_marker. + def exitPermanent_marker(self, ctx:fulling_motor_nameParser.Permanent_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_marker_base. + def enterBrushless_marker_base(self, ctx:fulling_motor_nameParser.Brushless_marker_baseContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_marker_base. + def exitBrushless_marker_base(self, ctx:fulling_motor_nameParser.Brushless_marker_baseContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#rounded_marker. + def enterRounded_marker(self, ctx:fulling_motor_nameParser.Rounded_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#rounded_marker. + def exitRounded_marker(self, ctx:fulling_motor_nameParser.Rounded_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#brushless_flat_marker. + def enterBrushless_flat_marker(self, ctx:fulling_motor_nameParser.Brushless_flat_markerContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#brushless_flat_marker. + def exitBrushless_flat_marker(self, ctx:fulling_motor_nameParser.Brushless_flat_markerContext): + pass + + + # Enter a parse tree produced by fulling_motor_nameParser#dot. + def enterDot(self, ctx:fulling_motor_nameParser.DotContext): + pass + + # Exit a parse tree produced by fulling_motor_nameParser#dot. + def exitDot(self, ctx:fulling_motor_nameParser.DotContext): + pass + + + +del fulling_motor_nameParser \ No newline at end of file diff --git a/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameParser.py b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameParser.py new file mode 100644 index 0000000..f497f33 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/antlr4/fulling_motor_nameParser.py @@ -0,0 +1,3426 @@ +# Generated from grammar.g4 by ANTLR 4.12.0 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + +def serializedATN(): + return [ + 4,1,21,330,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, + 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13, + 2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20, + 7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26, + 2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33, + 7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39, + 2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46, + 7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,52, + 2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,59, + 7,59,1,0,3,0,122,8,0,1,0,1,0,1,0,1,1,1,1,1,1,1,2,1,2,1,2,1,2,3,2, + 134,8,2,1,3,1,3,1,3,1,3,1,4,3,4,141,8,4,1,5,1,5,1,5,1,5,1,5,1,6, + 1,6,1,6,1,7,1,7,3,7,153,8,7,1,8,1,8,1,8,1,9,3,9,159,8,9,1,10,3,10, + 162,8,10,1,11,3,11,165,8,11,1,12,3,12,168,8,12,1,13,3,13,171,8,13, + 1,14,3,14,174,8,14,1,15,3,15,177,8,15,1,16,3,16,180,8,16,1,17,1, + 17,1,17,1,18,1,18,1,18,1,19,1,19,3,19,190,8,19,1,20,1,20,1,20,1, + 20,1,20,1,20,1,20,1,20,1,20,1,21,3,21,202,8,21,1,22,1,22,1,22,1, + 22,1,22,1,23,3,23,210,8,23,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1, + 26,1,26,1,26,1,26,1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,28,1,28,3, + 28,232,8,28,1,29,1,29,1,29,1,30,1,30,1,30,1,31,3,31,241,8,31,1,32, + 1,32,1,32,1,33,1,33,3,33,248,8,33,1,34,3,34,251,8,34,1,35,1,35,1, + 35,1,36,1,36,1,37,3,37,259,8,37,1,38,1,38,3,38,263,8,38,1,39,1,39, + 1,40,3,40,268,8,40,1,41,1,41,1,42,1,42,1,43,1,43,3,43,276,8,43,1, + 44,1,44,1,44,1,45,1,45,1,45,1,46,1,46,3,46,286,8,46,1,47,4,47,289, + 8,47,11,47,12,47,290,1,48,1,48,3,48,295,8,48,1,49,1,49,3,49,299, + 8,49,1,50,1,50,1,50,1,50,1,51,1,51,1,52,1,52,1,52,1,53,1,53,1,53, + 1,54,1,54,1,54,1,55,1,55,1,55,1,56,1,56,1,56,1,57,3,57,323,8,57, + 1,58,3,58,326,8,58,1,59,1,59,1,59,0,0,60,0,2,4,6,8,10,12,14,16,18, + 20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62, + 64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104, + 106,108,110,112,114,116,118,0,4,1,0,2,3,2,0,7,7,11,11,2,0,5,5,20, + 20,1,0,5,6,300,0,121,1,0,0,0,2,126,1,0,0,0,4,133,1,0,0,0,6,135,1, + 0,0,0,8,140,1,0,0,0,10,142,1,0,0,0,12,147,1,0,0,0,14,152,1,0,0,0, + 16,154,1,0,0,0,18,158,1,0,0,0,20,161,1,0,0,0,22,164,1,0,0,0,24,167, + 1,0,0,0,26,170,1,0,0,0,28,173,1,0,0,0,30,176,1,0,0,0,32,179,1,0, + 0,0,34,181,1,0,0,0,36,184,1,0,0,0,38,189,1,0,0,0,40,191,1,0,0,0, + 42,201,1,0,0,0,44,203,1,0,0,0,46,209,1,0,0,0,48,211,1,0,0,0,50,214, + 1,0,0,0,52,218,1,0,0,0,54,225,1,0,0,0,56,231,1,0,0,0,58,233,1,0, + 0,0,60,236,1,0,0,0,62,240,1,0,0,0,64,242,1,0,0,0,66,247,1,0,0,0, + 68,250,1,0,0,0,70,252,1,0,0,0,72,255,1,0,0,0,74,258,1,0,0,0,76,262, + 1,0,0,0,78,264,1,0,0,0,80,267,1,0,0,0,82,269,1,0,0,0,84,271,1,0, + 0,0,86,273,1,0,0,0,88,277,1,0,0,0,90,280,1,0,0,0,92,283,1,0,0,0, + 94,288,1,0,0,0,96,292,1,0,0,0,98,296,1,0,0,0,100,300,1,0,0,0,102, + 304,1,0,0,0,104,306,1,0,0,0,106,309,1,0,0,0,108,312,1,0,0,0,110, + 315,1,0,0,0,112,318,1,0,0,0,114,322,1,0,0,0,116,325,1,0,0,0,118, + 327,1,0,0,0,120,122,3,108,54,0,121,120,1,0,0,0,121,122,1,0,0,0,122, + 123,1,0,0,0,123,124,3,92,46,0,124,125,3,4,2,0,125,1,1,0,0,0,126, + 127,5,10,0,0,127,128,3,98,49,0,128,3,1,0,0,0,129,134,3,44,22,0,130, + 134,3,50,25,0,131,134,3,64,32,0,132,134,3,6,3,0,133,129,1,0,0,0, + 133,130,1,0,0,0,133,131,1,0,0,0,133,132,1,0,0,0,134,5,1,0,0,0,135, + 136,3,104,52,0,136,137,3,92,46,0,137,138,3,8,4,0,138,7,1,0,0,0,139, + 141,3,10,5,0,140,139,1,0,0,0,140,141,1,0,0,0,141,9,1,0,0,0,142,143, + 5,4,0,0,143,144,3,88,44,0,144,145,3,88,44,0,145,146,3,32,16,0,146, + 11,1,0,0,0,147,148,5,4,0,0,148,149,3,14,7,0,149,13,1,0,0,0,150,153, + 3,16,8,0,151,153,3,40,20,0,152,150,1,0,0,0,152,151,1,0,0,0,153,15, + 1,0,0,0,154,155,3,90,45,0,155,156,3,40,20,0,156,17,1,0,0,0,157,159, + 5,15,0,0,158,157,1,0,0,0,158,159,1,0,0,0,159,19,1,0,0,0,160,162, + 5,8,0,0,161,160,1,0,0,0,161,162,1,0,0,0,162,21,1,0,0,0,163,165,5, + 9,0,0,164,163,1,0,0,0,164,165,1,0,0,0,165,23,1,0,0,0,166,168,5,13, + 0,0,167,166,1,0,0,0,167,168,1,0,0,0,168,25,1,0,0,0,169,171,5,7,0, + 0,170,169,1,0,0,0,170,171,1,0,0,0,171,27,1,0,0,0,172,174,3,2,1,0, + 173,172,1,0,0,0,173,174,1,0,0,0,174,29,1,0,0,0,175,177,3,106,53, + 0,176,175,1,0,0,0,176,177,1,0,0,0,177,31,1,0,0,0,178,180,3,84,42, + 0,179,178,1,0,0,0,179,180,1,0,0,0,180,33,1,0,0,0,181,182,3,32,16, + 0,182,183,3,18,9,0,183,35,1,0,0,0,184,185,3,18,9,0,185,186,3,32, + 16,0,186,37,1,0,0,0,187,190,3,34,17,0,188,190,3,36,18,0,189,187, + 1,0,0,0,189,188,1,0,0,0,190,39,1,0,0,0,191,192,3,72,36,0,192,193, + 3,38,19,0,193,194,3,20,10,0,194,195,3,22,11,0,195,196,3,24,12,0, + 196,197,3,26,13,0,197,198,3,28,14,0,198,199,3,30,15,0,199,41,1,0, + 0,0,200,202,3,78,39,0,201,200,1,0,0,0,201,202,1,0,0,0,202,43,1,0, + 0,0,203,204,3,48,24,0,204,205,3,42,21,0,205,206,3,92,46,0,206,207, + 3,12,6,0,207,45,1,0,0,0,208,210,3,76,38,0,209,208,1,0,0,0,209,210, + 1,0,0,0,210,47,1,0,0,0,211,212,5,18,0,0,212,213,3,46,23,0,213,49, + 1,0,0,0,214,215,3,110,55,0,215,216,3,88,44,0,216,217,3,12,6,0,217, + 51,1,0,0,0,218,219,3,80,40,0,219,220,3,114,57,0,220,221,3,112,56, + 0,221,222,3,116,58,0,222,223,3,74,37,0,223,224,3,80,40,0,224,53, + 1,0,0,0,225,226,5,4,0,0,226,227,3,94,47,0,227,228,3,82,41,0,228, + 55,1,0,0,0,229,232,3,58,29,0,230,232,3,60,30,0,231,229,1,0,0,0,231, + 230,1,0,0,0,232,57,1,0,0,0,233,234,3,102,51,0,234,235,3,88,44,0, + 235,59,1,0,0,0,236,237,3,92,46,0,237,238,3,62,31,0,238,61,1,0,0, + 0,239,241,3,66,33,0,240,239,1,0,0,0,240,241,1,0,0,0,241,63,1,0,0, + 0,242,243,3,52,26,0,243,244,3,56,28,0,244,65,1,0,0,0,245,248,3,70, + 35,0,246,248,3,54,27,0,247,245,1,0,0,0,247,246,1,0,0,0,248,67,1, + 0,0,0,249,251,3,54,27,0,250,249,1,0,0,0,250,251,1,0,0,0,251,69,1, + 0,0,0,252,253,3,100,50,0,253,254,3,68,34,0,254,71,1,0,0,0,255,256, + 7,0,0,0,256,73,1,0,0,0,257,259,5,18,0,0,258,257,1,0,0,0,258,259, + 1,0,0,0,259,75,1,0,0,0,260,263,5,19,0,0,261,263,5,11,0,0,262,260, + 1,0,0,0,262,261,1,0,0,0,263,77,1,0,0,0,264,265,7,1,0,0,265,79,1, + 0,0,0,266,268,5,7,0,0,267,266,1,0,0,0,267,268,1,0,0,0,268,81,1,0, + 0,0,269,270,7,2,0,0,270,83,1,0,0,0,271,272,7,3,0,0,272,85,1,0,0, + 0,273,275,3,72,36,0,274,276,3,72,36,0,275,274,1,0,0,0,275,276,1, + 0,0,0,276,87,1,0,0,0,277,278,3,72,36,0,278,279,3,72,36,0,279,89, + 1,0,0,0,280,281,3,88,44,0,281,282,3,72,36,0,282,91,1,0,0,0,283,285, + 3,88,44,0,284,286,3,72,36,0,285,284,1,0,0,0,285,286,1,0,0,0,286, + 93,1,0,0,0,287,289,3,72,36,0,288,287,1,0,0,0,289,290,1,0,0,0,290, + 288,1,0,0,0,290,291,1,0,0,0,291,95,1,0,0,0,292,294,3,118,59,0,293, + 295,3,94,47,0,294,293,1,0,0,0,294,295,1,0,0,0,295,97,1,0,0,0,296, + 298,3,94,47,0,297,299,3,96,48,0,298,297,1,0,0,0,298,299,1,0,0,0, + 299,99,1,0,0,0,300,301,5,4,0,0,301,302,5,12,0,0,302,303,5,8,0,0, + 303,101,1,0,0,0,304,305,7,3,0,0,305,103,1,0,0,0,306,307,5,2,0,0, + 307,308,5,16,0,0,308,105,1,0,0,0,309,310,5,4,0,0,310,311,5,11,0, + 0,311,107,1,0,0,0,312,313,5,9,0,0,313,314,5,14,0,0,314,109,1,0,0, + 0,315,316,5,16,0,0,316,317,5,15,0,0,317,111,1,0,0,0,318,319,5,6, + 0,0,319,320,5,14,0,0,320,113,1,0,0,0,321,323,5,17,0,0,322,321,1, + 0,0,0,322,323,1,0,0,0,323,115,1,0,0,0,324,326,5,21,0,0,325,324,1, + 0,0,0,325,326,1,0,0,0,326,117,1,0,0,0,327,328,5,1,0,0,328,119,1, + 0,0,0,29,121,133,140,152,158,161,164,167,170,173,176,179,189,201, + 209,231,240,247,250,258,262,267,275,285,290,294,298,322,325 + ] + +class fulling_motor_nameParser ( Parser ): + + grammarFileName = "grammar.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "'.'", "'3'", "", "", + "'A'", "'B'", "'C'", "'E'", "'F'", "'G'", "'H'", "'I'", + "'K'", "'L'", "'M'", "'P'", "'R'", "'S'", "'T'", "'V'", + "'W'" ] + + symbolicNames = [ "", "", "Three", "RestOfDigits", + "Dash", "A", "B", "C", "E", "F", "G", "H", "I", "K", + "L", "M", "P", "R", "S", "T", "V", "W" ] + + RULE_main = 0 + RULE_gearbox_specifier = 1 + RULE_type_specific = 2 + RULE_three_phase_t = 3 + RULE_three_phase_suffix_opt_our = 4 + RULE_three_phase_suffix_t = 5 + RULE_stepper_suffix_t = 6 + RULE_suffix_with_or_without_tail = 7 + RULE_suffix_with_current = 8 + RULE_double_step_rate_marker = 9 + RULE_encoder_presence_marker = 10 + RULE_unknown_marker_F = 11 + RULE_keyway_marker = 12 + RULE_screwed_shaft_marker = 13 + RULE_gearbox_specifier_opt_our = 14 + RULE_hollow_specifier_opt_our = 15 + RULE_shafts_count_marker_opt_our = 16 + RULE_shafts_count_and_step_rate_any_order_1_t = 17 + RULE_shafts_count_and_step_rate_any_order_2_t = 18 + RULE_shafts_count_and_step_rate_any_order_t = 19 + RULE_stepper_suffix_tail = 20 + RULE_stepper_modifiers_opt_our = 21 + RULE_stepper_t = 22 + RULE_stepper_series_opt_our = 23 + RULE_stepper_marker = 24 + RULE_permanent_t = 25 + RULE_brushless_marker = 26 + RULE_execution_configuration_t = 27 + RULE_brushless_modifier_variants = 28 + RULE_brushless_modifier_poles_torque = 29 + RULE_brushless_modifier_length_electronics_electrics = 30 + RULE_brushless_tail_opt_our = 31 + RULE_brushless_t = 32 + RULE_brushless_tail = 33 + RULE_execution_configuration_opt_our = 34 + RULE_brushless_electronic_tail = 35 + RULE_digit = 36 + RULE_square_marker = 37 + RULE_stepper_series = 38 + RULE_stepper_modifiers_t = 39 + RULE_price_performance_or_unknown_C_marker = 40 + RULE_electrical_unit = 41 + RULE_shafts_count_marker = 42 + RULE_one_or_two_digit_number = 43 + RULE_two_digit_number = 44 + RULE_three_digit_number = 45 + RULE_two_or_three_digit_number = 46 + RULE_any_integer = 47 + RULE_fractional_part = 48 + RULE_float_number = 49 + RULE_integrated_electronic_marker = 50 + RULE_brushless_modifier_poles_torque_letter = 51 + RULE_three_phase_marker = 52 + RULE_hollow_specifier = 53 + RULE_fl = 54 + RULE_permanent_marker = 55 + RULE_brushless_marker_base = 56 + RULE_rounded_marker = 57 + RULE_brushless_flat_marker = 58 + RULE_dot = 59 + + ruleNames = [ "main", "gearbox_specifier", "type_specific", "three_phase_t", + "three_phase_suffix_opt_our", "three_phase_suffix_t", + "stepper_suffix_t", "suffix_with_or_without_tail", "suffix_with_current", + "double_step_rate_marker", "encoder_presence_marker", + "unknown_marker_F", "keyway_marker", "screwed_shaft_marker", + "gearbox_specifier_opt_our", "hollow_specifier_opt_our", + "shafts_count_marker_opt_our", "shafts_count_and_step_rate_any_order_1_t", + "shafts_count_and_step_rate_any_order_2_t", "shafts_count_and_step_rate_any_order_t", + "stepper_suffix_tail", "stepper_modifiers_opt_our", "stepper_t", + "stepper_series_opt_our", "stepper_marker", "permanent_t", + "brushless_marker", "execution_configuration_t", "brushless_modifier_variants", + "brushless_modifier_poles_torque", "brushless_modifier_length_electronics_electrics", + "brushless_tail_opt_our", "brushless_t", "brushless_tail", + "execution_configuration_opt_our", "brushless_electronic_tail", + "digit", "square_marker", "stepper_series", "stepper_modifiers_t", + "price_performance_or_unknown_C_marker", "electrical_unit", + "shafts_count_marker", "one_or_two_digit_number", "two_digit_number", + "three_digit_number", "two_or_three_digit_number", "any_integer", + "fractional_part", "float_number", "integrated_electronic_marker", + "brushless_modifier_poles_torque_letter", "three_phase_marker", + "hollow_specifier", "fl", "permanent_marker", "brushless_marker_base", + "rounded_marker", "brushless_flat_marker", "dot" ] + + EOF = Token.EOF + T__0=1 + Three=2 + RestOfDigits=3 + Dash=4 + A=5 + B=6 + C=7 + E=8 + F=9 + G=10 + H=11 + I=12 + K=13 + L=14 + M=15 + P=16 + R=17 + S=18 + T=19 + V=20 + W=21 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.12.0") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class MainContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.size = None # Two_or_three_digit_numberContext + self.typed = None # Type_specificContext + + def two_or_three_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Two_or_three_digit_numberContext,0) + + + def type_specific(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Type_specificContext,0) + + + def fl(self): + return self.getTypedRuleContext(fulling_motor_nameParser.FlContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_main + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterMain" ): + listener.enterMain(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitMain" ): + listener.exitMain(self) + + + + + def main(self): + + localctx = fulling_motor_nameParser.MainContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_main) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 121 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==9: + self.state = 120 + self.fl() + + + self.state = 123 + localctx.size = self.two_or_three_digit_number() + self.state = 124 + localctx.typed = self.type_specific() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Gearbox_specifierContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.ratio = None # Float_numberContext + + def G(self): + return self.getToken(fulling_motor_nameParser.G, 0) + + def float_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Float_numberContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_gearbox_specifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGearbox_specifier" ): + listener.enterGearbox_specifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGearbox_specifier" ): + listener.exitGearbox_specifier(self) + + + + + def gearbox_specifier(self): + + localctx = fulling_motor_nameParser.Gearbox_specifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_gearbox_specifier) + try: + self.enterOuterAlt(localctx, 1) + self.state = 126 + self.match(fulling_motor_nameParser.G) + self.state = 127 + localctx.ratio = self.float_number() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Type_specificContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.stepper = None # Stepper_tContext + self.permanent = None # Permanent_tContext + self.brushless = None # Brushless_tContext + self.three_phase = None # Three_phase_tContext + + def stepper_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_tContext,0) + + + def permanent_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Permanent_tContext,0) + + + def brushless_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_tContext,0) + + + def three_phase_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Three_phase_tContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_type_specific + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterType_specific" ): + listener.enterType_specific(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitType_specific" ): + listener.exitType_specific(self) + + + + + def type_specific(self): + + localctx = fulling_motor_nameParser.Type_specificContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_type_specific) + try: + self.state = 133 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [18]: + self.enterOuterAlt(localctx, 1) + self.state = 129 + localctx.stepper = self.stepper_t() + pass + elif token in [16]: + self.enterOuterAlt(localctx, 2) + self.state = 130 + localctx.permanent = self.permanent_t() + pass + elif token in [6, 7, 17]: + self.enterOuterAlt(localctx, 3) + self.state = 131 + localctx.brushless = self.brushless_t() + pass + elif token in [2]: + self.enterOuterAlt(localctx, 4) + self.state = 132 + localctx.three_phase = self.three_phase_t() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Three_phase_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.type_marker = None # Three_phase_markerContext + self.motor_body_length = None # Two_or_three_digit_numberContext + self.suffix = None # Three_phase_suffix_opt_ourContext + + def three_phase_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Three_phase_markerContext,0) + + + def two_or_three_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Two_or_three_digit_numberContext,0) + + + def three_phase_suffix_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Three_phase_suffix_opt_ourContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_three_phase_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterThree_phase_t" ): + listener.enterThree_phase_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitThree_phase_t" ): + listener.exitThree_phase_t(self) + + + + + def three_phase_t(self): + + localctx = fulling_motor_nameParser.Three_phase_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_three_phase_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 135 + localctx.type_marker = self.three_phase_marker() + self.state = 136 + localctx.motor_body_length = self.two_or_three_digit_number() + self.state = 137 + localctx.suffix = self.three_phase_suffix_opt_our() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Three_phase_suffix_opt_ourContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def three_phase_suffix_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Three_phase_suffix_tContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_three_phase_suffix_opt_our + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterThree_phase_suffix_opt_our" ): + listener.enterThree_phase_suffix_opt_our(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitThree_phase_suffix_opt_our" ): + listener.exitThree_phase_suffix_opt_our(self) + + + + + def three_phase_suffix_opt_our(self): + + localctx = fulling_motor_nameParser.Three_phase_suffix_opt_ourContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_three_phase_suffix_opt_our) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 140 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==4: + self.state = 139 + self.three_phase_suffix_t() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Three_phase_suffix_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.current_per_phase_over_ten = None # Two_digit_numberContext + self.leads = None # Two_digit_numberContext + self.shafts_count = None # Shafts_count_marker_opt_ourContext + + def Dash(self): + return self.getToken(fulling_motor_nameParser.Dash, 0) + + def two_digit_number(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(fulling_motor_nameParser.Two_digit_numberContext) + else: + return self.getTypedRuleContext(fulling_motor_nameParser.Two_digit_numberContext,i) + + + def shafts_count_marker_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Shafts_count_marker_opt_ourContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_three_phase_suffix_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterThree_phase_suffix_t" ): + listener.enterThree_phase_suffix_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitThree_phase_suffix_t" ): + listener.exitThree_phase_suffix_t(self) + + + + + def three_phase_suffix_t(self): + + localctx = fulling_motor_nameParser.Three_phase_suffix_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_three_phase_suffix_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 142 + self.match(fulling_motor_nameParser.Dash) + self.state = 143 + localctx.current_per_phase_over_ten = self.two_digit_number() + self.state = 144 + localctx.leads = self.two_digit_number() + self.state = 145 + localctx.shafts_count = self.shafts_count_marker_opt_our() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Stepper_suffix_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.suffix_body = None # Suffix_with_or_without_tailContext + + def Dash(self): + return self.getToken(fulling_motor_nameParser.Dash, 0) + + def suffix_with_or_without_tail(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Suffix_with_or_without_tailContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_stepper_suffix_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStepper_suffix_t" ): + listener.enterStepper_suffix_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStepper_suffix_t" ): + listener.exitStepper_suffix_t(self) + + + + + def stepper_suffix_t(self): + + localctx = fulling_motor_nameParser.Stepper_suffix_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_stepper_suffix_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 147 + self.match(fulling_motor_nameParser.Dash) + self.state = 148 + localctx.suffix_body = self.suffix_with_or_without_tail() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Suffix_with_or_without_tailContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.with_current = None # Suffix_with_currentContext + self.without_current = None # Stepper_suffix_tailContext + + def suffix_with_current(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Suffix_with_currentContext,0) + + + def stepper_suffix_tail(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_suffix_tailContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_suffix_with_or_without_tail + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSuffix_with_or_without_tail" ): + listener.enterSuffix_with_or_without_tail(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSuffix_with_or_without_tail" ): + listener.exitSuffix_with_or_without_tail(self) + + + + + def suffix_with_or_without_tail(self): + + localctx = fulling_motor_nameParser.Suffix_with_or_without_tailContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_suffix_with_or_without_tail) + try: + self.state = 152 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,3,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 150 + localctx.with_current = self.suffix_with_current() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 151 + localctx.without_current = self.stepper_suffix_tail() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Suffix_with_currentContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.current = None # Three_digit_numberContext + self.tail = None # Stepper_suffix_tailContext + + def three_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Three_digit_numberContext,0) + + + def stepper_suffix_tail(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_suffix_tailContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_suffix_with_current + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSuffix_with_current" ): + listener.enterSuffix_with_current(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSuffix_with_current" ): + listener.exitSuffix_with_current(self) + + + + + def suffix_with_current(self): + + localctx = fulling_motor_nameParser.Suffix_with_currentContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_suffix_with_current) + try: + self.enterOuterAlt(localctx, 1) + self.state = 154 + localctx.current = self.three_digit_number() + self.state = 155 + localctx.tail = self.stepper_suffix_tail() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Double_step_rate_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def M(self): + return self.getToken(fulling_motor_nameParser.M, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_double_step_rate_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDouble_step_rate_marker" ): + listener.enterDouble_step_rate_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDouble_step_rate_marker" ): + listener.exitDouble_step_rate_marker(self) + + + + + def double_step_rate_marker(self): + + localctx = fulling_motor_nameParser.Double_step_rate_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_double_step_rate_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 158 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==15: + self.state = 157 + self.match(fulling_motor_nameParser.M) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Encoder_presence_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def E(self): + return self.getToken(fulling_motor_nameParser.E, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_encoder_presence_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterEncoder_presence_marker" ): + listener.enterEncoder_presence_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitEncoder_presence_marker" ): + listener.exitEncoder_presence_marker(self) + + + + + def encoder_presence_marker(self): + + localctx = fulling_motor_nameParser.Encoder_presence_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_encoder_presence_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 161 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==8: + self.state = 160 + self.match(fulling_motor_nameParser.E) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Unknown_marker_FContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def F(self): + return self.getToken(fulling_motor_nameParser.F, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_unknown_marker_F + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUnknown_marker_F" ): + listener.enterUnknown_marker_F(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUnknown_marker_F" ): + listener.exitUnknown_marker_F(self) + + + + + def unknown_marker_F(self): + + localctx = fulling_motor_nameParser.Unknown_marker_FContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_unknown_marker_F) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 164 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==9: + self.state = 163 + self.match(fulling_motor_nameParser.F) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Keyway_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def K(self): + return self.getToken(fulling_motor_nameParser.K, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_keyway_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterKeyway_marker" ): + listener.enterKeyway_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitKeyway_marker" ): + listener.exitKeyway_marker(self) + + + + + def keyway_marker(self): + + localctx = fulling_motor_nameParser.Keyway_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_keyway_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 167 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==13: + self.state = 166 + self.match(fulling_motor_nameParser.K) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Screwed_shaft_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def C(self): + return self.getToken(fulling_motor_nameParser.C, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_screwed_shaft_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterScrewed_shaft_marker" ): + listener.enterScrewed_shaft_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitScrewed_shaft_marker" ): + listener.exitScrewed_shaft_marker(self) + + + + + def screwed_shaft_marker(self): + + localctx = fulling_motor_nameParser.Screwed_shaft_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_screwed_shaft_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 170 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==7: + self.state = 169 + self.match(fulling_motor_nameParser.C) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Gearbox_specifier_opt_ourContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def gearbox_specifier(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Gearbox_specifierContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_gearbox_specifier_opt_our + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterGearbox_specifier_opt_our" ): + listener.enterGearbox_specifier_opt_our(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitGearbox_specifier_opt_our" ): + listener.exitGearbox_specifier_opt_our(self) + + + + + def gearbox_specifier_opt_our(self): + + localctx = fulling_motor_nameParser.Gearbox_specifier_opt_ourContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_gearbox_specifier_opt_our) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 173 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==10: + self.state = 172 + self.gearbox_specifier() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Hollow_specifier_opt_ourContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def hollow_specifier(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Hollow_specifierContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_hollow_specifier_opt_our + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHollow_specifier_opt_our" ): + listener.enterHollow_specifier_opt_our(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHollow_specifier_opt_our" ): + listener.exitHollow_specifier_opt_our(self) + + + + + def hollow_specifier_opt_our(self): + + localctx = fulling_motor_nameParser.Hollow_specifier_opt_ourContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_hollow_specifier_opt_our) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 176 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==4: + self.state = 175 + self.hollow_specifier() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Shafts_count_marker_opt_ourContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def shafts_count_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Shafts_count_markerContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_shafts_count_marker_opt_our + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterShafts_count_marker_opt_our" ): + listener.enterShafts_count_marker_opt_our(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitShafts_count_marker_opt_our" ): + listener.exitShafts_count_marker_opt_our(self) + + + + + def shafts_count_marker_opt_our(self): + + localctx = fulling_motor_nameParser.Shafts_count_marker_opt_ourContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_shafts_count_marker_opt_our) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 179 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==5 or _la==6: + self.state = 178 + self.shafts_count_marker() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Shafts_count_and_step_rate_any_order_1_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.shafts_count = None # Shafts_count_marker_opt_ourContext + self.step_rate = None # Double_step_rate_markerContext + + def shafts_count_marker_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Shafts_count_marker_opt_ourContext,0) + + + def double_step_rate_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Double_step_rate_markerContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_shafts_count_and_step_rate_any_order_1_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterShafts_count_and_step_rate_any_order_1_t" ): + listener.enterShafts_count_and_step_rate_any_order_1_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitShafts_count_and_step_rate_any_order_1_t" ): + listener.exitShafts_count_and_step_rate_any_order_1_t(self) + + + + + def shafts_count_and_step_rate_any_order_1_t(self): + + localctx = fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_1_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 34, self.RULE_shafts_count_and_step_rate_any_order_1_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 181 + localctx.shafts_count = self.shafts_count_marker_opt_our() + self.state = 182 + localctx.step_rate = self.double_step_rate_marker() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Shafts_count_and_step_rate_any_order_2_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.step_rate = None # Double_step_rate_markerContext + self.shafts_count = None # Shafts_count_marker_opt_ourContext + + def double_step_rate_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Double_step_rate_markerContext,0) + + + def shafts_count_marker_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Shafts_count_marker_opt_ourContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_shafts_count_and_step_rate_any_order_2_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterShafts_count_and_step_rate_any_order_2_t" ): + listener.enterShafts_count_and_step_rate_any_order_2_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitShafts_count_and_step_rate_any_order_2_t" ): + listener.exitShafts_count_and_step_rate_any_order_2_t(self) + + + + + def shafts_count_and_step_rate_any_order_2_t(self): + + localctx = fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_2_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 36, self.RULE_shafts_count_and_step_rate_any_order_2_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 184 + localctx.step_rate = self.double_step_rate_marker() + self.state = 185 + localctx.shafts_count = self.shafts_count_marker_opt_our() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Shafts_count_and_step_rate_any_order_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.shafts_count_and_step_rate_any_order_1 = None # Shafts_count_and_step_rate_any_order_1_tContext + self.shafts_count_and_step_rate_any_order_2 = None # Shafts_count_and_step_rate_any_order_2_tContext + + def shafts_count_and_step_rate_any_order_1_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_1_tContext,0) + + + def shafts_count_and_step_rate_any_order_2_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_2_tContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_shafts_count_and_step_rate_any_order_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterShafts_count_and_step_rate_any_order_t" ): + listener.enterShafts_count_and_step_rate_any_order_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitShafts_count_and_step_rate_any_order_t" ): + listener.exitShafts_count_and_step_rate_any_order_t(self) + + + + + def shafts_count_and_step_rate_any_order_t(self): + + localctx = fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 38, self.RULE_shafts_count_and_step_rate_any_order_t) + try: + self.state = 189 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,12,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 187 + localctx.shafts_count_and_step_rate_any_order_1 = self.shafts_count_and_step_rate_any_order_1_t() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 188 + localctx.shafts_count_and_step_rate_any_order_2 = self.shafts_count_and_step_rate_any_order_2_t() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Stepper_suffix_tailContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.variant = None # DigitContext + self.shafts_count_and_step_rate_any_order = None # Shafts_count_and_step_rate_any_order_tContext + self.encoder = None # Encoder_presence_markerContext + self.unknown_F = None # Unknown_marker_FContext + self.key_way = None # Keyway_markerContext + self.screwed_shaft = None # Screwed_shaft_markerContext + self.gearbox = None # Gearbox_specifier_opt_ourContext + self.hollow = None # Hollow_specifier_opt_ourContext + + def digit(self): + return self.getTypedRuleContext(fulling_motor_nameParser.DigitContext,0) + + + def shafts_count_and_step_rate_any_order_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Shafts_count_and_step_rate_any_order_tContext,0) + + + def encoder_presence_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Encoder_presence_markerContext,0) + + + def unknown_marker_F(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Unknown_marker_FContext,0) + + + def keyway_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Keyway_markerContext,0) + + + def screwed_shaft_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Screwed_shaft_markerContext,0) + + + def gearbox_specifier_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Gearbox_specifier_opt_ourContext,0) + + + def hollow_specifier_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Hollow_specifier_opt_ourContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_stepper_suffix_tail + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStepper_suffix_tail" ): + listener.enterStepper_suffix_tail(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStepper_suffix_tail" ): + listener.exitStepper_suffix_tail(self) + + + + + def stepper_suffix_tail(self): + + localctx = fulling_motor_nameParser.Stepper_suffix_tailContext(self, self._ctx, self.state) + self.enterRule(localctx, 40, self.RULE_stepper_suffix_tail) + try: + self.enterOuterAlt(localctx, 1) + self.state = 191 + localctx.variant = self.digit() + self.state = 192 + localctx.shafts_count_and_step_rate_any_order = self.shafts_count_and_step_rate_any_order_t() + self.state = 193 + localctx.encoder = self.encoder_presence_marker() + self.state = 194 + localctx.unknown_F = self.unknown_marker_F() + self.state = 195 + localctx.key_way = self.keyway_marker() + self.state = 196 + localctx.screwed_shaft = self.screwed_shaft_marker() + self.state = 197 + localctx.gearbox = self.gearbox_specifier_opt_our() + self.state = 198 + localctx.hollow = self.hollow_specifier_opt_our() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Stepper_modifiers_opt_ourContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def stepper_modifiers_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_modifiers_tContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_stepper_modifiers_opt_our + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStepper_modifiers_opt_our" ): + listener.enterStepper_modifiers_opt_our(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStepper_modifiers_opt_our" ): + listener.exitStepper_modifiers_opt_our(self) + + + + + def stepper_modifiers_opt_our(self): + + localctx = fulling_motor_nameParser.Stepper_modifiers_opt_ourContext(self, self._ctx, self.state) + self.enterRule(localctx, 42, self.RULE_stepper_modifiers_opt_our) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 201 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==7 or _la==11: + self.state = 200 + self.stepper_modifiers_t() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Stepper_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.type_marker = None # Stepper_markerContext + self.stepper_modifiers = None # Stepper_modifiers_opt_ourContext + self.motor_body_length = None # Two_or_three_digit_numberContext + self.suffix = None # Stepper_suffix_tContext + + def stepper_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_markerContext,0) + + + def stepper_modifiers_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_modifiers_opt_ourContext,0) + + + def two_or_three_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Two_or_three_digit_numberContext,0) + + + def stepper_suffix_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_suffix_tContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_stepper_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStepper_t" ): + listener.enterStepper_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStepper_t" ): + listener.exitStepper_t(self) + + + + + def stepper_t(self): + + localctx = fulling_motor_nameParser.Stepper_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 44, self.RULE_stepper_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 203 + localctx.type_marker = self.stepper_marker() + self.state = 204 + localctx.stepper_modifiers = self.stepper_modifiers_opt_our() + self.state = 205 + localctx.motor_body_length = self.two_or_three_digit_number() + self.state = 206 + localctx.suffix = self.stepper_suffix_t() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Stepper_series_opt_ourContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def stepper_series(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_seriesContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_stepper_series_opt_our + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStepper_series_opt_our" ): + listener.enterStepper_series_opt_our(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStepper_series_opt_our" ): + listener.exitStepper_series_opt_our(self) + + + + + def stepper_series_opt_our(self): + + localctx = fulling_motor_nameParser.Stepper_series_opt_ourContext(self, self._ctx, self.state) + self.enterRule(localctx, 46, self.RULE_stepper_series_opt_our) + try: + self.enterOuterAlt(localctx, 1) + self.state = 209 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,14,self._ctx) + if la_ == 1: + self.state = 208 + self.stepper_series() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Stepper_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.series = None # Stepper_series_opt_ourContext + + def S(self): + return self.getToken(fulling_motor_nameParser.S, 0) + + def stepper_series_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_series_opt_ourContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_stepper_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStepper_marker" ): + listener.enterStepper_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStepper_marker" ): + listener.exitStepper_marker(self) + + + + + def stepper_marker(self): + + localctx = fulling_motor_nameParser.Stepper_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 48, self.RULE_stepper_marker) + try: + self.enterOuterAlt(localctx, 1) + self.state = 211 + self.match(fulling_motor_nameParser.S) + self.state = 212 + localctx.series = self.stepper_series_opt_our() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Permanent_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.type_marker = None # Permanent_markerContext + self.motor_body_length = None # Two_digit_numberContext + self.suffix = None # Stepper_suffix_tContext + + def permanent_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Permanent_markerContext,0) + + + def two_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Two_digit_numberContext,0) + + + def stepper_suffix_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Stepper_suffix_tContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_permanent_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPermanent_t" ): + listener.enterPermanent_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPermanent_t" ): + listener.exitPermanent_t(self) + + + + + def permanent_t(self): + + localctx = fulling_motor_nameParser.Permanent_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 50, self.RULE_permanent_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 214 + localctx.type_marker = self.permanent_marker() + self.state = 215 + localctx.motor_body_length = self.two_digit_number() + self.state = 216 + localctx.suffix = self.stepper_suffix_t() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.is_price_performance = None # Price_performance_or_unknown_C_markerContext + self.is_round = None # Rounded_markerContext + self.is_flat = None # Brushless_flat_markerContext + self.is_square = None # Square_markerContext + self.is_unknown_C = None # Price_performance_or_unknown_C_markerContext + + def brushless_marker_base(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_marker_baseContext,0) + + + def price_performance_or_unknown_C_marker(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(fulling_motor_nameParser.Price_performance_or_unknown_C_markerContext) + else: + return self.getTypedRuleContext(fulling_motor_nameParser.Price_performance_or_unknown_C_markerContext,i) + + + def rounded_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Rounded_markerContext,0) + + + def brushless_flat_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_flat_markerContext,0) + + + def square_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Square_markerContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_marker" ): + listener.enterBrushless_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_marker" ): + listener.exitBrushless_marker(self) + + + + + def brushless_marker(self): + + localctx = fulling_motor_nameParser.Brushless_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 52, self.RULE_brushless_marker) + try: + self.enterOuterAlt(localctx, 1) + self.state = 218 + localctx.is_price_performance = self.price_performance_or_unknown_C_marker() + self.state = 219 + localctx.is_round = self.rounded_marker() + self.state = 220 + self.brushless_marker_base() + self.state = 221 + localctx.is_flat = self.brushless_flat_marker() + self.state = 222 + localctx.is_square = self.square_marker() + self.state = 223 + localctx.is_unknown_C = self.price_performance_or_unknown_C_marker() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Execution_configuration_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.number = None # Any_integerContext + self.unit = None # Electrical_unitContext + + def Dash(self): + return self.getToken(fulling_motor_nameParser.Dash, 0) + + def any_integer(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Any_integerContext,0) + + + def electrical_unit(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Electrical_unitContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_execution_configuration_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExecution_configuration_t" ): + listener.enterExecution_configuration_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExecution_configuration_t" ): + listener.exitExecution_configuration_t(self) + + + + + def execution_configuration_t(self): + + localctx = fulling_motor_nameParser.Execution_configuration_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 54, self.RULE_execution_configuration_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 225 + self.match(fulling_motor_nameParser.Dash) + self.state = 226 + localctx.number = self.any_integer() + self.state = 227 + localctx.unit = self.electrical_unit() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_modifier_variantsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.poles_torque = None # Brushless_modifier_poles_torqueContext + self.length_electronics_electrics = None # Brushless_modifier_length_electronics_electricsContext + + def brushless_modifier_poles_torque(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_modifier_poles_torqueContext,0) + + + def brushless_modifier_length_electronics_electrics(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_modifier_length_electronics_electricsContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_modifier_variants + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_modifier_variants" ): + listener.enterBrushless_modifier_variants(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_modifier_variants" ): + listener.exitBrushless_modifier_variants(self) + + + + + def brushless_modifier_variants(self): + + localctx = fulling_motor_nameParser.Brushless_modifier_variantsContext(self, self._ctx, self.state) + self.enterRule(localctx, 56, self.RULE_brushless_modifier_variants) + try: + self.state = 231 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [5, 6]: + self.enterOuterAlt(localctx, 1) + self.state = 229 + localctx.poles_torque = self.brushless_modifier_poles_torque() + pass + elif token in [2, 3]: + self.enterOuterAlt(localctx, 2) + self.state = 230 + localctx.length_electronics_electrics = self.brushless_modifier_length_electronics_electrics() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_modifier_poles_torqueContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.poles_or_other = None # Brushless_modifier_poles_torque_letterContext + self.variant = None # Two_digit_numberContext + + def brushless_modifier_poles_torque_letter(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_modifier_poles_torque_letterContext,0) + + + def two_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Two_digit_numberContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_modifier_poles_torque + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_modifier_poles_torque" ): + listener.enterBrushless_modifier_poles_torque(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_modifier_poles_torque" ): + listener.exitBrushless_modifier_poles_torque(self) + + + + + def brushless_modifier_poles_torque(self): + + localctx = fulling_motor_nameParser.Brushless_modifier_poles_torqueContext(self, self._ctx, self.state) + self.enterRule(localctx, 58, self.RULE_brushless_modifier_poles_torque) + try: + self.enterOuterAlt(localctx, 1) + self.state = 233 + localctx.poles_or_other = self.brushless_modifier_poles_torque_letter() + self.state = 234 + localctx.variant = self.two_digit_number() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_modifier_length_electronics_electricsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.motor_body_length = None # Two_or_three_digit_numberContext + self.tail = None # Brushless_tail_opt_ourContext + + def two_or_three_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Two_or_three_digit_numberContext,0) + + + def brushless_tail_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_tail_opt_ourContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_modifier_length_electronics_electrics + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_modifier_length_electronics_electrics" ): + listener.enterBrushless_modifier_length_electronics_electrics(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_modifier_length_electronics_electrics" ): + listener.exitBrushless_modifier_length_electronics_electrics(self) + + + + + def brushless_modifier_length_electronics_electrics(self): + + localctx = fulling_motor_nameParser.Brushless_modifier_length_electronics_electricsContext(self, self._ctx, self.state) + self.enterRule(localctx, 60, self.RULE_brushless_modifier_length_electronics_electrics) + try: + self.enterOuterAlt(localctx, 1) + self.state = 236 + localctx.motor_body_length = self.two_or_three_digit_number() + self.state = 237 + localctx.tail = self.brushless_tail_opt_our() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_tail_opt_ourContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def brushless_tail(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_tailContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_tail_opt_our + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_tail_opt_our" ): + listener.enterBrushless_tail_opt_our(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_tail_opt_our" ): + listener.exitBrushless_tail_opt_our(self) + + + + + def brushless_tail_opt_our(self): + + localctx = fulling_motor_nameParser.Brushless_tail_opt_ourContext(self, self._ctx, self.state) + self.enterRule(localctx, 62, self.RULE_brushless_tail_opt_our) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 240 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==4: + self.state = 239 + self.brushless_tail() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.type_marker = None # Brushless_markerContext + self.modifier = None # Brushless_modifier_variantsContext + + def brushless_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_markerContext,0) + + + def brushless_modifier_variants(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_modifier_variantsContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_t" ): + listener.enterBrushless_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_t" ): + listener.exitBrushless_t(self) + + + + + def brushless_t(self): + + localctx = fulling_motor_nameParser.Brushless_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 64, self.RULE_brushless_t) + try: + self.enterOuterAlt(localctx, 1) + self.state = 242 + localctx.type_marker = self.brushless_marker() + self.state = 243 + localctx.modifier = self.brushless_modifier_variants() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_tailContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.electronic = None # Brushless_electronic_tailContext + self.no_electronic = None # Execution_configuration_tContext + + def brushless_electronic_tail(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Brushless_electronic_tailContext,0) + + + def execution_configuration_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Execution_configuration_tContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_tail + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_tail" ): + listener.enterBrushless_tail(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_tail" ): + listener.exitBrushless_tail(self) + + + + + def brushless_tail(self): + + localctx = fulling_motor_nameParser.Brushless_tailContext(self, self._ctx, self.state) + self.enterRule(localctx, 66, self.RULE_brushless_tail) + try: + self.state = 247 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,17,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 245 + localctx.electronic = self.brushless_electronic_tail() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 246 + localctx.no_electronic = self.execution_configuration_t() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Execution_configuration_opt_ourContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def execution_configuration_t(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Execution_configuration_tContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_execution_configuration_opt_our + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExecution_configuration_opt_our" ): + listener.enterExecution_configuration_opt_our(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExecution_configuration_opt_our" ): + listener.exitExecution_configuration_opt_our(self) + + + + + def execution_configuration_opt_our(self): + + localctx = fulling_motor_nameParser.Execution_configuration_opt_ourContext(self, self._ctx, self.state) + self.enterRule(localctx, 68, self.RULE_execution_configuration_opt_our) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 250 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==4: + self.state = 249 + self.execution_configuration_t() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_electronic_tailContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.has_electronics = None # Integrated_electronic_markerContext + self.cfg = None # Execution_configuration_opt_ourContext + + def integrated_electronic_marker(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Integrated_electronic_markerContext,0) + + + def execution_configuration_opt_our(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Execution_configuration_opt_ourContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_electronic_tail + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_electronic_tail" ): + listener.enterBrushless_electronic_tail(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_electronic_tail" ): + listener.exitBrushless_electronic_tail(self) + + + + + def brushless_electronic_tail(self): + + localctx = fulling_motor_nameParser.Brushless_electronic_tailContext(self, self._ctx, self.state) + self.enterRule(localctx, 70, self.RULE_brushless_electronic_tail) + try: + self.enterOuterAlt(localctx, 1) + self.state = 252 + localctx.has_electronics = self.integrated_electronic_marker() + self.state = 253 + localctx.cfg = self.execution_configuration_opt_our() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DigitContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def RestOfDigits(self): + return self.getToken(fulling_motor_nameParser.RestOfDigits, 0) + + def Three(self): + return self.getToken(fulling_motor_nameParser.Three, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_digit + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDigit" ): + listener.enterDigit(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDigit" ): + listener.exitDigit(self) + + + + + def digit(self): + + localctx = fulling_motor_nameParser.DigitContext(self, self._ctx, self.state) + self.enterRule(localctx, 72, self.RULE_digit) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 255 + _la = self._input.LA(1) + if not(_la==2 or _la==3): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Square_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def S(self): + return self.getToken(fulling_motor_nameParser.S, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_square_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSquare_marker" ): + listener.enterSquare_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSquare_marker" ): + listener.exitSquare_marker(self) + + + + + def square_marker(self): + + localctx = fulling_motor_nameParser.Square_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 74, self.RULE_square_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 258 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==18: + self.state = 257 + self.match(fulling_motor_nameParser.S) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Stepper_seriesContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.standard = None # Token + self.hybrid = None # Token + + def T(self): + return self.getToken(fulling_motor_nameParser.T, 0) + + def H(self): + return self.getToken(fulling_motor_nameParser.H, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_stepper_series + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStepper_series" ): + listener.enterStepper_series(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStepper_series" ): + listener.exitStepper_series(self) + + + + + def stepper_series(self): + + localctx = fulling_motor_nameParser.Stepper_seriesContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_stepper_series) + try: + self.state = 262 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [19]: + self.enterOuterAlt(localctx, 1) + self.state = 260 + localctx.standard = self.match(fulling_motor_nameParser.T) + pass + elif token in [11]: + self.enterOuterAlt(localctx, 2) + self.state = 261 + localctx.hybrid = self.match(fulling_motor_nameParser.H) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Stepper_modifiers_tContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.stepper_modifiers = None # Token + + def H(self): + return self.getToken(fulling_motor_nameParser.H, 0) + + def C(self): + return self.getToken(fulling_motor_nameParser.C, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_stepper_modifiers_t + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStepper_modifiers_t" ): + listener.enterStepper_modifiers_t(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStepper_modifiers_t" ): + listener.exitStepper_modifiers_t(self) + + + + + def stepper_modifiers_t(self): + + localctx = fulling_motor_nameParser.Stepper_modifiers_tContext(self, self._ctx, self.state) + self.enterRule(localctx, 78, self.RULE_stepper_modifiers_t) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 264 + localctx.stepper_modifiers = self._input.LT(1) + _la = self._input.LA(1) + if not(_la==7 or _la==11): + localctx.stepper_modifiers = self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Price_performance_or_unknown_C_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def C(self): + return self.getToken(fulling_motor_nameParser.C, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_price_performance_or_unknown_C_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPrice_performance_or_unknown_C_marker" ): + listener.enterPrice_performance_or_unknown_C_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPrice_performance_or_unknown_C_marker" ): + listener.exitPrice_performance_or_unknown_C_marker(self) + + + + + def price_performance_or_unknown_C_marker(self): + + localctx = fulling_motor_nameParser.Price_performance_or_unknown_C_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 80, self.RULE_price_performance_or_unknown_C_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 267 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==7: + self.state = 266 + self.match(fulling_motor_nameParser.C) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Electrical_unitContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def A(self): + return self.getToken(fulling_motor_nameParser.A, 0) + + def V(self): + return self.getToken(fulling_motor_nameParser.V, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_electrical_unit + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterElectrical_unit" ): + listener.enterElectrical_unit(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitElectrical_unit" ): + listener.exitElectrical_unit(self) + + + + + def electrical_unit(self): + + localctx = fulling_motor_nameParser.Electrical_unitContext(self, self._ctx, self.state) + self.enterRule(localctx, 82, self.RULE_electrical_unit) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 269 + _la = self._input.LA(1) + if not(_la==5 or _la==20): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Shafts_count_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def A(self): + return self.getToken(fulling_motor_nameParser.A, 0) + + def B(self): + return self.getToken(fulling_motor_nameParser.B, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_shafts_count_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterShafts_count_marker" ): + listener.enterShafts_count_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitShafts_count_marker" ): + listener.exitShafts_count_marker(self) + + + + + def shafts_count_marker(self): + + localctx = fulling_motor_nameParser.Shafts_count_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 84, self.RULE_shafts_count_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 271 + _la = self._input.LA(1) + if not(_la==5 or _la==6): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class One_or_two_digit_numberContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def digit(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(fulling_motor_nameParser.DigitContext) + else: + return self.getTypedRuleContext(fulling_motor_nameParser.DigitContext,i) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_one_or_two_digit_number + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOne_or_two_digit_number" ): + listener.enterOne_or_two_digit_number(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOne_or_two_digit_number" ): + listener.exitOne_or_two_digit_number(self) + + + + + def one_or_two_digit_number(self): + + localctx = fulling_motor_nameParser.One_or_two_digit_numberContext(self, self._ctx, self.state) + self.enterRule(localctx, 86, self.RULE_one_or_two_digit_number) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 273 + self.digit() + self.state = 275 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==2 or _la==3: + self.state = 274 + self.digit() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Two_digit_numberContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def digit(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(fulling_motor_nameParser.DigitContext) + else: + return self.getTypedRuleContext(fulling_motor_nameParser.DigitContext,i) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_two_digit_number + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTwo_digit_number" ): + listener.enterTwo_digit_number(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTwo_digit_number" ): + listener.exitTwo_digit_number(self) + + + + + def two_digit_number(self): + + localctx = fulling_motor_nameParser.Two_digit_numberContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_two_digit_number) + try: + self.enterOuterAlt(localctx, 1) + self.state = 277 + self.digit() + self.state = 278 + self.digit() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Three_digit_numberContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def two_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Two_digit_numberContext,0) + + + def digit(self): + return self.getTypedRuleContext(fulling_motor_nameParser.DigitContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_three_digit_number + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterThree_digit_number" ): + listener.enterThree_digit_number(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitThree_digit_number" ): + listener.exitThree_digit_number(self) + + + + + def three_digit_number(self): + + localctx = fulling_motor_nameParser.Three_digit_numberContext(self, self._ctx, self.state) + self.enterRule(localctx, 90, self.RULE_three_digit_number) + try: + self.enterOuterAlt(localctx, 1) + self.state = 280 + self.two_digit_number() + self.state = 281 + self.digit() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Two_or_three_digit_numberContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def two_digit_number(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Two_digit_numberContext,0) + + + def digit(self): + return self.getTypedRuleContext(fulling_motor_nameParser.DigitContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_two_or_three_digit_number + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTwo_or_three_digit_number" ): + listener.enterTwo_or_three_digit_number(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTwo_or_three_digit_number" ): + listener.exitTwo_or_three_digit_number(self) + + + + + def two_or_three_digit_number(self): + + localctx = fulling_motor_nameParser.Two_or_three_digit_numberContext(self, self._ctx, self.state) + self.enterRule(localctx, 92, self.RULE_two_or_three_digit_number) + try: + self.enterOuterAlt(localctx, 1) + self.state = 283 + self.two_digit_number() + self.state = 285 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,23,self._ctx) + if la_ == 1: + self.state = 284 + self.digit() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Any_integerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def digit(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(fulling_motor_nameParser.DigitContext) + else: + return self.getTypedRuleContext(fulling_motor_nameParser.DigitContext,i) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_any_integer + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterAny_integer" ): + listener.enterAny_integer(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitAny_integer" ): + listener.exitAny_integer(self) + + + + + def any_integer(self): + + localctx = fulling_motor_nameParser.Any_integerContext(self, self._ctx, self.state) + self.enterRule(localctx, 94, self.RULE_any_integer) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 288 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 287 + self.digit() + self.state = 290 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==2 or _la==3): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Fractional_partContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def dot(self): + return self.getTypedRuleContext(fulling_motor_nameParser.DotContext,0) + + + def any_integer(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Any_integerContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_fractional_part + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFractional_part" ): + listener.enterFractional_part(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFractional_part" ): + listener.exitFractional_part(self) + + + + + def fractional_part(self): + + localctx = fulling_motor_nameParser.Fractional_partContext(self, self._ctx, self.state) + self.enterRule(localctx, 96, self.RULE_fractional_part) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 292 + self.dot() + self.state = 294 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==2 or _la==3: + self.state = 293 + self.any_integer() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Float_numberContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def any_integer(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Any_integerContext,0) + + + def fractional_part(self): + return self.getTypedRuleContext(fulling_motor_nameParser.Fractional_partContext,0) + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_float_number + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFloat_number" ): + listener.enterFloat_number(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFloat_number" ): + listener.exitFloat_number(self) + + + + + def float_number(self): + + localctx = fulling_motor_nameParser.Float_numberContext(self, self._ctx, self.state) + self.enterRule(localctx, 98, self.RULE_float_number) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 296 + self.any_integer() + self.state = 298 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==1: + self.state = 297 + self.fractional_part() + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Integrated_electronic_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def Dash(self): + return self.getToken(fulling_motor_nameParser.Dash, 0) + + def I(self): + return self.getToken(fulling_motor_nameParser.I, 0) + + def E(self): + return self.getToken(fulling_motor_nameParser.E, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_integrated_electronic_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntegrated_electronic_marker" ): + listener.enterIntegrated_electronic_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntegrated_electronic_marker" ): + listener.exitIntegrated_electronic_marker(self) + + + + + def integrated_electronic_marker(self): + + localctx = fulling_motor_nameParser.Integrated_electronic_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 100, self.RULE_integrated_electronic_marker) + try: + self.enterOuterAlt(localctx, 1) + self.state = 300 + self.match(fulling_motor_nameParser.Dash) + self.state = 301 + self.match(fulling_motor_nameParser.I) + self.state = 302 + self.match(fulling_motor_nameParser.E) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_modifier_poles_torque_letterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def A(self): + return self.getToken(fulling_motor_nameParser.A, 0) + + def B(self): + return self.getToken(fulling_motor_nameParser.B, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_modifier_poles_torque_letter + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_modifier_poles_torque_letter" ): + listener.enterBrushless_modifier_poles_torque_letter(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_modifier_poles_torque_letter" ): + listener.exitBrushless_modifier_poles_torque_letter(self) + + + + + def brushless_modifier_poles_torque_letter(self): + + localctx = fulling_motor_nameParser.Brushless_modifier_poles_torque_letterContext(self, self._ctx, self.state) + self.enterRule(localctx, 102, self.RULE_brushless_modifier_poles_torque_letter) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 304 + _la = self._input.LA(1) + if not(_la==5 or _la==6): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Three_phase_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def Three(self): + return self.getToken(fulling_motor_nameParser.Three, 0) + + def P(self): + return self.getToken(fulling_motor_nameParser.P, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_three_phase_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterThree_phase_marker" ): + listener.enterThree_phase_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitThree_phase_marker" ): + listener.exitThree_phase_marker(self) + + + + + def three_phase_marker(self): + + localctx = fulling_motor_nameParser.Three_phase_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 104, self.RULE_three_phase_marker) + try: + self.enterOuterAlt(localctx, 1) + self.state = 306 + self.match(fulling_motor_nameParser.Three) + self.state = 307 + self.match(fulling_motor_nameParser.P) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Hollow_specifierContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def Dash(self): + return self.getToken(fulling_motor_nameParser.Dash, 0) + + def H(self): + return self.getToken(fulling_motor_nameParser.H, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_hollow_specifier + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHollow_specifier" ): + listener.enterHollow_specifier(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHollow_specifier" ): + listener.exitHollow_specifier(self) + + + + + def hollow_specifier(self): + + localctx = fulling_motor_nameParser.Hollow_specifierContext(self, self._ctx, self.state) + self.enterRule(localctx, 106, self.RULE_hollow_specifier) + try: + self.enterOuterAlt(localctx, 1) + self.state = 309 + self.match(fulling_motor_nameParser.Dash) + self.state = 310 + self.match(fulling_motor_nameParser.H) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FlContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def F(self): + return self.getToken(fulling_motor_nameParser.F, 0) + + def L(self): + return self.getToken(fulling_motor_nameParser.L, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_fl + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFl" ): + listener.enterFl(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFl" ): + listener.exitFl(self) + + + + + def fl(self): + + localctx = fulling_motor_nameParser.FlContext(self, self._ctx, self.state) + self.enterRule(localctx, 108, self.RULE_fl) + try: + self.enterOuterAlt(localctx, 1) + self.state = 312 + self.match(fulling_motor_nameParser.F) + self.state = 313 + self.match(fulling_motor_nameParser.L) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Permanent_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def P(self): + return self.getToken(fulling_motor_nameParser.P, 0) + + def M(self): + return self.getToken(fulling_motor_nameParser.M, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_permanent_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPermanent_marker" ): + listener.enterPermanent_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPermanent_marker" ): + listener.exitPermanent_marker(self) + + + + + def permanent_marker(self): + + localctx = fulling_motor_nameParser.Permanent_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 110, self.RULE_permanent_marker) + try: + self.enterOuterAlt(localctx, 1) + self.state = 315 + self.match(fulling_motor_nameParser.P) + self.state = 316 + self.match(fulling_motor_nameParser.M) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_marker_baseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def B(self): + return self.getToken(fulling_motor_nameParser.B, 0) + + def L(self): + return self.getToken(fulling_motor_nameParser.L, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_marker_base + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_marker_base" ): + listener.enterBrushless_marker_base(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_marker_base" ): + listener.exitBrushless_marker_base(self) + + + + + def brushless_marker_base(self): + + localctx = fulling_motor_nameParser.Brushless_marker_baseContext(self, self._ctx, self.state) + self.enterRule(localctx, 112, self.RULE_brushless_marker_base) + try: + self.enterOuterAlt(localctx, 1) + self.state = 318 + self.match(fulling_motor_nameParser.B) + self.state = 319 + self.match(fulling_motor_nameParser.L) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Rounded_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def R(self): + return self.getToken(fulling_motor_nameParser.R, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_rounded_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterRounded_marker" ): + listener.enterRounded_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitRounded_marker" ): + listener.exitRounded_marker(self) + + + + + def rounded_marker(self): + + localctx = fulling_motor_nameParser.Rounded_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 114, self.RULE_rounded_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 322 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==17: + self.state = 321 + self.match(fulling_motor_nameParser.R) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Brushless_flat_markerContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def W(self): + return self.getToken(fulling_motor_nameParser.W, 0) + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_brushless_flat_marker + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrushless_flat_marker" ): + listener.enterBrushless_flat_marker(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrushless_flat_marker" ): + listener.exitBrushless_flat_marker(self) + + + + + def brushless_flat_marker(self): + + localctx = fulling_motor_nameParser.Brushless_flat_markerContext(self, self._ctx, self.state) + self.enterRule(localctx, 116, self.RULE_brushless_flat_marker) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 325 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==21: + self.state = 324 + self.match(fulling_motor_nameParser.W) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DotContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return fulling_motor_nameParser.RULE_dot + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDot" ): + listener.enterDot(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDot" ): + listener.exitDot(self) + + + + + def dot(self): + + localctx = fulling_motor_nameParser.DotContext(self, self._ctx, self.state) + self.enterRule(localctx, 118, self.RULE_dot) + try: + self.enterOuterAlt(localctx, 1) + self.state = 327 + self.match(fulling_motor_nameParser.T__0) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/FullingMotorModelDecoder/parserBundle/compiled/arpeggio/fulling_motor_name.peg b/FullingMotorModelDecoder/parserBundle/compiled/arpeggio/fulling_motor_name.peg new file mode 100644 index 0000000..083a405 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/arpeggio/fulling_motor_name.peg @@ -0,0 +1,82 @@ +//Generated by UniGrammar (https://github.com/UniGrammar/UniGrammar.py) +//for arpeggio (https://github.com/textX/Arpeggio) DSL + +//A grammar for parsing Changzhou Fulling Motor Co., Ltd. model namebers + + + +//productions +main <- fl? two_or_three_digit_number type_specific; +gyro_specifier <- G two_digit_number; +type_specific <- stepper_t / permanent_t / brushless_t / three_phase_t; +three_phase_t <- three_phase_marker two_or_three_digit_number three_phase_suffix_t?; +three_phase_suffix_t <- Dash two_digit_number two_digit_number shafts_count_marker?; +stepper_suffix_t <- Dash suffix_with_or_without_tail; +suffix_with_or_without_tail <- suffix_with_current / stepper_suffix_tail; +suffix_with_current <- three_digit_number stepper_suffix_tail; +double_step_rate_marker <- M?; +encoder_presence_marker <- E?; +flatness_marker <- F?; +keyway_marker <- K?; +screwed_shaft_marker <- C?; +gyro_specifier_opt <- gyro_specifier?; +shafts_count_marker_opt <- shafts_count_marker?; +stepper_suffix_tail <- digit shafts_count_marker_opt double_step_rate_marker encoder_presence_marker flatness_marker keyway_marker screwed_shaft_marker gyro_specifier_opt; +stepper_t <- stepper_marker stepper_modifiers_t? two_or_three_digit_number stepper_suffix_t; +stepper_type_opt <- stepper_type?; +stepper_marker <- S stepper_type_opt; +permanent_t <- permanent_marker two_digit_number stepper_suffix_t; +brushless_marker <- cheap_marker rounded_marker brushless_marker_base brushless_flat_marker square_marker; +execution_configuration_t <- Dash two_or_three_digit_number electrical_unit; +brushless_t <- brushless_marker brushless_modifier? two_or_three_digit_number brushless_tail?; +brushless_tail <- brushless_electronic_tail / execution_configuration_t; +brushless_electronic_tail <- integrated_electronic_marker execution_configuration_t?; + + +//fragmented +digit <- RestOfDigits / Three; +square_marker <- S?; +stepper_type <- T / H; +stepper_modifiers_t <- (H / C); +cheap_marker <- C?; +electrical_unit <- A / V; +shafts_count_marker <- A / B; +one_or_two_digit_number <- digit digit?; +two_digit_number <- digit digit; +three_digit_number <- two_digit_number digit; +two_or_three_digit_number <- two_digit_number digit?; +integrated_electronic_marker <- Dash I E; +brushless_modifier <- A / B / C; +three_phase_marker <- Three P; + + +//characters +Three <- '3'; +RestOfDigits <- r'[0-24-9]'; +Dash <- r'[–-]'; +A <- 'A'; +B <- 'B'; +C <- 'C'; +E <- 'E'; +F <- 'F'; +G <- 'G'; +H <- 'H'; +I <- 'I'; +K <- 'K'; +L <- 'L'; +M <- 'M'; +P <- 'P'; +R <- 'R'; +S <- 'S'; +T <- 'T'; +V <- 'V'; +W <- 'W'; + + +//tokens +fl <- F L; +permanent_marker <- P M; +brushless_marker_base <- B L; +rounded_marker <- R?; +brushless_flat_marker <- W?; + diff --git a/FullingMotorModelDecoder/parserBundle/compiled/parglare/__init__.py b/FullingMotorModelDecoder/parserBundle/compiled/parglare/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/compiled/parglare/fulling_motor_name.pg b/FullingMotorModelDecoder/parserBundle/compiled/parglare/fulling_motor_name.pg new file mode 100644 index 0000000..0212be1 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/parglare/fulling_motor_name.pg @@ -0,0 +1,103 @@ +//Generated by UniGrammar (https://github.com/UniGrammar/UniGrammar.py) +//for parglare (https://github.com/igordejanovic/parglare) DSL + +//A grammar for parsing Changzhou Fulling Motor Co., Ltd. model namebers + + + +//productions +main: fl? size=two_or_three_digit_number typed=type_specific; +gearbox_specifier: G ratio=float_number; +type_specific: stepper=stepper_t | permanent=permanent_t | brushless=brushless_t | three_phase=three_phase_t; +three_phase_t: type_marker=three_phase_marker motor_body_length=two_or_three_digit_number suffix=three_phase_suffix_opt_our; +three_phase_suffix_opt_our: three_phase_suffix_t?; +three_phase_suffix_t: Dash current_per_phase_over_ten=two_digit_number leads=two_digit_number shafts_count=shafts_count_marker_opt_our; +stepper_suffix_t: Dash suffix_body=suffix_with_or_without_tail; +suffix_with_or_without_tail: with_current=suffix_with_current | without_current=stepper_suffix_tail; +suffix_with_current: current=three_digit_number tail=stepper_suffix_tail; +double_step_rate_marker: M?; +encoder_presence_marker: E?; +unknown_marker_F: F?; +keyway_marker: K?; +screwed_shaft_marker: C?; +gearbox_specifier_opt_our: gearbox_specifier?; +hollow_specifier_opt_our: hollow_specifier?; +shafts_count_marker_opt_our: shafts_count_marker?; +shafts_count_and_step_rate_any_order_1_t: shafts_count=shafts_count_marker_opt_our step_rate=double_step_rate_marker; +shafts_count_and_step_rate_any_order_2_t: step_rate=double_step_rate_marker shafts_count=shafts_count_marker_opt_our; +shafts_count_and_step_rate_any_order_t: shafts_count_and_step_rate_any_order_1=shafts_count_and_step_rate_any_order_1_t | shafts_count_and_step_rate_any_order_2=shafts_count_and_step_rate_any_order_2_t; +stepper_suffix_tail: variant=digit shafts_count_and_step_rate_any_order=shafts_count_and_step_rate_any_order_t encoder=encoder_presence_marker unknown_F=unknown_marker_F key_way=keyway_marker screwed_shaft=screwed_shaft_marker gearbox=gearbox_specifier_opt_our hollow=hollow_specifier_opt_our; +stepper_modifiers_opt_our: stepper_modifiers_t?; +stepper_t: type_marker=stepper_marker stepper_modifiers=stepper_modifiers_opt_our motor_body_length=two_or_three_digit_number suffix=stepper_suffix_t; +stepper_series_opt_our_opt: stepper_series | EMPTY; +stepper_series_opt_our: stepper_series_opt_our_opt {shift}; +stepper_marker: S series=stepper_series_opt_our; +permanent_t: type_marker=permanent_marker motor_body_length=two_digit_number suffix=stepper_suffix_t; +brushless_marker: is_price_performance=price_performance_or_unknown_C_marker is_round=rounded_marker brushless_marker_base is_flat=brushless_flat_marker is_square=square_marker is_unknown_C=price_performance_or_unknown_C_marker; +execution_configuration_t: Dash number=any_integer unit=electrical_unit; +brushless_modifier_variants: poles_torque=brushless_modifier_poles_torque | length_electronics_electrics=brushless_modifier_length_electronics_electrics; +brushless_modifier_poles_torque: poles_or_other=brushless_modifier_poles_torque_letter variant=two_digit_number; +brushless_modifier_length_electronics_electrics: motor_body_length=two_or_three_digit_number tail=brushless_tail_opt_our; +brushless_tail_opt_our: brushless_tail?; +brushless_t: type_marker=brushless_marker modifier=brushless_modifier_variants; +brushless_tail: electronic=brushless_electronic_tail | no_electronic=execution_configuration_t; +execution_configuration_opt_our: execution_configuration_t?; +brushless_electronic_tail: has_electronics=integrated_electronic_marker cfg=execution_configuration_opt_our; + + +//fragmented +digit: RestOfDigits | Three; +square_marker: S?; +stepper_series: standard=T | hybrid=H; +stepper_modifiers_t: stepper_modifiers=(H | C); +price_performance_or_unknown_C_marker: C?; +electrical_unit: A | V; +shafts_count_marker: A | B; +one_or_two_digit_number_opt: digit | EMPTY; +one_or_two_digit_number: digit (one_or_two_digit_number_opt {shift}); +two_digit_number: digit digit; +three_digit_number: two_digit_number digit; +two_or_three_digit_number_opt: digit | EMPTY; +two_or_three_digit_number: two_digit_number (two_or_three_digit_number_opt {shift}); +any_integer: digit+; +fractional_part: dot any_integer?; +float_number: any_integer fractional_part?; +integrated_electronic_marker: Dash I E; +brushless_modifier_poles_torque_letter: A | B; +three_phase_marker: Three P; +hollow_specifier: Dash H; + + +LAYOUT: EMPTY; +//tokens +fl: F L; +permanent_marker: P M; +brushless_marker_base: B L; +rounded_marker: R?; +brushless_flat_marker: W?; + + +terminals +//characters +Three: '3'; +RestOfDigits: /[0-24-9]/; +Dash: /[–-]/; +dot: '.'; +A: 'A'; +B: 'B'; +C: 'C'; +E: 'E'; +F: 'F'; +G: 'G'; +H: 'H'; +I: 'I'; +K: 'K'; +L: 'L'; +M: 'M'; +P: 'P'; +R: 'R'; +S: 'S'; +T: 'T'; +V: 'V'; +W: 'W'; + diff --git a/FullingMotorModelDecoder/parserBundle/compiled/parsimonious/__init__.py b/FullingMotorModelDecoder/parserBundle/compiled/parsimonious/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/compiled/parsimonious/fulling_motor_name.ppeg b/FullingMotorModelDecoder/parserBundle/compiled/parsimonious/fulling_motor_name.ppeg new file mode 100644 index 0000000..3a87db9 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/parsimonious/fulling_motor_name.ppeg @@ -0,0 +1,98 @@ +#Generated by UniGrammar (https://github.com/UniGrammar/UniGrammar.py) +#for parsimonious (https://github.com/erikrose/parsimonious) DSL + +#A grammar for parsing Changzhou Fulling Motor Co., Ltd. model namebers + + + +#productions +main = fl? two_or_three_digit_number type_specific +gearbox_specifier = G float_number +type_specific = stepper_t / permanent_t / brushless_t / three_phase_t +three_phase_t = three_phase_marker two_or_three_digit_number three_phase_suffix_opt_our +three_phase_suffix_opt_our = three_phase_suffix_t? +three_phase_suffix_t = Dash two_digit_number two_digit_number shafts_count_marker_opt_our +stepper_suffix_t = Dash suffix_with_or_without_tail +suffix_with_or_without_tail = suffix_with_current / stepper_suffix_tail +suffix_with_current = three_digit_number stepper_suffix_tail +double_step_rate_marker = M? +encoder_presence_marker = E? +unknown_marker_F = F? +keyway_marker = K? +screwed_shaft_marker = C? +gearbox_specifier_opt_our = gearbox_specifier? +hollow_specifier_opt_our = hollow_specifier? +shafts_count_marker_opt_our = shafts_count_marker? +shafts_count_and_step_rate_any_order_1_t = shafts_count_marker_opt_our double_step_rate_marker +shafts_count_and_step_rate_any_order_2_t = double_step_rate_marker shafts_count_marker_opt_our +shafts_count_and_step_rate_any_order_t = shafts_count_and_step_rate_any_order_1_t / shafts_count_and_step_rate_any_order_2_t +stepper_suffix_tail = digit shafts_count_and_step_rate_any_order_t encoder_presence_marker unknown_marker_F keyway_marker screwed_shaft_marker gearbox_specifier_opt_our hollow_specifier_opt_our +stepper_modifiers_opt_our = stepper_modifiers_t? +stepper_t = stepper_marker stepper_modifiers_opt_our two_or_three_digit_number stepper_suffix_t +stepper_series_opt_our = stepper_series? +stepper_marker = S stepper_series_opt_our +permanent_t = permanent_marker two_digit_number stepper_suffix_t +brushless_marker = price_performance_or_unknown_C_marker rounded_marker brushless_marker_base brushless_flat_marker square_marker price_performance_or_unknown_C_marker +execution_configuration_t = Dash any_integer electrical_unit +brushless_modifier_variants = brushless_modifier_poles_torque / brushless_modifier_length_electronics_electrics +brushless_modifier_poles_torque = brushless_modifier_poles_torque_letter two_digit_number +brushless_modifier_length_electronics_electrics = two_or_three_digit_number brushless_tail_opt_our +brushless_tail_opt_our = brushless_tail? +brushless_t = brushless_marker brushless_modifier_variants +brushless_tail = brushless_electronic_tail / execution_configuration_t +execution_configuration_opt_our = execution_configuration_t? +brushless_electronic_tail = integrated_electronic_marker execution_configuration_opt_our + + +#fragmented +digit = RestOfDigits / Three +square_marker = S? +stepper_series = T / H +stepper_modifiers_t = (H / C) +price_performance_or_unknown_C_marker = C? +electrical_unit = A / V +shafts_count_marker = A / B +one_or_two_digit_number = digit digit? +two_digit_number = digit digit +three_digit_number = two_digit_number digit +two_or_three_digit_number = two_digit_number digit? +any_integer = digit+ +fractional_part = dot any_integer? +float_number = any_integer fractional_part? +integrated_electronic_marker = Dash I E +brushless_modifier_poles_torque_letter = A / B +three_phase_marker = Three P +hollow_specifier = Dash H + + +#characters +Three = '3' +RestOfDigits = ~r"[0-24-9]" +Dash = ~r"[–-]" +dot = '.' +A = 'A' +B = 'B' +C = 'C' +E = 'E' +F = 'F' +G = 'G' +H = 'H' +I = 'I' +K = 'K' +L = 'L' +M = 'M' +P = 'P' +R = 'R' +S = 'S' +T = 'T' +V = 'V' +W = 'W' + + +#tokens +fl = F L +permanent_marker = P M +brushless_marker_base = B L +rounded_marker = R? +brushless_flat_marker = W? + diff --git a/FullingMotorModelDecoder/parserBundle/compiled/waxeye/fulling_motor_name_parser.py b/FullingMotorModelDecoder/parserBundle/compiled/waxeye/fulling_motor_name_parser.py new file mode 100644 index 0000000..160c5ce --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/compiled/waxeye/fulling_motor_name_parser.py @@ -0,0 +1,235 @@ +# Generated by the Waxeye Parser Generator - version 0.8.1 +# www.waxeye.org + +from waxeye import Edge, State, FA, WaxeyeParser + +class Fulling_motor_nameParser (WaxeyeParser): + start = 0 + eof_check = True + automata = [FA("main", [State([Edge(75, 1, False), + Edge(46, 2, False)], False), + State([Edge(46, 2, False)], False), + State([Edge(2, 3, False)], False), + State([], True)], FA.LEFT), + FA("gearbox_specifier", [State([Edge(63, 1, False)], False), + State([Edge(49, 2, False)], False), + State([], True)], FA.LEFT), + FA("type_specific", [State([Edge(22, 1, False), + Edge(25, 1, False), + Edge(32, 1, False), + Edge(3, 1, False)], False), + State([], True)], FA.LEFT), + FA("three_phase_t", [State([Edge(52, 1, False)], False), + State([Edge(46, 2, False)], False), + State([Edge(4, 3, False)], False), + State([], True)], FA.LEFT), + FA("three_phase_suffix_opt_our", [State([Edge(5, 1, False)], True), + State([], True)], FA.LEFT), + FA("three_phase_suffix_t", [State([Edge(56, 1, False)], False), + State([Edge(44, 2, False)], False), + State([Edge(44, 3, False)], False), + State([Edge(16, 4, False)], False), + State([], True)], FA.LEFT), + FA("stepper_suffix_t", [State([Edge(56, 1, False)], False), + State([Edge(7, 2, False)], False), + State([], True)], FA.LEFT), + FA("suffix_with_or_without_tail", [State([Edge(8, 1, False), + Edge(20, 1, False)], False), + State([], True)], FA.LEFT), + FA("suffix_with_current", [State([Edge(45, 1, False)], False), + State([Edge(20, 2, False)], False), + State([], True)], FA.LEFT), + FA("double_step_rate_marker", [State([Edge(68, 1, False)], True), + State([], True)], FA.LEFT), + FA("encoder_presence_marker", [State([Edge(61, 1, False)], True), + State([], True)], FA.LEFT), + FA("unknown_marker_F", [State([Edge(62, 1, False)], True), + State([], True)], FA.LEFT), + FA("keyway_marker", [State([Edge(66, 1, False)], True), + State([], True)], FA.LEFT), + FA("screwed_shaft_marker", [State([Edge(60, 1, False)], True), + State([], True)], FA.LEFT), + FA("gearbox_specifier_opt_our", [State([Edge(1, 1, False)], True), + State([], True)], FA.LEFT), + FA("hollow_specifier_opt_our", [State([Edge(53, 1, False)], True), + State([], True)], FA.LEFT), + FA("shafts_count_marker_opt_our", [State([Edge(42, 1, False)], True), + State([], True)], FA.LEFT), + FA("shafts_count_and_step_rate_any_order_1_t", [State([Edge(16, 1, False)], False), + State([Edge(9, 2, False)], False), + State([], True)], FA.LEFT), + FA("shafts_count_and_step_rate_any_order_2_t", [State([Edge(9, 1, False)], False), + State([Edge(16, 2, False)], False), + State([], True)], FA.LEFT), + FA("shafts_count_and_step_rate_any_order_t", [State([Edge(17, 1, False), + Edge(18, 1, False)], False), + State([], True)], FA.LEFT), + FA("stepper_suffix_tail", [State([Edge(36, 1, False)], False), + State([Edge(19, 2, False)], False), + State([Edge(10, 3, False)], False), + State([Edge(11, 4, False)], False), + State([Edge(12, 5, False)], False), + State([Edge(13, 6, False)], False), + State([Edge(14, 7, False)], False), + State([Edge(15, 8, False)], False), + State([], True)], FA.LEFT), + FA("stepper_modifiers_opt_our", [State([Edge(39, 1, False)], True), + State([], True)], FA.LEFT), + FA("stepper_t", [State([Edge(24, 1, False)], False), + State([Edge(21, 2, False)], False), + State([Edge(46, 3, False)], False), + State([Edge(6, 4, False)], False), + State([], True)], FA.LEFT), + FA("stepper_series_opt_our", [State([Edge(38, 1, False)], True), + State([], True)], FA.LEFT), + FA("stepper_marker", [State([Edge(71, 1, False)], False), + State([Edge(23, 2, False)], False), + State([], True)], FA.LEFT), + FA("permanent_t", [State([Edge(76, 1, False)], False), + State([Edge(44, 2, False)], False), + State([Edge(6, 3, False)], False), + State([], True)], FA.LEFT), + FA("brushless_marker", [State([Edge(40, 1, False)], False), + State([Edge(78, 2, False)], False), + State([Edge(77, 3, False)], False), + State([Edge(79, 4, False)], False), + State([Edge(37, 5, False)], False), + State([Edge(40, 6, False)], False), + State([], True)], FA.LEFT), + FA("execution_configuration_t", [State([Edge(56, 1, False)], False), + State([Edge(47, 2, False)], False), + State([Edge(41, 3, False)], False), + State([], True)], FA.LEFT), + FA("brushless_modifier_variants", [State([Edge(29, 1, False), + Edge(30, 1, False)], False), + State([], True)], FA.LEFT), + FA("brushless_modifier_poles_torque", [State([Edge(51, 1, False)], False), + State([Edge(44, 2, False)], False), + State([], True)], FA.LEFT), + FA("brushless_modifier_length_electronics_electrics", [State([Edge(46, 1, False)], False), + State([Edge(31, 2, False)], False), + State([], True)], FA.LEFT), + FA("brushless_tail_opt_our", [State([Edge(33, 1, False)], True), + State([], True)], FA.LEFT), + FA("brushless_t", [State([Edge(26, 1, False)], False), + State([Edge(28, 2, False)], False), + State([], True)], FA.LEFT), + FA("brushless_tail", [State([Edge(35, 1, False), + Edge(27, 1, False)], False), + State([], True)], FA.LEFT), + FA("execution_configuration_opt_our", [State([Edge(27, 1, False)], True), + State([], True)], FA.LEFT), + FA("brushless_electronic_tail", [State([Edge(50, 1, False)], False), + State([Edge(34, 2, False)], False), + State([], True)], FA.LEFT), + FA("digit", [State([Edge(55, 1, False), + Edge(54, 1, False)], False), + State([], True)], FA.LEFT), + FA("square_marker", [State([Edge(71, 1, False)], True), + State([], True)], FA.LEFT), + FA("stepper_series", [State([Edge(72, 1, False), + Edge(64, 1, False)], False), + State([], True)], FA.LEFT), + FA("stepper_modifiers_t", [State([Edge(64, 1, False), + Edge(60, 1, False)], False), + State([], True)], FA.LEFT), + FA("price_performance_or_unknown_C_marker", [State([Edge(60, 1, False)], True), + State([], True)], FA.LEFT), + FA("electrical_unit", [State([Edge(58, 1, False), + Edge(73, 1, False)], False), + State([], True)], FA.LEFT), + FA("shafts_count_marker", [State([Edge(58, 1, False), + Edge(59, 1, False)], False), + State([], True)], FA.LEFT), + FA("one_or_two_digit_number", [State([Edge(36, 1, False)], False), + State([Edge(36, 2, False)], True), + State([], True)], FA.LEFT), + FA("two_digit_number", [State([Edge(36, 1, False)], False), + State([Edge(36, 2, False)], False), + State([], True)], FA.LEFT), + FA("three_digit_number", [State([Edge(44, 1, False)], False), + State([Edge(36, 2, False)], False), + State([], True)], FA.LEFT), + FA("two_or_three_digit_number", [State([Edge(44, 1, False)], False), + State([Edge(36, 2, False)], True), + State([], True)], FA.LEFT), + FA("any_integer", [State([Edge(36, 1, False)], False), + State([Edge(36, 1, False)], True)], FA.LEFT), + FA("fractional_part", [State([Edge(57, 1, False)], False), + State([Edge(47, 2, False)], True), + State([], True)], FA.LEFT), + FA("float_number", [State([Edge(47, 1, False)], False), + State([Edge(48, 2, False)], True), + State([], True)], FA.LEFT), + FA("integrated_electronic_marker", [State([Edge(56, 1, False)], False), + State([Edge(65, 2, False)], False), + State([Edge(61, 3, False)], False), + State([], True)], FA.LEFT), + FA("brushless_modifier_poles_torque_letter", [State([Edge(58, 1, False), + Edge(59, 1, False)], False), + State([], True)], FA.LEFT), + FA("three_phase_marker", [State([Edge(54, 1, False)], False), + State([Edge(69, 2, False)], False), + State([], True)], FA.LEFT), + FA("hollow_specifier", [State([Edge(56, 1, False)], False), + State([Edge(64, 2, False)], False), + State([], True)], FA.LEFT), + FA("three", [State([Edge("3", 1, False)], False), + State([], True)], FA.LEFT), + FA("restOfDigits", [State([Edge([(48, 50), (52, 57)], 1, False)], False), + State([], True)], FA.LEFT), + FA("dash", [State([Edge(["-", "–"], 1, False)], False), + State([], True)], FA.LEFT), + FA("dot", [State([Edge(".", 1, False)], False), + State([], True)], FA.LEFT), + FA("a", [State([Edge(["A", "a"], 1, False)], False), + State([], True)], FA.LEFT), + FA("b", [State([Edge(["B", "b"], 1, False)], False), + State([], True)], FA.LEFT), + FA("c", [State([Edge(["C", "c"], 1, False)], False), + State([], True)], FA.LEFT), + FA("e", [State([Edge(["E", "e"], 1, False)], False), + State([], True)], FA.LEFT), + FA("f", [State([Edge(["F", "f"], 1, False)], False), + State([], True)], FA.LEFT), + FA("g", [State([Edge(["G", "g"], 1, False)], False), + State([], True)], FA.LEFT), + FA("h", [State([Edge(["H", "h"], 1, False)], False), + State([], True)], FA.LEFT), + FA("i", [State([Edge(["I", "i"], 1, False)], False), + State([], True)], FA.LEFT), + FA("k", [State([Edge(["K", "k"], 1, False)], False), + State([], True)], FA.LEFT), + FA("l", [State([Edge(["L", "l"], 1, False)], False), + State([], True)], FA.LEFT), + FA("m", [State([Edge(["M", "m"], 1, False)], False), + State([], True)], FA.LEFT), + FA("p", [State([Edge(["P", "p"], 1, False)], False), + State([], True)], FA.LEFT), + FA("r", [State([Edge(["R", "r"], 1, False)], False), + State([], True)], FA.LEFT), + FA("s", [State([Edge(["S", "s"], 1, False)], False), + State([], True)], FA.LEFT), + FA("t", [State([Edge(["T", "t"], 1, False)], False), + State([], True)], FA.LEFT), + FA("v", [State([Edge(["V", "v"], 1, False)], False), + State([], True)], FA.LEFT), + FA("w", [State([Edge(["W", "w"], 1, False)], False), + State([], True)], FA.LEFT), + FA("fl", [State([Edge(62, 1, False)], False), + State([Edge(67, 2, False)], False), + State([], True)], FA.LEFT), + FA("permanent_marker", [State([Edge(69, 1, False)], False), + State([Edge(68, 2, False)], False), + State([], True)], FA.LEFT), + FA("brushless_marker_base", [State([Edge(59, 1, False)], False), + State([Edge(67, 2, False)], False), + State([], True)], FA.LEFT), + FA("rounded_marker", [State([Edge(70, 1, False)], True), + State([], True)], FA.LEFT), + FA("brushless_flat_marker", [State([Edge(74, 1, False)], True), + State([], True)], FA.LEFT)] + + def __init__(self): + WaxeyeParser.__init__(self, Fulling_motor_nameParser.start, Fulling_motor_nameParser.eof_check, Fulling_motor_nameParser.automata) + diff --git a/FullingMotorModelDecoder/parserBundle/schemas/__init__.py b/FullingMotorModelDecoder/parserBundle/schemas/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/schemas/capless/__init__.py b/FullingMotorModelDecoder/parserBundle/schemas/capless/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/schemas/capless/fulling_motor_name.json b/FullingMotorModelDecoder/parserBundle/schemas/capless/fulling_motor_name.json new file mode 100644 index 0000000..13ec580 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/schemas/capless/fulling_motor_name.json @@ -0,0 +1,105 @@ +{ + "main": { + "two_or_three_digit_number": "size", + "type_specific": "typed" + }, + "gearbox_specifier": { + "float_number": "ratio" + }, + "type_specific": { + "stepper_t": "stepper", + "permanent_t": "permanent", + "brushless_t": "brushless", + "three_phase_t": "three_phase" + }, + "three_phase_t": { + "three_phase_marker": "type_marker", + "two_or_three_digit_number": "motor_body_length", + "three_phase_suffix_opt_our": "suffix" + }, + "three_phase_suffix_t": { + "two_digit_number": "leads", + "shafts_count_marker_opt_our": "shafts_count" + }, + "stepper_suffix_t": { + "suffix_with_or_without_tail": "suffix_body" + }, + "suffix_with_or_without_tail": { + "suffix_with_current": "with_current", + "stepper_suffix_tail": "without_current" + }, + "suffix_with_current": { + "three_digit_number": "current", + "stepper_suffix_tail": "tail" + }, + "shafts_count_and_step_rate_any_order_1_t": { + "shafts_count_marker_opt_our": "shafts_count", + "double_step_rate_marker": "step_rate" + }, + "shafts_count_and_step_rate_any_order_2_t": { + "double_step_rate_marker": "step_rate", + "shafts_count_marker_opt_our": "shafts_count" + }, + "shafts_count_and_step_rate_any_order_t": { + "shafts_count_and_step_rate_any_order_1_t": "shafts_count_and_step_rate_any_order_1", + "shafts_count_and_step_rate_any_order_2_t": "shafts_count_and_step_rate_any_order_2" + }, + "stepper_suffix_tail": { + "digit": "variant", + "shafts_count_and_step_rate_any_order_t": "shafts_count_and_step_rate_any_order", + "encoder_presence_marker": "encoder", + "unknown_marker_F": "unknown_F", + "keyway_marker": "key_way", + "screwed_shaft_marker": "screwed_shaft", + "gearbox_specifier_opt_our": "gearbox", + "hollow_specifier_opt_our": "hollow" + }, + "stepper_t": { + "stepper_marker": "type_marker", + "stepper_modifiers_opt_our": "stepper_modifiers", + "two_or_three_digit_number": "motor_body_length", + "stepper_suffix_t": "suffix" + }, + "stepper_marker": { + "stepper_series_opt_our": "series" + }, + "permanent_t": { + "permanent_marker": "type_marker", + "two_digit_number": "motor_body_length", + "stepper_suffix_t": "suffix" + }, + "brushless_marker": { + "price_performance_or_unknown_C_marker": "is_unknown_C", + "rounded_marker": "is_round", + "brushless_flat_marker": "is_flat", + "square_marker": "is_square" + }, + "execution_configuration_t": { + "any_integer": "number", + "electrical_unit": "unit" + }, + "brushless_modifier_variants": { + "brushless_modifier_poles_torque": "poles_torque", + "brushless_modifier_length_electronics_electrics": "length_electronics_electrics" + }, + "brushless_modifier_poles_torque": { + "brushless_modifier_poles_torque_letter": "poles_or_other", + "two_digit_number": "variant" + }, + "brushless_modifier_length_electronics_electrics": { + "two_or_three_digit_number": "motor_body_length", + "brushless_tail_opt_our": "tail" + }, + "brushless_t": { + "brushless_marker": "type_marker", + "brushless_modifier_variants": "modifier" + }, + "brushless_tail": { + "brushless_electronic_tail": "electronic", + "execution_configuration_t": "no_electronic" + }, + "brushless_electronic_tail": { + "integrated_electronic_marker": "has_electronics", + "execution_configuration_opt_our": "cfg" + } +} \ No newline at end of file diff --git a/FullingMotorModelDecoder/parserBundle/schemas/iterless/__init__.py b/FullingMotorModelDecoder/parserBundle/schemas/iterless/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/schemas/iterless/fulling_motor_name.json b/FullingMotorModelDecoder/parserBundle/schemas/iterless/fulling_motor_name.json new file mode 100644 index 0000000..0637a08 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/schemas/iterless/fulling_motor_name.json @@ -0,0 +1 @@ +[] \ No newline at end of file diff --git a/FullingMotorModelDecoder/parserBundle/wrappers/__init__.py b/FullingMotorModelDecoder/parserBundle/wrappers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FullingMotorModelDecoder/parserBundle/wrappers/fulling_motor_name.py b/FullingMotorModelDecoder/parserBundle/wrappers/fulling_motor_name.py new file mode 100644 index 0000000..b12ddc7 --- /dev/null +++ b/FullingMotorModelDecoder/parserBundle/wrappers/fulling_motor_name.py @@ -0,0 +1,375 @@ +import typing +from UniGrammarRuntime.IWrapper import IWrapper, IParseResult + + +class main(IParseResult): + __slots__ = ("size", "typed") + + def __init__(self): + self.size = None + self.typed = None + + +class gearbox_specifier(IParseResult): + __slots__ = ("ratio",) + + def __init__(self): + self.ratio = None + + +class three_phase_t(IParseResult): + __slots__ = ("type_marker", "motor_body_length", "suffix") + + def __init__(self): + self.type_marker = None + self.motor_body_length = None + self.suffix = None + + +class three_phase_suffix_t(IParseResult): + __slots__ = ("current_per_phase_over_ten", "leads", "shafts_count") + + def __init__(self): + self.current_per_phase_over_ten = None + self.leads = None + self.shafts_count = None + + +class stepper_suffix_t(IParseResult): + __slots__ = ("suffix_body",) + + def __init__(self): + self.suffix_body = None + + +class suffix_with_current(IParseResult): + __slots__ = ("current", "tail") + + def __init__(self): + self.current = None + self.tail = None + + +class shafts_count_and_step_rate_any_order_1_t(IParseResult): + __slots__ = ("shafts_count", "step_rate") + + def __init__(self): + self.shafts_count = None + self.step_rate = None + + +class shafts_count_and_step_rate_any_order_2_t(IParseResult): + __slots__ = ("step_rate", "shafts_count") + + def __init__(self): + self.step_rate = None + self.shafts_count = None + + +class stepper_suffix_tail(IParseResult): + __slots__ = ("variant", "shafts_count_and_step_rate_any_order", "encoder", "unknown_F", "key_way", "screwed_shaft", "gearbox", "hollow") + + def __init__(self): + self.variant = None + self.shafts_count_and_step_rate_any_order = None + self.encoder = None + self.unknown_F = None + self.key_way = None + self.screwed_shaft = None + self.gearbox = None + self.hollow = None + + +class stepper_t(IParseResult): + __slots__ = ("type_marker", "stepper_modifiers", "motor_body_length", "suffix") + + def __init__(self): + self.type_marker = None + self.stepper_modifiers = None + self.motor_body_length = None + self.suffix = None + + +class stepper_marker(IParseResult): + __slots__ = ("series",) + + def __init__(self): + self.series = None + + +class permanent_t(IParseResult): + __slots__ = ("type_marker", "motor_body_length", "suffix") + + def __init__(self): + self.type_marker = None + self.motor_body_length = None + self.suffix = None + + +class brushless_marker(IParseResult): + __slots__ = ("is_price_performance", "is_round", "is_flat", "is_square", "is_unknown_C") + + def __init__(self): + self.is_price_performance = None + self.is_round = None + self.is_flat = None + self.is_square = None + self.is_unknown_C = None + + +class execution_configuration_t(IParseResult): + __slots__ = ("number", "unit") + + def __init__(self): + self.number = None + self.unit = None + + +class brushless_modifier_poles_torque(IParseResult): + __slots__ = ("poles_or_other", "variant") + + def __init__(self): + self.poles_or_other = None + self.variant = None + + +class brushless_modifier_length_electronics_electrics(IParseResult): + __slots__ = ("motor_body_length", "tail") + + def __init__(self): + self.motor_body_length = None + self.tail = None + + +class brushless_t(IParseResult): + __slots__ = ("type_marker", "modifier") + + def __init__(self): + self.type_marker = None + self.modifier = None + + +class brushless_electronic_tail(IParseResult): + __slots__ = ("has_electronics", "cfg") + + def __init__(self): + self.has_electronics = None + self.cfg = None + + +class mainParser(IWrapper): + __slots__ = () + + def process_main(self, parsed) -> main: + rec = main() + rec.size = self.backend.getSubTreeText(parsed.size) # type: str + rec.typed = self.process_type_specific(parsed.typed) # type: typing.Union[stepper_t, permanent_t, brushless_t, three_phase_t] + return rec + + def process_gearbox_specifier(self, parsed) -> gearbox_specifier: + rec = gearbox_specifier() + rec.ratio = self.backend.getSubTreeText(parsed.ratio) # type: str + return rec + + def process_type_specific(self, parsed) -> typing.Union[stepper_t, permanent_t, brushless_t, three_phase_t]: + stepper = getattr(parsed, "stepper", None) + if stepper is not None: + return self.process_stepper_t(stepper) + permanent = getattr(parsed, "permanent", None) + if permanent is not None: + return self.process_permanent_t(permanent) + brushless = getattr(parsed, "brushless", None) + if brushless is not None: + return self.process_brushless_t(brushless) + three_phase = getattr(parsed, "three_phase", None) + if three_phase is not None: + return self.process_three_phase_t(three_phase) + raise TypeError(dir(parsed)) + + def process_three_phase_t(self, parsed) -> three_phase_t: + rec = three_phase_t() + rec.type_marker = self.backend.getSubTreeText(parsed.type_marker) # type: str + rec.motor_body_length = self.backend.getSubTreeText(parsed.motor_body_length) # type: str + rec.suffix = self.process_three_phase_suffix_opt_our(getattr(parsed, "suffix", None)) # type: typing.Optional[three_phase_suffix_t] + return rec + + def process_three_phase_suffix_opt_our(self, parsed) -> typing.Optional[three_phase_suffix_t]: + return self.backend.enterOptional(parsed, self.process_three_phase_suffix_t) + + def process_three_phase_suffix_t(self, parsed) -> three_phase_suffix_t: + rec = three_phase_suffix_t() + rec.current_per_phase_over_ten = self.backend.getSubTreeText(parsed.current_per_phase_over_ten) # type: str + rec.leads = self.backend.getSubTreeText(parsed.leads) # type: str + rec.shafts_count = self.process_shafts_count_marker_opt_our(getattr(parsed, "shafts_count", None)) # type: typing.Optional[str] + return rec + + def process_stepper_suffix_t(self, parsed) -> stepper_suffix_t: + rec = stepper_suffix_t() + rec.suffix_body = self.process_suffix_with_or_without_tail(parsed.suffix_body) # type: typing.Union[suffix_with_current, stepper_suffix_tail] + return rec + + def process_suffix_with_or_without_tail(self, parsed) -> typing.Union[suffix_with_current, stepper_suffix_tail]: + with_current = getattr(parsed, "with_current", None) + if with_current is not None: + return self.process_suffix_with_current(with_current) + without_current = getattr(parsed, "without_current", None) + if without_current is not None: + return self.process_stepper_suffix_tail(without_current) + raise TypeError(dir(parsed)) + + def process_suffix_with_current(self, parsed) -> suffix_with_current: + rec = suffix_with_current() + rec.current = self.backend.getSubTreeText(parsed.current) # type: str + rec.tail = self.process_stepper_suffix_tail(parsed.tail) # type: stepper_suffix_tail + return rec + + def process_double_step_rate_marker(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.terminalNodeToStr) + + def process_encoder_presence_marker(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.terminalNodeToStr) + + def process_unknown_marker_F(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.terminalNodeToStr) + + def process_keyway_marker(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.terminalNodeToStr) + + def process_screwed_shaft_marker(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.terminalNodeToStr) + + def process_gearbox_specifier_opt_our(self, parsed) -> typing.Optional[gearbox_specifier]: + return self.backend.enterOptional(parsed, self.process_gearbox_specifier) + + def process_hollow_specifier_opt_our(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.getSubTreeText) + + def process_shafts_count_marker_opt_our(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.getSubTreeText) + + def process_shafts_count_and_step_rate_any_order_1_t(self, parsed) -> shafts_count_and_step_rate_any_order_1_t: + rec = shafts_count_and_step_rate_any_order_1_t() + rec.shafts_count = self.process_shafts_count_marker_opt_our(getattr(parsed, "shafts_count", None)) # type: typing.Optional[str] + rec.step_rate = self.process_double_step_rate_marker(getattr(parsed, "step_rate", None)) # type: typing.Optional[str] + return rec + + def process_shafts_count_and_step_rate_any_order_2_t(self, parsed) -> shafts_count_and_step_rate_any_order_2_t: + rec = shafts_count_and_step_rate_any_order_2_t() + rec.step_rate = self.process_double_step_rate_marker(getattr(parsed, "step_rate", None)) # type: typing.Optional[str] + rec.shafts_count = self.process_shafts_count_marker_opt_our(getattr(parsed, "shafts_count", None)) # type: typing.Optional[str] + return rec + + def process_shafts_count_and_step_rate_any_order_t(self, parsed) -> typing.Union[shafts_count_and_step_rate_any_order_1_t, shafts_count_and_step_rate_any_order_2_t]: + shafts_count_and_step_rate_any_order_1 = getattr(parsed, "shafts_count_and_step_rate_any_order_1", None) + if shafts_count_and_step_rate_any_order_1 is not None: + return self.process_shafts_count_and_step_rate_any_order_1_t(shafts_count_and_step_rate_any_order_1) + shafts_count_and_step_rate_any_order_2 = getattr(parsed, "shafts_count_and_step_rate_any_order_2", None) + if shafts_count_and_step_rate_any_order_2 is not None: + return self.process_shafts_count_and_step_rate_any_order_2_t(shafts_count_and_step_rate_any_order_2) + raise TypeError(dir(parsed)) + + def process_stepper_suffix_tail(self, parsed) -> stepper_suffix_tail: + rec = stepper_suffix_tail() + rec.variant = self.backend.getSubTreeText(parsed.variant) # type: str + rec.shafts_count_and_step_rate_any_order = self.process_shafts_count_and_step_rate_any_order_t(parsed.shafts_count_and_step_rate_any_order) # type: typing.Union[shafts_count_and_step_rate_any_order_1_t, shafts_count_and_step_rate_any_order_2_t] + rec.encoder = self.process_encoder_presence_marker(getattr(parsed, "encoder", None)) # type: typing.Optional[str] + rec.unknown_F = self.process_unknown_marker_F(getattr(parsed, "unknown_F", None)) # type: typing.Optional[str] + rec.key_way = self.process_keyway_marker(getattr(parsed, "key_way", None)) # type: typing.Optional[str] + rec.screwed_shaft = self.process_screwed_shaft_marker(getattr(parsed, "screwed_shaft", None)) # type: typing.Optional[str] + rec.gearbox = self.process_gearbox_specifier_opt_our(getattr(parsed, "gearbox", None)) # type: typing.Optional[gearbox_specifier] + rec.hollow = self.process_hollow_specifier_opt_our(getattr(parsed, "hollow", None)) # type: typing.Optional[str] + return rec + + def process_stepper_modifiers_opt_our(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.getSubTreeText) + + def process_stepper_t(self, parsed) -> stepper_t: + rec = stepper_t() + rec.type_marker = self.process_stepper_marker(parsed.type_marker) # type: stepper_marker + rec.stepper_modifiers = self.process_stepper_modifiers_opt_our(getattr(parsed, "stepper_modifiers", None)) # type: typing.Optional[str] + rec.motor_body_length = self.backend.getSubTreeText(parsed.motor_body_length) # type: str + rec.suffix = self.process_stepper_suffix_t(parsed.suffix) # type: stepper_suffix_t + return rec + + def process_stepper_series_opt_our(self, parsed) -> typing.Optional[str]: + return self.backend.enterOptional(parsed, self.backend.getSubTreeText) + + def process_stepper_marker(self, parsed) -> stepper_marker: + rec = stepper_marker() + rec.series = self.process_stepper_series_opt_our(getattr(parsed, "series", None)) # type: typing.Optional[str] + return rec + + def process_permanent_t(self, parsed) -> permanent_t: + rec = permanent_t() + rec.type_marker = self.backend.getSubTreeText(parsed.type_marker) # type: str + rec.motor_body_length = self.backend.getSubTreeText(parsed.motor_body_length) # type: str + rec.suffix = self.process_stepper_suffix_t(parsed.suffix) # type: stepper_suffix_t + return rec + + def process_brushless_marker(self, parsed) -> brushless_marker: + rec = brushless_marker() + rec.is_price_performance = self.backend.getSubTreeText(parsed.is_price_performance) # type: str + rec.is_round = self.backend.getSubTreeText(parsed.is_round) # type: str + rec.is_flat = self.backend.getSubTreeText(parsed.is_flat) # type: str + rec.is_square = self.backend.getSubTreeText(parsed.is_square) # type: str + rec.is_unknown_C = self.backend.getSubTreeText(parsed.is_unknown_C) # type: str + return rec + + def process_execution_configuration_t(self, parsed) -> execution_configuration_t: + rec = execution_configuration_t() + rec.number = self.backend.getSubTreeText(parsed.number) # type: str + rec.unit = self.backend.getSubTreeText(parsed.unit) # type: str + return rec + + def process_brushless_modifier_variants(self, parsed) -> typing.Union[brushless_modifier_poles_torque, brushless_modifier_length_electronics_electrics]: + poles_torque = getattr(parsed, "poles_torque", None) + if poles_torque is not None: + return self.process_brushless_modifier_poles_torque(poles_torque) + length_electronics_electrics = getattr(parsed, "length_electronics_electrics", None) + if length_electronics_electrics is not None: + return self.process_brushless_modifier_length_electronics_electrics(length_electronics_electrics) + raise TypeError(dir(parsed)) + + def process_brushless_modifier_poles_torque(self, parsed) -> brushless_modifier_poles_torque: + rec = brushless_modifier_poles_torque() + rec.poles_or_other = self.backend.getSubTreeText(parsed.poles_or_other) # type: str + rec.variant = self.backend.getSubTreeText(parsed.variant) # type: str + return rec + + def process_brushless_modifier_length_electronics_electrics(self, parsed) -> brushless_modifier_length_electronics_electrics: + rec = brushless_modifier_length_electronics_electrics() + rec.motor_body_length = self.backend.getSubTreeText(parsed.motor_body_length) # type: str + rec.tail = self.process_brushless_tail_opt_our(getattr(parsed, "tail", None)) # type: typing.Optional[typing.Union[brushless_electronic_tail, execution_configuration_t]] + return rec + + def process_brushless_tail_opt_our(self, parsed) -> typing.Optional[typing.Union[brushless_electronic_tail, execution_configuration_t]]: + return self.backend.enterOptional(parsed, self.process_brushless_tail) + + def process_brushless_t(self, parsed) -> brushless_t: + rec = brushless_t() + rec.type_marker = self.process_brushless_marker(parsed.type_marker) # type: brushless_marker + rec.modifier = self.process_brushless_modifier_variants(parsed.modifier) # type: typing.Union[brushless_modifier_poles_torque, brushless_modifier_length_electronics_electrics] + return rec + + def process_brushless_tail(self, parsed) -> typing.Union[brushless_electronic_tail, execution_configuration_t]: + electronic = getattr(parsed, "electronic", None) + if electronic is not None: + return self.process_brushless_electronic_tail(electronic) + no_electronic = getattr(parsed, "no_electronic", None) + if no_electronic is not None: + return self.process_execution_configuration_t(no_electronic) + raise TypeError(dir(parsed)) + + def process_execution_configuration_opt_our(self, parsed) -> typing.Optional[execution_configuration_t]: + return self.backend.enterOptional(parsed, self.process_execution_configuration_t) + + def process_brushless_electronic_tail(self, parsed) -> brushless_electronic_tail: + rec = brushless_electronic_tail() + rec.has_electronics = self.backend.getSubTreeText(parsed.has_electronics) # type: str + rec.cfg = self.process_execution_configuration_opt_our(getattr(parsed, "cfg", None)) # type: typing.Optional[execution_configuration_t] + return rec + + __MAIN_PRODUCTION__ = process_main + + +__MAIN_PARSER__ = mainParser diff --git a/FullingMotorModelDecoder/py.typed b/FullingMotorModelDecoder/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..20f0fa8 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,4 @@ +include UNLICENSE +include *.md +include tests +include .editorconfig diff --git a/ReadMe.md b/ReadMe.md new file mode 100644 index 0000000..2a83599 --- /dev/null +++ b/ReadMe.md @@ -0,0 +1,23 @@ +FullingMotorModelDecoder.py [![Unlicensed work](https://raw.githubusercontent.com/unlicense/unlicense.org/master/static/favicon.png)](https://unlicense.org/) +=========================== +~~[wheel (GitLab)](https://gitlab.com/KOLANICH-libs/FullingMotorModelDecoder.py/-/jobs/artifacts/master/raw/dist/FullingMotorModelDecoder-0.CI-py3-none-any.whl?job=build)~~ +[wheel (GHA via `nightly.link`)](https://nightly.link/KOLANICH-libs/FullingMotorModelDecoder.py/workflows/CI/master/FullingMotorModelDecoder-0.CI-py3-none-any.whl) +~~![GitLab Build Status](https://gitlab.com/KOLANICH-libs/FullingMotorModelDecoder.py/badges/master/pipeline.svg)~~ +~~![GitLab Coverage](https://gitlab.com/KOLANICH-libs/FullingMotorModelDecoder.py/badges/master/coverage.svg)~~ +[![GitHub Actions](https://github.com/KOLANICH-libs/FullingMotorModelDecoder.py/workflows/CI/badge.svg)](https://github.com/KOLANICH-libs/FullingMotorModelDecoder.py/actions/) +[![Libraries.io Status](https://img.shields.io/librariesio/github/KOLANICH-libs/FullingMotorModelDecoder.py.svg)](https://libraries.io/github/KOLANICH-libs/FullingMotorModelDecoder.py) + +This is a library to decode motor model numbers of Changzhou Fulling Motor Co., Ltd motors and gearboxes. + +Motors dataset [on csvbase](https://csvbase.com/KOLANICH/FullingMotors-motors). + +!!!! Currently doesn't fully work !!!! + +Docs on the format: +* [Delta Line Full Catalogue 2020-05](https://lotax.se/images/pdfs/Delta_Line_-_Fulling_Full_Catalogue_Edition_2020-05.pdf) (search `Codification`) +* [Catalogue 2018](https://www.europages.com/filestore/gallery/61/b7/15265927_7b1595da.pdf) (search `Codification`) +* https://andrives.se/onewebmedia/emb%20FL%20stepper%20katalog.pdf + +The docs seem to be not describing the actual format used and docs from different sourcess seem to contradict each other. Had to reverse engineer from samples. + + diff --git a/UNLICENSE b/UNLICENSE new file mode 100644 index 0000000..efb9808 --- /dev/null +++ b/UNLICENSE @@ -0,0 +1,24 @@ +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to diff --git a/fulling_motor_name.yug b/fulling_motor_name.yug new file mode 100644 index 0000000..234ab48 --- /dev/null +++ b/fulling_motor_name.yug @@ -0,0 +1,436 @@ +meta: + id: fulling_motor_name + title: Changzhou Fulling Motor Co., Ltd. model nameber + license: Unlicense + class: regular +doc: A grammar for parsing Changzhou Fulling Motor Co., Ltd. model namebers + +chars: + - id: Three + lit: "3" + - id: RestOfDigits + alt: + - range: ["0", "2"] + - range: ["4", "9"] + - id: Dash + alt: + - lit: '-' + - lit: '–' + - id: dot + lit: "." + - id: A + lit: A + - id: B + lit: B + - id: C + lit: C + - id: E + lit: E + - id: F + lit: F + - id: G + lit: G + - id: H + lit: H + - id: I + lit: I + - id: K + lit: K + - id: L + lit: L + - id: M + lit: M + - id: P + lit: P + - id: R + lit: R + - id: S + lit: S + - id: T + lit: T + - id: V + lit: V + - id: W + lit: W + +tokens: + - id: fl + seq: + - ref: F + - ref: L + - id: permanent_marker + seq: + - ref: P + - ref: M + - id: brushless_marker_base + seq: + - ref: B + - ref: L + + - id: rounded_marker + opt: + ref: R + + - id: brushless_flat_marker + opt: + ref: W + + +fragmented: + - id: digit + alt: + - ref: RestOfDigits + - ref: Three + + - id: square_marker + opt: + ref: S + + - id: stepper_series + alt: + - cap: standard + ref: T + - cap: hybrid + ref: H + + - id: stepper_modifiers_t + cap: stepper_modifiers + alt: + - ref: H # high_torque + - ref: C # hyper_torque (a.k.a hyper_step, but the docs says that it's just torque higher than high-torque) + + - id: price_performance_or_unknown_C_marker + opt: + ref: C + + - id: electrical_unit + alt: + - ref: A + - ref: V + + - id: shafts_count_marker + alt: + - ref: A + - ref: B + + - id: one_or_two_digit_number + seq: + - ref: digit + - opt: + ref: digit + prefer: shift + + - id: two_digit_number + seq: + - ref: digit + - ref: digit + # max: 2 # BUG: emits 1 digit + - id: three_digit_number + seq: + - ref: two_digit_number + - ref: digit + + - id: two_or_three_digit_number + seq: + - ref: two_digit_number + - opt: + ref: digit + prefer: shift + + - id: any_integer + ref: digit + min: 1 + + - id: fractional_part + seq: + - ref: dot + - opt: + ref: any_integer + + - id: float_number + seq: + - ref: any_integer + - opt: + ref: fractional_part + + - id: integrated_electronic_marker + seq: + - ref: Dash + - ref: I + - ref: E + + - id: brushless_modifier_poles_torque_letter # usually determines count of poles, A models have more poles (usually 10) than non-lettered models (usually 8), B models have more poles (usually 6) than non-lettered models, but some B models have no A analogues and have 8 poles and C models usually have no analogues and also have 8 poles. + alt: + - ref: A + - ref: B + + - id: three_phase_marker + seq: + - ref: Three + - ref: P + + - id: hollow_specifier + seq: + - ref: Dash + - ref: H + +prods: + - id: main + seq: + - uncap: + opt: + ref: fl + - cap: size + ref: two_or_three_digit_number + - ref: type_specific + cap: typed + + - spacer: 1 + + - id: gearbox_specifier + seq: + - uncap: + ref: G + - cap: ratio + ref: float_number + + - id: type_specific + alt: + - cap: stepper + ref: stepper_t + - cap: permanent + ref: permanent_t + - cap: brushless + ref: brushless_t + - cap: three_phase + ref: three_phase_t + + - id: three_phase_t + seq: + - cap: type_marker + ref: three_phase_marker + - cap: motor_body_length + ref: two_or_three_digit_number + - cap: suffix + ref: three_phase_suffix_opt_our + + - id: three_phase_suffix_opt_our + opt: + ref: three_phase_suffix_t + + - id: three_phase_suffix_t + seq: + - uncap: + ref: Dash + - cap: current_per_phase_over_ten + ref: two_digit_number + - cap: leads + ref: two_digit_number + - cap: shafts_count + ref: shafts_count_marker_opt_our + + - id: stepper_suffix_t + seq: + - uncap: + ref: Dash + - cap: suffix_body + ref: suffix_with_or_without_tail + + - id: suffix_with_or_without_tail + alt: + - cap: with_current + ref: suffix_with_current + - cap: without_current + ref: stepper_suffix_tail + + - id: suffix_with_current + seq: + - cap: current + ref: three_digit_number + - cap: tail + ref: stepper_suffix_tail + + + - id: double_step_rate_marker + opt: + ref: M + + - id: encoder_presence_marker + opt: + ref: E + + - id: unknown_marker_F + opt: + ref: F + + - id: keyway_marker + opt: + ref: K + + - id: screwed_shaft_marker + opt: + ref: C + + - id: gearbox_specifier_opt_our + opt: + ref: gearbox_specifier + + - id: hollow_specifier_opt_our + opt: + ref: hollow_specifier + + - id: shafts_count_marker_opt_our + opt: + ref: shafts_count_marker + + - id: shafts_count_and_step_rate_any_order_1_t + seq: + - cap: shafts_count + ref: shafts_count_marker_opt_our + - ref: double_step_rate_marker + cap: step_rate + + - id: shafts_count_and_step_rate_any_order_2_t + seq: + - ref: double_step_rate_marker + cap: step_rate + - cap: shafts_count + ref: shafts_count_marker_opt_our + + - id: shafts_count_and_step_rate_any_order_t + alt: + - cap: shafts_count_and_step_rate_any_order_1 + ref: shafts_count_and_step_rate_any_order_1_t + - cap: shafts_count_and_step_rate_any_order_2 + ref: shafts_count_and_step_rate_any_order_2_t + + - id: stepper_suffix_tail + seq: + - cap: variant # usually determines rated voltage, resistance and phase current + # For some models determines input count! + ref: digit + - cap: shafts_count_and_step_rate_any_order + ref: shafts_count_and_step_rate_any_order_t + - ref: encoder_presence_marker + cap: encoder + - ref: unknown_marker_F + cap: unknown_F + - ref: keyway_marker + cap: key_way + - ref: screwed_shaft_marker + cap: screwed_shaft + - cap: gearbox + ref: gearbox_specifier_opt_our + - cap: hollow + ref: hollow_specifier_opt_our + + - id: stepper_modifiers_opt_our + opt: + ref: stepper_modifiers_t + + + - id: stepper_t + seq: + - cap: type_marker + ref: stepper_marker + - cap: stepper_modifiers + ref: stepper_modifiers_opt_our + - cap: motor_body_length + ref: two_or_three_digit_number + - cap: suffix + ref: stepper_suffix_t + + - id: stepper_series_opt_our + opt: + ref: stepper_series + prefer: shift + + - id: stepper_marker + seq: + - uncap: + ref: S + - cap: series + ref: stepper_series_opt_our + + - id: permanent_t + seq: + - cap: type_marker + ref: permanent_marker + - cap: motor_body_length + ref: two_digit_number + - cap: suffix + ref: stepper_suffix_t + + - id: brushless_marker + seq: + - cap: is_price_performance + ref: price_performance_or_unknown_C_marker + - cap: is_round + ref: rounded_marker + - uncap: + ref: brushless_marker_base + - cap: is_flat + ref: brushless_flat_marker + - cap: is_square + ref: square_marker + - cap: is_unknown_C + ref: price_performance_or_unknown_C_marker + + - id: execution_configuration_t + seq: + - uncap: + ref: Dash + - cap: number + ref: any_integer + - cap: unit + ref: electrical_unit + + - id: brushless_modifier_variants + alt: + - cap: poles_torque + ref: brushless_modifier_poles_torque + - cap: length_electronics_electrics + ref: brushless_modifier_length_electronics_electrics + + - id: brushless_modifier_poles_torque + seq: + - cap: poles_or_other + ref: brushless_modifier_poles_torque_letter + - cap: variant # determines torque, sometimes it is arythm progression, but not always + ref: two_digit_number + + - id: brushless_modifier_length_electronics_electrics + seq: + - cap: motor_body_length + ref: two_or_three_digit_number + - cap: tail + ref: brushless_tail_opt_our + + - id: brushless_tail_opt_our + opt: + ref: brushless_tail + + - id: brushless_t + seq: + - cap: type_marker + ref: brushless_marker + - cap: modifier + ref: brushless_modifier_variants + + - id: brushless_tail + alt: + - cap: electronic + ref: brushless_electronic_tail + - cap: no_electronic + ref: execution_configuration_t + + - id: execution_configuration_opt_our + opt: + ref: execution_configuration_t + + - id: brushless_electronic_tail + seq: + - cap: has_electronics + ref: integrated_electronic_marker + - cap: cfg + ref: execution_configuration_opt_our diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..c51f91e --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,46 @@ +[build-system] +requires = ["setuptools>=61.2.0", "setuptools_scm[toml]>=3.4.3"] +build-backend = "setuptools.build_meta" + +[project] +name = "FullingMotorModelDecoder" +readme = "ReadMe.md" +description = "" +authors = [{name = "KOLANICH"}] +classifiers = [ + "Development Status :: 4 - Beta", + "Environment :: Other Environment", + "Intended Audience :: Developers", + "License :: Public Domain", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3 :: Only", + "Topic :: Software Development :: Libraries :: Python Modules", +] +keywords = ["FullingMotorModelDecoder"] +license = {text = "Unlicense"} +requires-python = ">=3.4" +dynamic = ["version"] + +dependencies = [ + "antlr4", # https://github.com/antlr/antlr4/tree/master/runtime/Python3, + "UniGrammarRuntime" +] + +[project.optional-dependencies] +test = [ + "parameterized", # @ git+https://github.com/wolever/parameterized.git +] + +[project.urls] +Homepage = "https://github.com/KOLANICH-libs/FullingMotorModelDecoder.py" +Motors dataset = "https://csvbase.com/KOLANICH/FullingMotors-motors" + +[tool.setuptools] +zip-safe = true + +[tool.setuptools.packages.find] +include = ["FullingMotorModelDecoder", "FullingMotorModelDecoder.*"] + +[tool.setuptools_scm] diff --git a/tests/gearboxes.tsv b/tests/gearboxes.tsv new file mode 100644 index 0000000..77ab8d3 --- /dev/null +++ b/tests/gearboxes.tsv @@ -0,0 +1,44 @@ +model high_torque price_performance +GP42-S1-3.93 +GP42-S1-4.27 +GP42-S1-5.25 +GP42-S1-6.00 +GP42-S1-7.07 +GP42-S1-8.73 +GP42-S2-15.45 +GP42-S2-20.63 +GP42-S2-25.61 +GP42-S2-45.82 +GP56-S1-3.29 +GP56-S1-3.93 +GP56-S1-4.24 +GP56-S1-5.08 +GP56-S1-6.53 +GP56-S1-7.71 +GP56-S1-9.55 +GP56-S2-10.84 +GP56-S2-15.51 +GP56-S2-20.03 +GP56-S2-25.71 +GP56-S2-32.69 +GP56-S2-42.63 +GP56-S2-62.33 +GP56-T1-3.29 1 +GP56-T1-3.93 1 +GP56-T1-4.24 1 +GP56-T1-5.08 1 +GP56-T1-6.53 1 +GP56-T1-7.71 1 +GP56-T1-9.55 1 +GP56-T2-10.84 1 +GP56-T2-15.51 1 +GP56-T2-20.03 1 +GP56-T2-25.71 1 +GP56-T2-32.69 1 +GP56-T2-42.63 1 +GP56-T2-62.33 1 +22JMS 1 +28JMS 1 +36JMS 1 +42JMS 1 +56JMS 1 diff --git a/tests/motors.tsv b/tests/motors.tsv new file mode 100644 index 0000000..250e3b7 --- /dev/null +++ b/tests/motors.tsv @@ -0,0 +1,408 @@ +name type series high_torque hyper_torque price_performance shape flat triple_plug electronics angle_hall_effect angle_step angle_step_accuracy controller_length current_peak_max current_per_phase current_rated current_unloaded dielectric_strength dielectric_strength_current_through_isolation dielectric_strength_rate_current_type dielectric_strength_rate_time force_axial_max force_radial_max force_radial_max_rate_distance gearbox inductance_line_to_line inductance_per_phase input_count insulation_class insulation_resistance (500 V, DC) length_motor_body length_centering phase_count play_shaft_axial_max (450 g load) play_shaft_radial_max (450 g load) pole_count resistance_line_to_line resistance_per_phase rotor_inertia rpm_rated shaft_run_out temperature_ambient_max temperature_ambient_min temperature_rise_max (current_rated. 2 phase on) torque_constant torque_detent torque_holding torque_peak_max torque_rated voltage_rated weight winding_type resistance_accuracy inductance_accuracy voltage_per_phase thread +24CBL30 b 0 1 r 0 0 120 0.9 0.3 190 500 DC 60 4 4 10 1.7 B 100 30 1.5 3 0.06 0.02 6 7.3 2.3 4000 0.025 0.02 0.017 0.006 12 0.1 +28CBL38 b 0 1 r 0 0 120 2.3 0.6 130 500 DC 60 4 4 10 2.48 B 100 38 2.6 3 0.06 0.02 8 5.69 5.8 4000 0.025 0.047 0.084 0.028 24 0.1 +36CBL30 b 0 1 r 0 0 120 1.4 0.44 150 600 AC 1 10 15 10 3.3 B 100 30 4.3 3 0.08 0.02 8 5.1 6 4800 0.025 0.036 0.05 0.016 24 0.12 +36CBL40 b 0 1 r 0 0 120 3 1 230 600 AC 1 10 15 10 2 B 100 40 4.5 3 0.08 0.02 8 2 12 4800 0.025 0.035 0.11 0.035 24 0.18 +36CBL57 b 0 1 r 0 0 120 5.3 1.89 270 600 AC 1 10 15 10 1.2 B 100 57 4.5 3 0.08 0.02 8 1.1 27 4500 0.025 0.037 0.21 0.07 24 0.25 +36CBL60 b 0 1 r 0 0 120 6.5 2.29 220 600 AC 1 10 15 10 1 B 100 60 4.3 3 0.08 0.02 8 0.9 30 4800 0.025 0.035 0.24 0.08 24 0.3 +42CBL60 b 0 1 r 0 0 120 6.6 2.13 430 500 DC 60 10 15 10 0.63 B 100 60 4.3 3 0.08 0.02 4 0.66 44 5900 0.025 0.032 0.2 0.068 24 0.35 +36CBL30-IE b 0 1 r 1 120 0 0.47 120 1.4 600 AC 1 10 15 10 5.5 B 100 30 4.5 3 0.08 0.02 8 7.8 6 4800 0.025 0.034 0.05 0.016 24 0.12 +36CBL40-IE b 0 1 r 1 120 0 0.95 230 3 600 AC 1 10 15 10 2.6 B 100 40 4.5 3 0.08 0.02 8 2.7 12 4800 0.025 0.037 0.11 0.035 24 0.18 +36CBL57-IE b 0 1 r 1 120 0 1.71 260 5.3 600 AC 1 10 15 10 1.6 B 100 57 4.5 3 0.08 0.02 8 1.3 27 4500 0.025 0.041 0.21 0.07 24 0.25 +36CBL60-IE b 0 1 r 1 120 0 2.11 200 6.5 600 AC 1 10 15 10 1.3 B 100 60 4.5 3 0.08 0.02 8 0.9 30 4800 0.025 0.038 0.24 0.08 24 0.3 +42CBL60-IE b 0 1 r 1 120 0 2.13 250 6.6 500 DC 60 10 15 10 0.75 B 100 60 4.4 3 0.08 0.02 4 0.82 44 5900 0.025 0.032 0.2 0.068 24 0.35 +42RBL60-IE b 0 1 r 1 120 32 2.11 230 5 500 DC 60 10 15 10 1.94 B 100 60 3 3 0.08 0.02 8 1.6 48 4000 0.025 0.038 0.19 0.08 24 0.5 +57BL54-IE b 0 1 r 1 120 48.4 1.8 300 6.8 500 AC 60 15 75 10 4.4 B 100 53.6 2 3 0.025 0.025 4 1.5 75 4000 0.025 0.061 0.39 0.11 36 0.44 +57BL74-IE b 0 1 r 1 120 48.4 12 3.67 400 500 AC 60 15 75 10 2 B 100 73.6 2 3 0.025 0.025 4 0.58 119 4000 0.025 0.06 0.7 0.22 36 0.72 +57BL94-IE b 0 1 r 1 120 39.9 5.08 450 16 500 AC 60 15 75 10 1.5 B 100 93.6 2 3 0.025 0.025 4 0.45 173 4000 0.025 0.065 1 0.33 36 0.95 +22BL45 b 0 r 0 0 120 1.1 0.26 150 360 AC 1 2 10 10 6.2 B 100 45 2 3 0.08 0.02 8 23 0.66 4600 0.025 0.0302 0.024 0.008 24 0.07 +22BL70 b 0 r 0 0 120 2 0.56 120 360 AC 1 2 10 10 4.2 B 100 68 2 3 0.08 0.02 8 11.6 1.32 3800 0.025 0.0355 0.06 0.02 24 0.12 +28BL26 b 0 r 0 0 120 1.3 0.35 200 360 AC 60 2 10 10 2.3 B 100 26 3 3 0.08 0.02 4 8.2 2.35 8000 0.025 0.0143 0.015 0.005 15 0.06 +28BL38 b 0 r 0 0 120 2 0.67 200 360 AC 60 2 10 10 7.4 B 100 38 3 3 0.08 0.02 4 20.5 3.69 3100 0.025 0.024 0.048 0.016 24 0.082 +28BL77 b 0 r 0 0 120 3 1 150 360 AC 60 2 10 10 2.2 B 100 77 3 3 0.08 0.02 4 4.67 10.98 3100 0.025 0.05 0.15 0.05 24 0.28 +33BL38 b 0 r 0 0 120 1.45 0.48 100 500 DC 60 2 10 10 7 B 100 38 1.5 3 0.08 0.02 4 14.2 7.95 3000 0.025 0.046 0.066 0.022 24 0.085 STAR CONNECTION +33BL80 b 0 r 0 0 120 4.8 2.17 450 500 DC 60 2 10 10 0.55 B 100 80 1.5 3 0.08 0.02 4 0.86 23.55 7800 0.025 0.023 0.15 0.05 24 0.2 STAR CONNECTION +36RBL40 b 0 r 0 0 120 3.7 1.13 270 500 DC 60 10 15 10 2.1 B 100 40 2 3 0.08 0.02 8 2.4 14 4800 0.025 0.032 0.1 0.036 24 0.16 +36RBL57 b 0 r 0 0 120 4.1 1.28 340 500 DC 60 10 15 10 2 B 100 57 2 3 0.08 0.02 8 2 24 4500 0.025 0.039 0.15 0.05 24 0.25 +40BL26-12V b 0 r 0 0 120 13.4 5.06 522 500 AC 1 5 15 10 0.11 F 100 26 1.5 3 0.15 0.02 14 0.28 10.5 9660 0.05 0.0085 0.12 0.043 12 0.17 +40BL26-24V b 0 r 0 0 120 9.35 3.06 285 500 AC 1 5 15 10 0.39 F 100 26 1.5 3 0.15 0.02 14 0.5 10.5 10300 0.05 0.017 0.16 0.052 24 0.17 +40BL36-18V b 0 r 0 0 120 12.3 4.06 354 500 AC 1 5 15 10 0.18 F 100 36 1.5 3 0.15 0.02 14 0.34 24.2 8230 0.05 0.017 0.21 0.069 18 0.24 +40BL36-36V b 0 r 0 0 120 7.5 2.44 192 500 AC 1 5 15 10 0.64 F 100 36 1.5 3 0.15 0.02 14 0.84 24.2 8740 0.05 0.034 0.25 0.083 36 0.24 +42RBL30 b 0 r 0 0 120 1.7 0.51 160 500 DC 60 10 15 10 5.1 B 100 30 2.7 3 0.08 0.02 8 5.9 15.6 4000 0.025 0.039 0.06 0.02 24 0.25 +42RBL60 b 0 r 0 0 120 4.4 1.58 230 500 DC 60 10 15 10 1.94 B 100 60 2.7 3 0.08 0.02 8 1.6 33 4000 0.025 0.038 0.18 0.06 24 0.4 +42RBL85 b 0 r 0 0 120 11.4 4.17 280 500 DC 60 10 15 10 0.86 B 100 85 2.7 3 0.08 0.02 8 0.71 84 4000 0.025 0.036 0.45 0.15 24 0.7 +57BL116 b 0 r 0 0 120 21 7.1 540 500 AC 60 15 75 10 0.95 B 100 113.6 2 3 0.025 0.025 4 0.35 230 4000 0.025 0.062 1.27 0.44 36 1.2 +57BL45 b 0 r 0 0 120 3.5 1.06 240 500 AC 60 15 75 10 10 B 100 43.6 2 3 0.025 0.025 4 4.1 30 4000 0.025 0.052 0.16 0.055 36 0.33 +57BL54 b 0 r 0 0 120 6.8 1.8 300 500 AC 60 15 75 10 4.4 B 100 53.6 2 3 0.025 0.025 4 1.5 75 4000 0.025 0.061 0.39 0.11 36 0.44 +57BL74 b 0 r 0 0 120 12 3.67 400 500 AC 60 15 75 10 2 B 100 73.6 2 3 0.025 0.025 4 0.58 119 4000 0.025 0.06 0.7 0.22 36 0.72 +57BL94 b 0 r 0 0 120 16 5.08 450 500 AC 60 15 75 10 1.5 B 100 93.6 2 3 0.025 0.025 4 0.45 173 4000 0.025 0.065 1 0.33 36 0.95 +57BLA01 b 0 r 0 0 120 8.6 2.86 350 500 AC 60 45 115 10 1.2 F 100 53.6 2 3 0.025 0.025 6 0.95 275 4000 0.025 0.07 0.6 0.2 36 0.52 +57BLA02 b 0 r 0 0 120 16 5.71 400 500 AC 60 45 115 10 0.55 F 100 73.6 2 3 0.025 0.025 6 0.4 375 4000 0.025 0.07 1.2 0.4 36 0.75 +57BLA03 b 0 r 0 0 120 29 10 580 500 AC 60 45 115 10 0.4 F 100 93.6 2 3 0.025 0.025 6 0.25 510 4000 0.025 0.06 1.8 0.6 36 1 +57BLA04 b 0 r 0 0 120 35 11.43 240 500 AC 60 45 115 10 0.25 F 100 113.6 2 3 0.025 0.025 6 0.2 693 4000 0.025 0.07 2.4 0.8 36 1.25 +20BLW14-12V b 0 r 1 0 120 1.62 0.63 230 500 DC 60 2 5 10 0.7 B 100 14 1 3 0.08 0.02 8 6.9 5.1 5170 0.025 0.012 0.019 0.0075 12 0.023 +20BLW14-24V b 0 r 1 0 120 0.85 0.32 120 500 DC 60 2 5 10 2.8 B 100 14 1 3 0.08 0.02 8 25.8 5.1 5220 0.025 0.024 0.02 0.0077 24 0.023 +32BLW18-12V b 0 r 1 0 17.9 3.1 +32BLW18-24V b 0 r 1 0 120 1.7 0.51 100 250 AC 60 4 14 10 7.7 B 100 17.9 3.1 3 0.06 0.02 8 13 35 2760 0.03 0.051 0.075 0.026 24 0.05 +32BLW18-48V b 0 r 1 0 120 0.97 0.26 90 250 AC 60 4 14 10 28 B 100 17.9 3.1 3 0.06 0.02 8 53 35 2950 0.03 0.096 0.075 0.025 48 0.05 +32BLW18-9V b 0 r 1 0 120 3.4 1.09 290 250 AC 60 4 14 10 1.6 B 100 17.9 3.1 3 0.06 0.02 8 3 35 2100 0.03 0.023 0.075 0.025 9 0.05 +45BLW16 b 0 r 1 0 120 6.3 2.12 320 500 DC 60 10 28 10 0.34 B 100 16 3.2 3 0.14 0.02 16 0.9 92.5 2910 0.03 0.026 0.16 0.055 12 0.08 +45BLW18 b 0 r 1 0 120 4.8 1.61 250 500 DC 60 10 28 10 0.59 B 100 18 3.2 3 0.14 0.02 16 1.83 100 5000 0.03 0.031 0.15 0.05 24 0.08 +45BLW21 b 0 r 1 0 120 7 2.55 380 500 DC 60 10 28 10 0.33 B 100 21 3.2 3 0.14 0.02 16 0.8 135 5260 0.03 0.033 0.25 0.084 24 0.12 +45BLW27 b 0 r 1 0 120 10 3.51 430 500 DC 60 10 28 10 0.27 B 100 27 3.2 3 0.14 0.02 16 0.61 180 4840 0.03 0.037 0.39 0.13 24 0.15 +60BLW40-24V b 0 r 1 0 120 18 6 800 500 DC 60 10 28 10 0.3 B 100 42 2.5 3 0.14 0.02 14 0.3 1500 3700 0.025 0.05 0.9 0.3 24 0.5 +60BLW40-48V b 0 r 1 0 120 9 3 400 500 DC 60 10 28 10 1.4 B 100 42 2.5 3 0.14 0.02 14 1.1 1500 3700 0.025 0.1 0.9 0.3 48 0.5 +60BLWA38 b 0 r 1 0 120 14 4.6 500 600 DC 1 10 28 10 0.6 B 100 39 0 3 0.08 0.02 14 0.59 1100 3400 0.025 0.108 1.5 0.5 48 0.5 +90BLW27-24V b 0 r 1 0 120 23 6.82 650 500 AC 60 45 110 10 0.19 B 100 27 5.4 3 0.08 0.02 22 0.21 3000 2720 0.05 0.067 1.8 0.457 24 0.6 +90BLW27-36V b 0 r 1 0 120 14.5 5.09 420 500 AC 60 45 110 10 0.5 B 100 27 5.4 3 0.08 0.02 22 0.5 3000 2510 0.05 0.11 1.8 0.56 36 0.6 +90BLW27-48V b 0 r 1 0 120 7.5 2.42 300 500 AC 60 45 110 10 2 B 100 27 5.4 3 0.08 0.02 22 2.1 3000 1610 0.05 0.22 1.8 0.533 48 0.6 +90BLW27-60V b 0 r 1 0 120 7.5 2.19 260 500 AC 60 45 110 10 1.8 B 100 27 5.4 3 0.08 0.02 22 2 3000 2200 0.05 0.21 1.8 0.46 60 0.6 +90BLW40-48V b 0 r 1 0 120 13 4 280 500 AC 60 45 110 10 0.9 B 100 40 5.4 3 0.08 0.02 22 0.65 5000 1670 0.05 0.24 3 0.964 48 1 +42BL100 b 0 s 0 0 120 21.7 6.94 450 500 DC 60 10 28 10 0.5 B 100 100 3 3 0.08 0.02 8 0.3 96 4000 0.025 0.036 0.75 0.25 24 0.8 +42BL41 b 0 s 0 0 120 6 1.79 200 500 DC 60 10 28 10 2.1 B 100 41 3 3 0.08 0.02 8 1.5 24 4000 0.025 0.035 0.19 0.0625 24 0.3 +42BL61 b 0 s 0 0 120 10.8 3.47 240 500 DC 60 10 28 10 1.2 B 100 61 3 3 0.08 0.02 8 0.8 48 4000 0.025 0.036 0.38 0.125 24 0.45 +42BL81 b 0 s 0 0 120 15.5 5.14 400 500 DC 60 10 28 10 0.71 B 100 81 3 3 0.08 0.02 8 0.43 72 4000 0.025 0.036 0.56 0.185 24 0.65 +42BLA01 b 0 s 0 0 120 4 1.27 220 500 DC 60 10 28 10 1.83 B 100 40.3 3 3 0.08 0.02 10 2.6 48 3000 0.025 0.055 0.21 0.07 24 0.26 +42BLA02 b 0 s 0 0 120 8.3 2.71 450 500 DC 60 10 28 10 0.96 B 100 60.3 3 3 0.08 0.02 10 1.1 101 3000 0.025 0.059 0.48 0.16 24 0.45 +42BLA03 b 0 s 0 0 120 13.5 4.48 430 500 DC 60 10 28 10 0.58 B 100 80.3 3 3 0.08 0.02 10 0.7 154 3000 0.025 0.058 0.78 0.26 24 0.65 +42BLA04 b 0 s 0 0 120 19 6.32 490 500 DC 60 10 28 10 0.44 B 100 100.3 3 3 0.08 0.02 10 0.48 207 3000 0.025 0.057 1.08 0.36 24 0.85 +42BLB01 b 0 s 0 0 120 3.5 1.12 160 500 DC 60 10 28 10 1.8 B 100 40.3 3 3 0.08 0.02 6 3.6 80 3000 0.025 0.057 0.19 0.064 24 0.4 +42BLB02 b 0 s 0 0 120 9 2.93 270 500 DC 60 10 28 10 0.75 B 100 60.3 3 3 0.08 0.02 6 1.05 100 3000 0.025 0.058 0.51 0.17 24 0.6 +42BLB03 b 0 s 0 0 120 14.5 4.84 330 500 DC 60 10 28 10 0.45 B 100 80.3 3 3 0.08 0.02 6 0.54 120 3000 0.025 0.062 0.9 0.3 24 0.8 +42BLB04 b 0 s 0 0 120 20.8 6.94 450 500 DC 60 10 28 10 0.3 B 100 100.3 3 3 0.08 0.02 6 0.4 140 3000 0.025 0.062 1.29 0.43 24 1 +57BLB40 b 0 s 0 0 120 12.3 3.75 400 500 DC 60 45 115 10 1.2 B 100 76 2 3 0.025 0.025 8 1.2 210 3000 0.025 0.08 0.9 0.3 36 0.8 +57BLB60 b 0 s 0 0 120 18.2 5.63 550 500 DC 60 45 115 10 0.8 B 100 96 2 3 0.025 0.025 8 0.8 320 3000 0.025 0.08 1.35 0.45 36 1 +57BLB80 b 0 s 0 0 120 23.8 7.5 620 500 DC 60 45 115 10 0.6 B 100 116 2 3 0.025 0.025 8 0.5 430 3000 0.025 0.08 1.8 0.6 36 1.2 +70BLS116 b 0 s 0 0 120 26 8.33 600 600 AC 1 45 115 10 0.7 B 100 116 2 3 0.08 0.02 8 0.3 400 3000 0.05 0.12 3 1 48 2.1 +70BLS136 b 0 s 0 0 120 38 12.5 600 600 AC 1 45 115 10 0.55 B 100 136 2 3 0.08 0.02 8 0.22 600 3000 0.05 0.12 4.5 1.5 48 2.9 +70BLS86 b 0 s 0 0 120 13 4.17 600 600 AC 1 45 115 10 1.4 B 100 86 2 3 0.08 0.02 8 0.6 200 3000 0.05 0.12 1.5 0.5 48 1.3 +80BLS105 b 0 s 0 0 120 45 15.04 700 500 DC 60 45 115 10 0.6 F 100 105 4 3 0.08 0.02 8 0.1 1020 3000 0.05 0.113 5 1.7 48 2 +80BLS120 b 0 s 0 0 120 61 20.18 1000 500 DC 60 45 115 10 0.4 F 100 120 4 3 0.08 0.02 8 0.07 1360 3000 0.05 0.109 6.5 2.2 48 2.5 +80BLS125 b 0 s 0 0 120 78 27.03 1500 500 DC 60 45 115 10 0.3 F 100 140 4 3 0.08 0.02 8 0.057 1900 3000 0.05 0.111 8.5 3 48 2.9 +80BLS84 b 0 s 0 0 120 22 7.63 500 500 DC 60 45 115 10 1.3 F 100 84 4 3 0.08 0.02 8 0.25 544 3000 0.05 0.118 2.5 0.9 48 1.6 +86BL125 b 0 s 0 0 120 56 500 60 60 220 20 0.31 B 100 125 3 0.08 0.02 8 0.1 2400 3000 0.05 128 6.3 2.1 48 4.2 +86BL58 b 0 s 0 0 120 9.5 500 60 60 220 20 2.6 B 100 58 3 0.08 0.02 8 0.9 400 3000 0.05 116 1.05 0.35 48 1.6 +86BL71 b 0 s 0 0 120 20 500 60 60 220 20 1 B 100 71 3 0.08 0.02 8 0.34 800 3000 0.05 124 2.1 0.7 48 2.12 +86BL98 b 0 s 0 0 120 24 500 60 60 220 20 0.5 B 100 98 3 0.08 0.02 8 0.16 1600 3000 0.05 127 4.2 1.4 48 3.15 +86BLC105 b 0 s 0 0 120 37 11.85 860 500 DC 60 45 220 10 0.36 B 100 105 2.5 3 0.08 0.02 8 0.14 1600 3000 0.05 0.135 4.8 1.6 48 2.7 +86BLC125 b 0 s 0 0 120 52 16.95 1200 500 DC 60 45 220 10 0.24 B 100 125 2.5 3 0.08 0.02 8 0.1 2400 3000 0.05 0.131 6.66 2.22 48 4 +86BLC64 b 0 s 0 0 120 11 3.28 380 500 DC 60 45 220 10 1.4 B 100 64 2.5 3 0.08 0.02 8 1 400 3000 0.05 0.122 1.2 0.4 48 1.5 +86BLC77 b 0 s 0 0 120 17.5 5.37 550 500 DC 60 45 220 10 0.6 B 100 77 2.5 3 0.08 0.02 8 0.34 800 3000 0.05 0.149 2.4 0.8 48 1.85 +86BLS125 b 0 s 0 0 120 56 16.41 1640 500 DC 60 60 220 10 0.31 B 100 125 1.52 3 0.08 0.02 8 0.1 2400 3000 0.05 0.128 6.3 2.1 48 4.2 +86BLS58 b 0 s 0 0 120 9.5 3.02 540 500 DC 60 60 220 10 2.6 B 100 58 1.52 3 0.08 0.02 8 0.9 400 3000 0.05 0.116 1.05 0.35 48 1.6 +86BLS71 b 0 s 0 0 120 20 5.65 800 500 DC 60 60 220 10 1 B 100 71 1.52 3 0.08 0.02 8 0.34 800 3000 0.05 0.124 2.1 0.7 48 2.12 +86BLS98 b 0 s 0 0 120 33 11.02 1450 500 DC 60 60 220 10 0.5 B 100 98 1.52 3 0.08 0.02 8 0.16 1600 3000 0.05 0.127 4.2 1.4 48 3.15 +42BL100-IE b 0 s 1 120 55.9 6.94 450 21.7 500 DC 1 10 28 10 0.5 B 100 90.1 3 3 0.08 0.02 8 0.3 96 4000 0.025 0.036 0.74 0.25 24 1 +42BL41-IE b 0 s 1 120 46 1.79 220 6 500 DC 1 10 28 10 2.1 B 100 41 3 3 0.08 0.02 8 1.5 24 4000 0.025 0.035 0.19 0.0625 24 0.5 +42BL61-IE b 0 s 1 120 41 3.47 250 10.8 500 DC 1 10 28 10 1.2 B 100 61 3 3 0.08 0.02 8 0.8 48 4000 0.025 0.036 0.37 0.125 24 0.65 +42BL81-IE b 0 s 1 120 46 5.14 340 15.5 500 DC 1 10 28 10 0.7 B 100 81 3 3 0.08 0.02 8 0.43 72 4000 0.025 0.036 0.56 0.185 24 0.85 +57PM25-0126 p 0 0 r 0 0 7.5 0.08 0.12 500 AC 60 2 5 3 107 6 B 100 25 3 100 0.00000125 50 -20 80 0.15 12 0.27 +57PM25-0624 p 0 0 r 0 0 7.5 0.08 0.625 500 AC 60 2 5 3 19.9 4 B 100 25 3 9 0.00000125 50 -20 80 0.12 5.6 0.27 +10PM10-0204 p 0 0 r 0 1.8 0.07 0.22 500 AC 60 1 2 3 3 4 E 100 10 1 15 0.0000001 50 -20 70 0.0016 3.2 6 +15PM12-0064 p 0 0 r 0 18 0.08 0.065 500 AC 60 1 2 3 37 4 E 100 12 1 190 0.0000001 50 -20 80 0.0032 12 0.012 +15PM12-0244 p 0 0 r 0 18 12 1 +20PM18-0506 p 0 0 r 0 18 0.05 0.5 500 AC 60 1 2 3 1.85 6 B 100 18.5 1 10 0.0000001 50 -20 80 0.005 5 0.026 +25PM15-0246 p 0 0 r 0 7.5 15.5 1.5 +25PM15-0436 p 0 0 r 0 7.5 0.08 0.43 500 AC 60 1.5 3 3 2.3 6 B 100 15.5 1.5 11.5 0.0000001 50 -20 80 0.01 5 0.036 +25PM15-0506 p 0 0 r 0 7.5 0.08 0.5 500 AC 60 1.5 3 3 2 6 B 100 15.5 1.5 10 0.0000001 50 -20 80 0.014 5 0.036 +25PM15-0764 p 0 0 r 0 7.5 0.08 0.76 500 AC 60 1.5 3 3 3 4 B 100 15.5 1.5 5 0.0000001 50 -20 80 0.01 3.8 0.036 +35PM16-0506 p 0 0 r 0 7.5 0.07 0.5 500 AC 60 1.5 3 3 3.8 6 B 100 16.5 1.5 10 0.0000005 50 -20 80 0.04 5 0.09 +35PM22-0866 p 0 0 r 0 7.5 0.07 0.86 500 AC 60 1.5 3 3 3.2 6 E 100 22 1.5 5.8 0.00000075 40 -10 80 0.055 5 0.09 +42PM17-0596 p 0 0 s 0 0 7.5 0.07 0.59 500 AC 60 2 5 3 4.5 6 B 100 17 1.5 8.6 0.00000096 40 -10 80 0.05 5 0.11 +42PM22-0806 p 0 0 s 0 0 7.5 0.07 0.8 500 AC 60 2 5 3 5.5 6 E 100 22.5 1.5 6.2 0.00000096 40 -10 80 0.06 5 0.13 +57S41-1 s h 0 0 r 0 0 1.8 0.05 1.1 500 AC 60 15 28 20 4 6 B 100 41 1.6 0.08 0.02 3.6 57 50 -20 80 0.18 0.288 4 0.54 +57S41-2 s h 0 0 r 0 0 1.8 0.05 0.4 500 AC 60 15 28 20 30 6 B 100 41 1.6 0.08 0.02 30 57 50 -20 80 0.18 0.288 12 0.54 +57S41-4 s h 0 0 r 0 0 1.8 0.05 1.56 500 AC 60 15 75 20 3.6 4 B 100 41 1.6 0.08 0.02 1.8 57 50 -20 80 0.18 0.4 2.8 0.54 +57S51-1 s h 0 0 r 0 0 1.8 0.05 0.85 500 AC 60 15 75 20 9 6 B 100 51 1.6 0.08 0.02 7.1 110 50 -20 80 4 0.49 6 0.6 +57S51-2 s h 0 0 r 0 0 1.8 0.05 0.42 500 AC 60 15 75 20 36 6 B 100 51 1.6 0.08 0.02 29 110 50 -20 80 4 0.49 12 0.6 +57S51-4 s h 0 0 r 0 0 1.8 0.05 2.8 500 AC 60 15 75 20 2.1 4 B 100 51 1.6 0.08 0.02 0.85 110 50 -20 80 4 0.69 2.38 0.6 +57S56-1 s h 0 0 r 0 0 1.8 0.05 1.2 500 AC 60 15 75 20 8 6 B 100 56 1.6 0.08 0.02 5 135 50 -20 80 0.42 0.605 6 0.65 +57S56-2 s h 0 0 r 0 0 1.8 0.05 0.6 500 AC 60 15 75 20 32 6 B 100 56 1.6 0.08 0.02 20 135 50 -20 80 0.42 0.605 12 0.65 +57S56-4 s h 0 0 r 0 0 1.8 0.05 2.5 500 AC 60 15 75 20 3.6 4 B 100 56 1.6 0.08 0.02 1.1 135 50 -20 80 0.42 0.84 2.8 0.65 +57S76-1 s h 0 0 r 0 0 1.8 0.05 1.5 500 AC 60 15 75 20 6 6 B 100 76 1.6 0.08 0.02 3.6 200 50 -20 80 0.72 0.9 5.4 0.95 +57S76-2 s h 0 0 r 0 0 1.8 0.05 0.68 500 AC 60 15 75 20 30 6 B 100 76 1.6 0.08 0.02 17.7 200 50 -20 80 0.72 0.9 12 0.95 +57S76-4 s h 0 0 r 0 0 1.8 0.05 3.3 500 AC 60 15 75 20 3 4 B 100 76 1.6 0.08 0.02 0.85 200 50 -20 80 0.72 1.25 2.7 0.95 +63S10-1004 s h 0 0 r 1 0 1.8 0.05 1 600 AC 60 2 5 20 2 4 E 100 9.6 0 0.05 0.06 3.8 16 50 -20 80 0.064 3.8 0.095 +86ST125-6408 s h 0 0 s 0 0 1.8 0.05 9.06 3.5 8 125 1.6 0.4 1800 7.6 3.6 +86ST94-4308 s h 0 0 s 0 0 1.8 0.05 6 3.3 8 94 1.6 0.385 1200 4.8 2.4 +35ST26-0284 s h 0 0 s 0 1.8 0.05 0.28 500 AC 60 10 28 20 27 4 100 26 0.08 0.02 26 10 50 -20 80 0.0058842 0.068649 7.4 0.13 0.1 0.2 +35ST28-0504 s h 0 0 s 0 1.8 0.05 0.5 500 AC 60 10 28 20 18 4 100 28 0.08 0.02 20 11 50 -20 80 0.0078456 0.09807 10 0.14 0.1 0.2 +35ST36-1004 s h 0 0 s 0 1.8 0.05 1 500 AC 60 10 28 20 4.3 4 100 36 0.08 0.02 2.7 14 50 -20 80 0.009807 0.137298 2.7 0.18 0.1 0.2 +39ST20-0404 s h 0 0 s 0 1.8 0.05 0.4 500 AC 60 10 28 20 7.5 4 100 20 0.08 0.02 6.6 11 50 -20 80 0.0049035 0.0637455 2.64 0.12 0.1 0.2 +39ST20-0506 s h 0 0 s 0 1.8 0.05 0.5 500 AC 60 10 28 20 7.5 6 100 20 0.08 0.02 13 11 50 -20 80 0.0049035 0.078456 6.5 0.12 0.1 0.2 +39ST34-0306 s h 0 0 s 0 1.8 0.05 0.3 500 AC 60 10 28 20 20 6 100 34 0.08 0.02 40 20 50 -20 80 0.0117684 0.127491 12 0.18 0.1 0.2 +39ST34-0404 s h 0 0 s 0 1.8 0.05 0.4 500 AC 60 10 28 20 32 4 100 34 0.08 0.02 30 20 50 -20 80 0.0117684 0.205947 12 0.18 0.1 0.2 +39ST38-0504 s h 0 0 s 0 1.8 0.05 0.5 500 AC 60 10 28 20 45 4 100 38 0.08 0.02 24 24 50 -20 80 0.0176526 0.284403 12 0.2 0.1 0.2 +39ST38-0806 s h 0 0 s 0 1.8 0.05 0.8 500 AC 60 10 28 20 6 6 100 38 0.08 0.02 7.5 24 50 -20 80 0.0176526 0.19614 6 0.2 0.1 0.2 +39ST44-0304 s h 0 0 s 0 1.8 0.05 0.3 500 AC 60 10 28 20 100 4 100 44 0.08 0.02 40 40 50 -20 80 0.0245175 0.274596 12 0.25 0.1 0.2 +42ST33-0114D s h 0 0 s 0 3.6 0.05 0.114 500 AC 60 10 28 20 130 4 100 34 0.08 0.02 123 20 50 -20 80 0.0147105 0.0764946 14 0.2 0.1 0.2 +42ST33-0156D s h 0 0 s 0 3.6 0.05 0.15 500 AC 60 10 28 20 60 6 100 34 0.08 0.02 100 20 50 -20 80 0.0147105 0.049035 15 0.2 0.1 0.2 +42ST33-0954D s h 0 0 s 0 3.6 0.05 0.095 500 AC 60 10 28 20 200 4 100 34 0.08 0.02 98 20 50 -20 80 0.0147105 0.0519771 9.31 0.2 0.1 0.2 +42ST38-0954D s h 0 0 s 0 3.6 0.05 0.095 500 AC 60 10 28 20 330 4 100 38 0.08 0.02 105 23 50 -20 80 0.0147105 0.068649 9.98 0.23 0.1 0.2 +39ST34-0166 s h 0 0 s 0.16 50 6 34 75 20 0.0117684 0.107877 12 0.18 +39ST34-0604 s h 0 0 s 0.6 16 4 34 15 20 0.0117684 0.215754 9 0.18 +39ST34-0654 s h 0 0 s 0.65 9.3 4 34 7 20 0.0117684 0.176526 4.55 0.18 +86ST125-3508 s h 1 0 r 0 1.8 0.05 3.5 820 3 AC 1 60 220 20 7.9 8 100 88 0.08 0.02 1.42 1800 50 -20 80 12.2583125 7.453054 4.97 3.6 0.1 0.2 +86ST134-1806 s h 1 0 r 0 1.8 0.05 1.8 1500 AC 60 60 220 20 41 6 100 134 0.08 0.02 6.5 1800 50 -20 80 0.3530394 3.530394 12 3.6 0.1 0.2 +86ST134-4006 s h 1 0 r 0 1.8 0.05 4 1500 AC 60 60 220 20 6.6 6 100 134 0.08 0.02 1.25 1800 50 -20 80 0.3530394 3.530394 5 3.6 0.1 0.2 +86ST134-5604 s h 1 0 r 0 1.8 0.05 5.6 1500 AC 60 60 220 20 6.6 4 100 134 0.08 0.02 0.63 1800 50 -20 80 0.3530394 4.903325 3.5 3.6 0.1 0.2 +86ST134-6706 s h 1 0 r 0 1.8 0.05 6.7 1500 AC 60 60 220 20 2 6 100 134 0.08 0.02 0.45 1800 50 -20 80 0.3530394 3.530394 3 3.6 0.1 0.2 +86ST62-1256 s h 1 0 r 0 1.8 0.05 1.25 1500 AC 60 60 220 20 14 6 100 62 0.08 0.02 4.4 560 50 -20 80 0.0784532 1.2748645 5.5 1.5 0.1 0.2 +86ST62-1406 s h 1 0 r 0 1.8 0.05 14 1500 AC 60 60 220 20 60 6 100 62 0.08 0.02 20 560 50 -20 80 0.0784532 1.2748645 0.7 1.5 0.1 0.2 +86ST62-4506 s h 1 0 r 0 1.8 0.05 4.5 1500 AC 60 60 220 20 1.4 6 100 62 0.08 0.02 0.4 560 50 -20 80 0.0784532 1.2748645 1.8 1.5 0.1 0.2 +86ST62-5904 s h 1 0 r 0 1.8 0.05 5.9 1500 AC 60 60 220 20 1.5 4 100 62 0.08 0.02 0.23 560 50 -20 80 0.0784532 1.765197 1.33 1.5 0.1 0.2 +86ST67-2808 s h 1 0 r 0 1.8 0.05 2.8 820 3 AC 1 60 220 20 5.1 8 100 88 0.08 0.02 1.3 660 50 -20 80 6.5704555 2.745862 3.64 1.6 0.1 0.2 +86ST94-1006 s h 1 0 r 0 1.8 0.05 1 1500 AC 60 60 220 20 72 6 100 94 0.08 0.02 12 1100 50 -20 80 0.2353596 2.549729 12 2.6 0.1 0.2 +86ST94-2006 s h 1 0 r 0 1.8 0.05 2 1500 AC 60 60 220 20 13 6 100 94 0.08 0.02 3 1100 50 -20 80 0.2353596 2.549729 6 2.6 0.1 0.2 +86ST94-2808 s h 1 0 r 0 1.8 0.05 2.8 820 3 AC 1 60 220 20 7.7 8 100 88 0.08 0.02 1.7 1200 50 -20 80 9.218251 4.707192 4.76 2.4 0.1 0.2 +86ST94-4006 s h 1 0 r 0 1.8 0.05 4 1500 AC 60 60 220 20 4.5 6 100 94 0.08 0.02 0.75 1100 50 -20 80 0.2353596 2.549729 3 2.6 0.1 0.2 +86ST94-5604 s h 1 0 r 0 1.8 0.05 5.6 1500 AC 60 60 220 20 3.9 4 100 94 0.08 0.02 0.38 1100 50 -20 80 0.2353596 3.4323275 2.1 2.6 0.1 0.2 +42STH33-1334 s h 1 0 s 0 1 0 1.8 0.05 1.33 100 500 AC 60 2.5 4 34 2 2.1 35 50 -20 80 0.0117684 0.2157463 2.8 0.22 +42STH38-1684 s h 1 0 s 0 1 0 1.8 0.05 1.68 100 500 AC 60 3.2 4 40 2 1.65 54 50 -20 80 0.0147105 0.3530394 2.8 0.28 +42STH47-1684 s h 1 0 s 0 1 0 1.8 0.05 1.68 100 500 AC 60 2.8 4 48 2 1.65 68 50 -20 80 0.019614 0.4314926 2.8 0.35 +60SH45-2008F s h 1 0 s 0 1 0 1.8 0.05 2 500 AC 60 15 75 20 2 8 B 100 45 1.6 1.5 275 50 -20 80 0.5 0.78 3 0.6 +60SH56-2008F s h 1 0 s 0 1 0 1.8 0.05 2 500 AC 60 15 75 20 3.6 8 B 100 56 1.6 1.8 400 50 -20 80 0.7 1.17 3.6 0.77 +60SH65-2008F s h 1 0 s 0 1 0 1.8 0.05 2 500 AC 60 15 75 20 4.6 8 B 100 65 1.6 2.4 570 50 -20 80 0.9 1.5 4.8 1.2 +60SH86-2008F s h 1 0 s 0 1 0 1.8 0.05 2 500 AC 60 15 75 20 6.8 8 B 100 86 1.6 3 840 50 -20 80 1 2.2 6 1.4 +86S125-3508 s h 1 0 s 0 1 0 1.8 0.05 3.5 750 AC 60 60 220 20 7.9 8 B 100 125 1.6 0.08 0.02 1.42 1800 50 -20 80 2.3 6.2 4.97 3.6 +86S67-2808 s h 1 0 s 0 1 0 1.8 0.05 2.8 750 AC 60 60 220 20 5.1 8 B 100 67 1.6 0.08 0.02 1.3 660 50 -20 80 0.85 2.3 3.64 1.6 +86S94-2808 s h 1 0 s 0 1 0 8 B 94 1.6 1200 50 -20 80 1.3 +86SH65-4208 s h 1 0 s 0 1 0 1.8 0.05 4.2 750 AC 60 60 220 20 1.7 8 B 100 65 1.52 0.08 0.02 0.57 1000 50 -20 80 2.6 2.39 1.7 +110SH150-6504 s h 1 0 s 0 0 1.8 0.05 6.5 1500 AC 60 100 330 20 11.5 4 B 100 150 0.08 0.02 0.72 10900 50 -20 80 5.9 21 5.2 8.4 +110SH201-8004 s h 1 0 s 0 0 1.8 0.05 8 1500 AC 60 100 330 20 12 4 B 100 201 0.08 0.02 0.67 16200 50 -20 80 7.5 28 5.36 11.7 +110SH99-5504 s h 1 0 s 0 0 1.8 0.05 5.5 1500 AC 60 100 330 20 9.8 4 B 100 99 0.08 0.02 0.7 5500 50 -20 80 3 11.2 4.95 5 +110STH150-6504 s h 1 0 s 0 0 1.8 6.5 15 4 150 1.52 0.8 10900 21 8.4 +110STH201-8004 s h 1 0 s 0 0 1.8 8 12 4 201 1.52 0.67 16200 28 11.7 +20SH33-0604 s h 1 0 s 0 0 1.8 0.05 0.6 500 AC 60 2 28 20 1.7 4 B 100 33 0.08 0.02 6.5 2 50 -20 80 0.0176 3.96 0.06 +20SH42-0804 s h 1 0 s 0 0 1.8 0.05 0.8 500 AC 60 2 28 20 1.5 4 B 100 42 0.08 0.02 5.4 3.6 50 -20 80 0.03 4.32 0.08 +25SH23-0704 s h 1 0 s 0 0 1.8 0.05 0.7 500 AC 60 7 28 20 2.4 4 B 100 23 0.08 0.02 4.3 2 50 -20 80 0.033 3 0.055 +28SH32-0674 s h 1 0 s 0 0 1.8 0.05 0.67 500 AC 60 10 28 20 3.4 4 B 100 32 0.08 0.02 5.6 9 50 -20 80 0.06 3.8 0.11 +28SH32-0956 s h 1 0 s 0 0 1.8 0.05 0.95 500 AC 60 10 28 20 0.8 6 B 100 32 0.08 0.02 2.8 9 50 -20 80 0.043 2.66 0.11 +28SH45-0674 s h 1 0 s 0 0 1.8 0.05 0.67 500 AC 60 10 28 20 4.9 4 B 100 45 0.08 0.02 6.8 12 50 -20 80 0.095 4.56 0.14 +28SH45-0956 s h 1 0 s 0 0 1.8 0.05 0.95 500 AC 60 10 28 20 1.2 6 B 100 45 0.08 0.02 3.4 12 50 -20 80 0.075 3.4 0.14 +28SH51-0674 s h 1 0 s 0 0 1.8 0.05 0.67 500 AC 60 10 28 20 7.2 4 B 100 51 0.08 0.02 9.2 18 50 -20 80 0.12 6.2 0.2 +28SH51-0956 s h 1 0 s 0 0 1.8 0.05 0.95 500 AC 60 10 28 20 1.8 6 B 100 51 0.08 0.02 4.6 18 50 -20 80 0.9 4.4 0.2 +28STH32-0674 s h 1 0 s 0 0 1.8 0.05 0.67 500 AC 60 10 28 20 3.4 4 100 31.5 2 0.08 0.02 5.6 9 50 -20 80 0.058842 3.8 0.11 +28STH32-0956 s h 1 0 s 0 0 1.8 0.05 0.95 500 AC 60 10 28 20 0.8 6 100 31.5 2 0.08 0.02 2.8 9 50 -20 80 0.0421701 2.66 0.11 +28STH45-0674 s h 1 0 s 0 0 1.8 0.05 0.67 500 AC 60 10 28 20 4.9 4 100 44.5 2 0.08 0.02 6.8 12 50 -20 80 0.0931665 4.56 0.14 +28STH45-0956 s h 1 0 s 0 0 1.8 0.05 0.95 500 AC 60 10 28 20 1.2 6 100 44.5 2 0.08 0.02 3.4 12 50 -20 80 0.0735525 3.4 0.14 +28STH51-0674 s h 1 0 s 0 0 1.8 0.05 0.67 500 AC 60 10 28 20 7.2 4 100 50.5 2 0.08 0.02 9.2 18 50 -20 80 0.117684 6.2 0.2 +28STH51-0956 s h 1 0 s 0 0 1.8 0.05 0.95 500 AC 60 10 28 20 1.8 6 100 50.5 2 0.08 0.02 4.6 18 50 -20 80 0.088263 4.4 0.2 +35SH26-0284 s h 1 0 s 0 0 1.8 0.05 0.28 500 AC 60 10 28 20 27 4 B 100 26 0.08 0.02 26 10 50 -20 80 60 0.07 7.4 0.13 +35SH28-0504 s h 1 0 s 0 0 1.8 0.05 0.5 500 AC 60 10 28 20 14 4 B 100 28 0.08 0.02 20 11 50 -20 80 80 0.1 10 0.14 +35SH36-1004 s h 1 0 s 0 0 1.8 0.05 1 500 AC 60 10 28 20 4.3 4 B 100 36 0.08 0.02 2.7 14 50 -20 80 100 0.14 2.7 0.18 +39SH20-0404 s h 1 0 s 0 0 1.8 0.05 0.4 500 AC 60 10 28 20 6 4 B 100 20 0.08 0.02 6.6 11 50 -20 80 50 0.065 2.64 0.12 +39SH20-0506 s h 1 0 s 0 0 1.8 0.05 0.5 500 AC 60 10 28 20 6 6 B 100 20 0.08 0.02 13 11 50 -20 80 50 0.08 6.5 0.12 +39SH34-0306 s h 1 0 s 0 0 1.8 0.05 0.3 500 AC 60 10 28 20 20 6 B 100 34 0.08 0.02 40 20 50 -20 80 120 0.13 12 0.18 +39SH34-0404 s h 1 0 s 0 0 1.8 0.05 0.4 500 AC 60 10 28 20 43 4 B 100 34 0.08 0.02 30 20 50 -20 80 120 0.21 12 0.18 +39SH34-0604 s h 1 0 s 0 0 1.8 0.05 0.6 500 AC 60 10 28 20 16 4 B 100 34 0.08 0.02 15 20 50 -20 80 120 0.21 9 0.18 +39SH34-0654 s h 1 0 s 0 0 1.8 0.05 0.65 500 AC 60 10 28 20 9.3 4 B 100 34 0.08 0.02 7 20 50 -20 80 120 0.18 4.55 0.18 +39SH38-0304 s h 1 0 s 0 0 1.8 0.05 0.3 500 AC 60 10 28 20 100 4 B 100 38 0.08 0.02 40 24 50 -20 80 180 0.28 12 0.2 +39SH38-0504 s h 1 0 s 0 0 1.8 0.05 0.5 500 AC 60 10 28 20 40 4 B 100 38 0.08 0.02 22 24 50 -20 80 180 0.29 11 0.2 +39SH38-0806 s h 1 0 s 0 0 1.8 0.05 0.8 500 AC 60 10 28 20 8 6 B 100 38 0.08 0.02 7.5 24 50 -20 80 180 0.2 6 0.2 +42SH33-1 s h 1 0 s 0 0 1.8 0.05 0.95 500 AC 60 10 28 20 2.5 6 B 100 33.5 2 0.08 0.02 4.2 35 50 -20 80 120 0.158 4 0.22 +42SH33-1M s h 1 0 s 0 0 0.9 0.05 0.95 500 AC 60 10 28 20 4 6 B 100 33.5 2 0.08 0.02 4.2 35 50 -20 80 200 0.158 4 0.22 +42SH33-2 s h 1 0 s 0 0 1.8 0.05 0.4 500 AC 60 10 28 20 15 6 B 100 33.5 2 0.08 0.02 24 35 50 -20 80 120 0.158 9.6 0.22 +42SH33-2M s h 1 0 s 0 0 0.9 0.05 0.6 500 AC 60 10 28 20 11 6 B 100 33.5 2 0.08 0.02 10 35 50 -20 80 200 0.158 6 0.22 +42SH33-3 s h 1 0 s 0 0 1.8 0.05 0.31 500 AC 60 10 28 20 21 6 B 100 33.5 0.08 0.02 38.5 35 50 -20 80 12 0.158 12 0.22 +42SH33-3M s h 1 0 s 0 0 0.9 0.05 0.31 500 AC 60 10 28 20 33 6 B 100 33.5 2 0.08 0.02 38.5 35 50 -20 80 200 0.158 12 0.22 +42SH33-4 s h 1 0 s 0 0 1.8 0.05 1.33 500 AC 60 10 28 20 2.5 4 B 100 33.5 0.08 0.02 2.1 35 50 -20 80 12 0.22 2.8 0.22 +42SH33-4M s h 1 0 s 0 0 0.9 0.05 1.33 500 AC 60 10 28 20 4.2 4 B 100 33.5 2 0.08 0.02 2.1 35 50 -20 80 200 0.22 2.8 0.22 +42SH38-1 s h 1 0 s 0 0 1.8 0.05 1.2 500 AC 60 10 28 20 3.2 6 B 100 39.5 2 0.08 0.02 3.3 54 50 -20 80 150 0.259 4 0.28 +42SH38-1M s h 1 0 s 0 0 0.9 0.05 1.2 500 AC 60 10 28 20 4.1 6 B 100 39.5 2 0.08 0.02 3.3 54 50 -20 80 220 0.259 4 0.28 +42SH38-2 s h 1 0 s 0 0 1.8 0.05 0.8 500 AC 60 10 28 20 6.7 6 B 100 39.5 2 0.08 0.02 7.5 54 50 -20 80 150 0.259 6 0.28 +42SH38-2M s h 1 0 s 0 0 0.9 0.05 0.8 500 AC 60 10 28 20 8.3 6 B 100 39.5 2 0.08 0.02 7.5 54 50 -20 80 220 0.259 6 0.28 +42SH38-3 s h 1 0 s 0 0 1.8 0.05 0.4 500 AC 60 10 28 20 25 6 B 100 39.5 2 0.08 0.02 30 54 50 -20 80 150 0.259 12 0.28 +42SH38-3M s h 1 0 s 0 0 0.9 0.05 0.4 500 AC 60 10 28 20 30 6 B 100 39.5 2 0.08 0.02 30 54 50 -20 80 220 0.259 12 0.28 +42SH38-4 s h 1 0 s 0 0 1.8 0.05 1.68 500 AC 60 10 28 20 3.2 4 B 100 39.5 2 0.08 0.02 1.65 54 50 -20 80 150 0.36 2.8 0.28 +42SH38-4M s h 1 0 s 0 0 0.9 0.05 1.68 500 AC 60 10 28 20 4.1 4 B 100 39.5 2 0.08 0.02 1.65 54 50 -20 80 220 0.36 2.8 0.28 +42SH47-1 s h 1 0 s 0 0 1.8 0.05 1.2 500 AC 60 10 28 20 2.8 6 B 100 47.5 2 0.08 0.02 3.3 68 50 -20 80 200 0.317 4 0.35 +42SH47-1M s h 1 0 s 0 0 0.9 0.05 1.2 500 AC 60 10 28 20 2.8 6 B 100 47.5 2 0.08 0.02 3.3 68 50 -20 80 200 0.317 4 0.35 +42SH47-2 s h 1 0 s 0 0 1.8 0.05 0.8 500 AC 60 10 28 20 6.3 6 B 100 47.5 2 0.08 0.02 7.5 68 50 -20 80 200 0.317 6 0.35 +42SH47-2M s h 1 0 s 0 0 0.9 0.05 0.8 500 AC 60 10 28 20 6.3 6 B 100 47.5 2 0.08 0.02 7.5 68 50 -20 80 200 0.317 6 0.35 +42SH47-3 s h 1 0 s 0 0 1.8 0.05 0.4 500 AC 60 10 28 20 25 6 B 100 47.5 2 0.08 0.02 30 68 50 -20 80 200 0.317 12 0.35 +42SH47-3M s h 1 0 s 0 0 0.9 0.05 0.4 500 AC 60 10 28 20 25 6 B 100 47.5 2 0.08 0.02 30 68 50 -20 80 200 0.317 12 0.35 +42SH47-4 s h 1 0 s 0 0 1.8 0.05 1.68 500 AC 60 10 28 20 2.8 4 B 100 47.5 2 0.08 0.02 1.65 68 50 -20 80 200 0.44 2.8 0.35 +42SH47-4M s h 1 0 s 0 0 0.9 0.05 1.68 500 AC 60 10 28 20 2.8 4 B 100 47.5 2 0.08 0.02 1.65 68 50 -20 80 200 0.44 2.8 0.35 +42SH60-0854 s h 1 0 s 0 0 1.8 0.05 0.85 500 AC 60 10 28 20 29 4 B 100 60 2 0.08 0.02 12 102 50 -20 80 280 0.8 10.2 0.5 +42SH60-1206 s h 1 0 s 0 0 1.8 0.05 1.2 500 AC 60 10 28 20 7 6 B 100 60 2 0.08 0.02 6 102 50 -20 80 280 0.65 7.2 0.5 +42SH60-3004 s h 1 0 s 0 0 1.8 0.05 3 500 AC 60 10 28 20 2.7 4 B 100 60 2 0.08 0.02 1.1 102 50 -20 80 280 0.8 3.3 0.5 +57SH51-1 s h 1 0 s 0 0 1.8 0.05 1 500 AC 60 15 75 20 8.2 6 B 100 51 1.6 0.08 0.02 6.6 275 50 -20 80 0.36 0.72 6.6 0.65 +57SH51-2 s h 1 0 s 0 0 1.8 0.05 2 500 AC 60 15 75 20 2.2 6 B 100 51 1.6 0.08 0.02 1.65 275 50 -20 80 0.36 0.72 3.3 0.65 +57SH51-3 s h 1 0 s 0 0 1.8 0.05 3 500 AC 60 15 75 20 0.9 6 B 100 51 1.6 0.08 0.02 0.74 275 50 -20 80 0.36 0.72 2.2 0.65 +57SH51-4 s h 1 0 s 0 0 1.8 0.05 2.8 500 AC 60 15 75 20 2.2 4 B 100 51 1.6 0.08 0.02 0.83 275 50 -20 80 0.36 1.01 2.3 0.65 +57SH56-1 s h 1 0 s 0 0 1.8 0.05 1 500 AC 60 15 75 20 10 6 B 100 56 1.6 0.08 0.02 7.4 300 50 -20 80 0.4 0.9 7.4 0.7 +57SH56-1M s h 1 0 s 0 0 0.9 0.05 1 500 AC 60 15 75 20 17.5 6 B 100 56 1.6 0.08 0.02 7.4 300 50 -20 80 0.4 0.9 7.4 0.7 +57SH56-2 s h 1 0 s 0 0 1.8 0.05 2 500 AC 60 15 75 20 2.5 6 B 100 56 1.6 0.08 0.02 1.8 300 50 -20 80 0.4 0.9 3.6 0.7 +57SH56-2M s h 1 0 s 0 0 0.9 0.05 2 500 AC 60 15 75 20 4.5 6 B 100 56 1.6 0.08 0.02 1.8 300 50 -20 80 0.4 0.9 3.6 0.7 +57SH56-3 s h 1 0 s 0 0 1.8 0.05 3 500 AC 60 15 75 20 1.1 6 B 100 56 1.6 0.08 0.02 0.75 300 50 -20 80 0.4 0.9 2.3 0.7 +57SH56-3M s h 1 0 s 0 0 0.9 0.05 3 500 AC 60 15 75 20 1.9 6 B 100 56 1.6 0.08 0.02 0.75 300 50 -20 80 0.4 0.9 2.3 0.7 +57SH56-4 s h 1 0 s 0 0 1.8 0.05 2.8 500 AC 60 15 75 20 2.5 4 B 100 56 1.6 0.08 0.02 0.9 300 50 -20 80 0.4 1.26 2.5 0.7 +57SH56-4M s h 1 0 s 0 0 0.9 0.05 2.8 500 AC 60 15 75 20 4.5 4 B 100 56 1.6 0.08 0.02 0.9 300 50 -20 80 0.4 1.26 2.5 0.7 +57SH76-1 s h 1 0 s 0 0 1.8 0.05 1 500 AC 60 15 75 20 14 6 B 100 76 1.6 0.08 0.02 8.6 480 50 -20 80 0.68 1.35 8.6 1 +57SH76-1M s h 1 0 s 0 0 0.9 0.05 1 500 AC 60 15 75 20 23 6 B 100 76 1.6 0.08 0.02 8.6 480 50 -20 80 0.68 1.35 8.6 1 +57SH76-2 s h 1 0 s 0 0 1.8 0.05 2 500 AC 60 15 75 20 3.6 6 B 100 76 1.6 0.08 0.02 2.25 480 50 -20 80 0.68 1.35 4.5 1 +57SH76-2M s h 1 0 s 0 0 0.9 0.05 2 500 AC 60 15 75 20 5.6 6 B 100 76 1.6 0.08 0.02 2.25 480 50 -20 80 0.68 1.35 4.5 1 +57SH76-3 s h 1 0 s 0 0 1.8 0.05 3 500 AC 60 15 75 20 1.6 6 B 100 76 1.6 0.08 0.02 1 480 50 -20 80 0.68 1.35 3 1 +57SH76-3M s h 1 0 s 0 0 0.9 0.05 3 500 AC 60 15 75 20 2.6 6 B 100 76 1.6 0.08 0.02 1 480 50 -20 80 0.68 1.35 3 1 +57SH76-4 s h 1 0 s 0 0 1.8 0.05 2.8 500 AC 60 15 75 20 3.6 4 B 100 76 1.6 0.08 0.02 1.13 480 50 -20 80 0.68 1.89 3.2 1 +57SH76-4M s h 1 0 s 0 0 0.9 0.05 2.8 500 AC 60 15 75 20 5.6 4 B 100 76 1.6 0.08 0.02 1.13 480 50 -20 80 0.68 1.8 3.2 1 +60STH65-2008 s h 1 0 s 0 0 1.8 0.05 2 AC 60 4.6 8 100 65 0.08 0.02 1.2 50 -20 80 180 1.2 +60STH86-2804C s h 1 0 s 0 0 1.8 2.8 6.8 4 1.5 840 3.1 1.4 +86SH118-6004 s h 1 0 s 0 0 1.8 0.05 6 750 AC 60 60 220 20 5.1 4 B 100 118 1.52 0.08 0.02 0.45 2700 50 -20 80 2.4 8.7 2.7 3.8 +86SH156-6204 s h 1 0 s 0 0 1.8 0.05 6.2 750 AC 60 60 220 20 9 4 B 100 156 1.52 0.08 0.02 0.72 4000 50 -20 80 3.6 12.1 4.5 5.4 +86SH80-5504 s h 1 0 s 0 0 1.8 0.05 5.5 750 AC 60 60 220 20 3.5 4 B 100 80 1.52 0.08 0.02 0.42 1400 50 -20 80 1.2 4.6 2.3 2.3 +86SH96-5504 s h 1 0 s 0 0 1.8 0.05 5.5 750 AC 60 60 220 20 4.5 4 B 100 96 1.52 0.08 0.02 0.465 2700 50 -20 80 1.2 7 2.56 2.8 +86STH118-8004 s h 1 0 s 0 0 1.8 8 2.9 4 118 1.52 0.31 2700 8.7 3.8 +86STH156-9904 s h 1 0 s 0 0 1.8 9.9 2.9 4 156 1.52 0.21 4000 12 5.3 +86STH80-5504 s h 1 0 s 0 0 1.8 0.05 5.5 820 3 AC 1 60 220 20 4 4 80 1.52 0.08 0.02 0.46 1400 50 -20 80 0.1176798 4.511059 2.3 2.3 +60STH45-2008F s h 1 0 s 1 0 0.9 0.05 1.4 500 AC 60 15 75 20 8 8 100 47 0.08 0.02 3 275 50 -20 80 0.04903325 1.0787315 4.2 0.6 0.1 0.2 +60STH56-2008F s h 1 0 s 1 0 0.9 0.05 1.4 500 AC 60 15 75 20 14.4 8 100 56 0.08 0.02 3.6 300 50 -20 80 0.06864655 1.61809725 5.04 0.77 0.1 0.2 +60STH65-2008F s h 1 0 s 1 0 0.9 0.05 1.4 500 AC 60 15 75 20 18.4 8 100 67 0.08 0.02 4.8 570 50 -20 80 0.08825985 2.0593965 6.72 1.2 0.1 0.2 +60STH86-2008F s h 1 0 s 1 0 0.9 0.05 1.4 500 AC 60 15 75 20 27.2 8 100 88 0.08 0.02 6 840 50 -20 80 0.0980665 3.0400615 8.4 1.4 0.1 0.2 +110STH99-5504 s h 1 0 s 0 1.8 0.05 5.5 1800 5 AC 1 60 220 20 12 4 100 99 0.08 0.02 0.9 5500 50 -20 80 0.2941995 11.2 5 0.1 0.2 +20STH30-0604 s h 1 0 s 0 1.8 0.05 0.6 500 AC 60 2 20 20 1.7 4 100 30 0.08 0.02 6.5 2 50 -20 80 0.0176526 3.9 0.06 0.1 0.2 +20STH33-0604 s h 1 0 s 0 1.8 0.05 0.6 500 AC 60 2 20 20 1.7 4 100 33 0.08 0.02 6.5 2 50 -20 80 0.0176526 3.9 0.06 0.1 0.2 +20STH42-0804 s h 1 0 s 0 1.8 0.05 0.8 500 AC 60 2 20 20 1.5 4 100 42 0.08 0.02 5.4 3.6 50 -20 80 0.029421 4.32 0.08 0.1 0.2 +42STH33-0316M s h 1 0 s 0 0.9 0.05 0.31 500 AC 60 10 28 20 33 6 100 33 0.08 0.02 38.5 35 50 -20 80 0.019614 0.15494507 12 0.22 0.1 0.2 +42STH33-0606M s h 1 0 s 0 0.9 0.05 0.6 500 AC 60 10 28 20 9.5 6 100 33 0.08 0.02 10 35 50 -20 80 0.019614 0.15494507 6 0.22 0.1 0.2 +42STH33-0956M s h 1 0 s 0 0.9 0.05 0.95 500 AC 60 10 28 20 4 6 100 33 0.08 0.02 4.2 35 50 -20 80 0.019614 0.15494507 4 0.22 0.1 0.2 +42STH33-1334M s h 1 0 s 0 0.9 0.05 1.33 500 AC 60 10 28 20 4.2 4 100 33 0.08 0.02 2.1 35 50 -20 80 0.019614 0.2157463 2.8 0.22 0.1 0.2 +42STH33S-0956 s h 1 0 s 0 1.8 0.05 0.95 500 AC 60 10 28 20 2.5 6 100 34 0.08 0.02 4.2 35 50 -20 80 0.0117684 0.1549506 4 0.2 0.1 0.2 1 +42STH33T-0554 s h 1 0 s 0 1.8 0.05 0.55 500 AC 60 10 28 20 4.5 4 100 34 0.08 0.02 3.2 35 50 -20 80 0.0117684 0.088263 1.8 0.2 0.1 0.2 1 +42STH38-0406M s h 1 0 s 0 0.9 0.05 0.4 500 AC 60 10 28 20 30 6 100 39 0.08 0.02 30 54 50 -20 80 0.0215754 0.253992235 12 0.28 0.1 0.2 +42STH38-0806M s h 1 0 s 0 0.9 0.05 0.8 500 AC 60 10 28 20 6.7 6 100 39 0.08 0.02 7.5 54 50 -20 80 0.0215754 0.253992235 6 0.28 0.1 0.2 +42STH38-1206M s h 1 0 s 0 0.9 0.05 1.2 500 AC 60 10 28 20 3.4 6 100 39 0.08 0.02 3.3 54 50 -20 80 0.0215754 0.253992235 4 0.28 0.1 0.2 +42STH38-1684M s h 1 0 s 0 0.9 0.05 1.68 500 AC 60 10 28 20 3.2 4 100 39 0.08 0.02 1.65 54 50 -20 80 0.0215754 0.32361945 2.8 0.28 0.1 0.2 +42STH47-0406M s h 1 0 s 0 0.9 0.05 0.4 500 AC 60 10 28 20 38 6 100 47 0.08 0.02 30 68 50 -20 80 0.0245175 0.310870805 12 0.35 0.1 0.2 +42STH47-0806M s h 1 0 s 0 0.9 0.05 0.8 500 AC 60 10 28 20 10 6 100 47 0.08 0.02 7.5 68 50 -20 80 0.0245175 0.310870805 6 0.35 0.1 0.2 +42STH47-1206M s h 1 0 s 0 0.9 0.05 1.2 500 AC 60 10 28 20 4 6 100 47 0.08 0.02 3.3 68 50 -20 80 0.0245175 0.310870805 4 0.35 0.1 0.2 +42STH47-1684M s h 1 0 s 0 0.9 0.05 1.68 500 AC 60 10 28 20 4.1 4 100 47 0.08 0.02 1.65 68 50 -20 80 0.0245175 0.4314926 2.8 0.35 0.1 0.2 +57STH41-1006M s h 1 0 s 0 0.9 0.05 1 500 AC 60 15 75 20 8 6 100 41 0.08 0.02 5.7 120 50 -20 80 0.020593965 0.38245935 5.7 0.45 0.1 0.2 +57STH41-2006M s h 1 0 s 0 0.9 0.05 2 500 AC 60 15 75 20 2.2 6 100 41 0.08 0.02 1.4 120 50 -20 80 0.020593965 0.38245935 2.8 0.45 0.1 0.2 +57STH41-2804M s h 1 0 s 0 0.9 0.05 2.8 500 AC 60 15 75 20 2.2 4 100 41 0.08 0.02 0.7 120 50 -20 80 0.020593965 0.53936575 2 0.45 0.1 0.2 +57STH41-3006M s h 1 0 s 0 0.9 0.05 3 500 AC 60 15 75 20 1 6 100 41 0.08 0.02 0.63 120 50 -20 80 0.020593965 0.38245935 1.9 0.45 0.1 0.2 +57STH56-1006M s h 1 0 s 0 0.9 0.05 1 500 AC 60 15 75 20 17.5 6 100 56 0.08 0.02 7.4 300 50 -20 80 0.0392266 0.8825985 7.4 0.7 0.1 0.2 +57STH56-2006M s h 1 0 s 0 0.9 0.05 2 500 AC 60 15 75 20 4.5 6 100 56 0.08 0.02 1.8 300 50 -20 80 0.0392266 0.8825985 3.6 0.7 0.1 0.2 +57STH56-2804 s h 1 0 s 0 1.8 2.8 500 AC 60 15 75 20 2.5 4 100 56 1.6 0.08 0.02 0.9 300 50 -20 80 0.0392266 1.2356379 2.5 0.7 +57STH56-2804M s h 1 0 s 0 0.9 0.05 2.8 500 AC 60 15 75 20 4.5 4 100 56 0.08 0.02 0.9 300 50 -20 80 0.0392266 1.176798 2.5 0.7 0.1 0.2 +57STH56-3006M s h 1 0 s 0 0.9 0.05 3 500 AC 60 15 75 20 1.9 6 100 56 0.08 0.02 0.75 300 50 -20 80 0.0392266 0.8825985 2.3 0.7 0.1 0.2 +57STH76-1006M s h 1 0 s 0 0.9 0.05 1 500 AC 60 15 75 20 23 6 100 76 0.08 0.02 8.6 480 50 -20 80 0.06668522 1.32389775 8.6 1 0.1 0.2 +57STH76-2006M s h 1 0 s 0 0.9 0.05 2 500 AC 60 15 75 20 5.6 6 100 76 0.08 0.02 2.25 480 50 -20 80 0.06668522 1.32389775 4.5 1 0.1 0.2 +57STH76-2804 s h 1 0 s 0 1.8 2.8 500 AC 60 15 75 20 3.6 4 100 76 1.6 0.08 0.02 1.13 480 50 -20 80 0.06668522 1.85345685 3.2 1 +57STH76-2804M s h 1 0 s 0 0.9 0.05 2.8 500 AC 60 15 75 20 5.6 4 100 76 0.08 0.02 1.13 480 50 -20 80 0.06668522 1.765197 3.2 1 0.1 0.2 +57STH76-3006M s h 1 0 s 0 0.9 0.05 3 500 AC 60 15 75 20 2.6 6 100 76 0.08 0.02 1 480 50 -20 80 0.06668522 1.32389775 3 1 0.1 0.2 +60STH86-2008 s h 1 0 s 0 1.8 2.8 500 AC 60 6.8 8 88 1.6 1.5 840 3.1 1.4 +20STC33-0604 s h 1 1 s 0 0 1.8 0.05 0.6 500 AC 60 4 10 20 2.6 4 B 100 33 1.5 0.08 0.02 6.4 2 50 -20 80 0.022 3.84 0.06 +20STC40-0804 s h 1 1 s 0 0 1.8 0.05 0.8 500 AC 60 4 10 20 2.3 4 B 100 40 1.5 0.08 0.02 5.6 3.6 50 -20 80 0.036 4.32 0.08 +28STC32-0674 s h 1 1 s 0 0 1.8 0.05 0.67 500 AC 60 7 28 20 5.76 4 B 100 32 1.5 0.08 0.02 6.2 9 50 -20 80 0.08 4.2 0.11 +28STC32-1504 s h 1 1 s 0 0 1.8 0.05 1.5 500 AC 60 7 28 20 1 4 B 100 32 1.5 0.08 0.02 1.3 9 50 -20 80 0.08 1.95 0.11 +28STC40-0674 s h 1 1 s 0 0 1.8 0.05 0.67 500 AC 60 7 28 20 6.52 4 B 100 40 1.5 0.08 0.02 7.3 12 50 -20 80 0.13 4.9 0.14 +28STC40-1504 s h 1 1 s 0 0 1.8 0.05 1.5 500 AC 60 7 28 20 1.25 4 B 100 40 1.5 0.08 0.02 1.45 12 50 -20 80 0.13 2.2 0.14 +28STC51-0674 s h 1 1 s 0 0 1.8 0.05 0.67 500 AC 60 7 28 20 8.4 4 B 100 51.5 1.5 0.08 0.02 9.2 18 50 -20 80 0.18 6.2 0.2 +28STC51-1504 s h 1 1 s 0 0 1.8 0.05 1.5 500 AC 60 7 28 20 1.9 4 B 100 51.5 1.5 0.08 0.02 1.9 18 50 -20 80 0.18 2.7 0.2 +57ST41-1564 s h 0 r 0 1.8 0.05 1.56 60 15 75 20 3.6 4 В 100 41 1.6 2 0.08 0.02 1.8 57 50 -20 80 0.392266 2.8 0.54 +57ST76-1006 s h 0 r 0 1.8 0.05 1 10 6 76 6 200 0.593302325 0.95 0.1 0.2 +57ST76-1506 s h 0 r 0 1.8 0.05 1.5 15 75 20 6 6 76 1.6 0.08 0.02 3.6 200 50 -20 80 0.8825985 0.8826 5.4 0.95 +42STH25-0404 s h 0 s 0 0 0.4 36 4 25 24 20 0.00735525 0.16671305 9.6 0.15 +42STH33-0316 s h 0 s 0 0 1.8 0.05 0.31 100 500 AC 60 21 6 34 38.5 35 50 -20 80 0.0117684 0.1569064 12 0.22 +42STH33-0406 s h 0 s 0 0 1.8 0.05 0.4 100 500 AC 60 15 6 34 24 35 50 -20 80 0.0117684 0.1569064 9.6 0.22 +42STH33-0956 s h 0 s 0 0 1.8 0.05 0.95 100 500 AC 60 2.5 6 34 2 4.2 35 50 -20 80 0.0117684 0.1569064 4 0.22 +42STH38-0406 s h 0 s 0 0 1.8 0.05 0.4 100 500 AC 60 30 6 40 2 30 54 50 -20 80 0.0147105 0.2549729 12 0.28 +42STH38-0806 s h 0 s 0 0 1.8 0.05 0.8 100 500 AC 60 6.7 6 40 2 7.5 54 50 -20 80 0.0147105 0.2549729 6 0.28 +42STH38-1206 s h 0 s 0 0 1.8 0.05 1.2 100 500 AC 60 3.2 6 40 2 3.3 54 50 -20 80 0.0147105 0.2549729 4 0.28 +42STH47-0406 s h 0 s 0 0 1.8 0.05 0.4 100 500 AC 60 25 6 48 30 68 50 -20 80 0.019614 0.310870805 12 0.35 +42STH47-0806 s h 0 s 0 0 1.8 0.05 0.8 100 500 AC 60 6.3 6 48 7.5 68 50 -20 80 0.019614 0.310870805 6 0.35 +42STH47-1206 s h 0 s 0 0 1.8 0.05 1.2 100 500 AC 60 2.8 6 48 3.3 68 50 -20 80 0.019614 0.310870805 4 0.35 +57SH41-1 s h 0 s 0 0 1.8 0.05 1 500 AC 60 15 75 20 5.4 6 B 100 41 1.6 0.08 0.02 5.7 120 50 -20 80 0.21 0.39 5.7 0.45 +57SH41-1M s h 0 s 0 0 0.9 0.05 1 500 AC 60 15 75 20 8 6 B 100 41 1.6 0.08 0.02 5.7 120 50 -20 80 0.21 0.39 5.7 0.45 +57SH41-2 s h 0 s 0 0 1.8 0.05 2 500 AC 60 15 75 20 1.4 6 B 100 41 1.6 0.08 0.02 1.4 120 50 -20 80 0.21 0.39 2.8 0.45 +57SH41-2M s h 0 s 0 0 0.9 0.05 2 500 AC 60 15 75 20 2.2 6 B 100 41 1.6 0.08 0.02 1.4 120 50 -20 80 0.21 0.39 2.8 0.45 +57SH41-3 s h 0 s 0 0 1.8 0.05 3 500 AC 60 10 28 20 0.6 6 B 100 41 0.08 0.02 0.63 120 50 -20 80 21 0.39 1.9 0.45 +57SH41-3M s h 0 s 0 0 0.9 0.05 3 500 AC 60 15 75 20 1 6 B 100 41 1.6 0.08 0.02 0.63 120 50 -20 80 0.21 0.39 1.9 0.45 +57SH41-4 s h 0 s 0 0 1.8 0.05 2.8 500 AC 60 10 28 20 1.4 4 B 100 41 0.08 0.02 0.7 120 50 -20 80 21 0.55 2 0.45 +57SH41-4M s h 0 s 0 0 0.9 0.05 2.8 500 AC 60 15 75 20 2.2 4 B 100 41 1.6 0.08 0.02 0.7 120 50 -20 80 0.21 0.55 2 0.45 +42STH60-1206 s h 0 s 0 1.8 0.05 1.2 7 6 60 6 102 0.0274596 0.63743225 7.2 0.5 +57STH41-1006 s h 0 s 0 1.8 1 500 AC 5.4 6 100 41 0.08 0.02 5.7 120 50 -20 80 0.020593965 0.38245935 5.7 0.45 +57STH41-2006 s h 0 s 0 1.8 2 500 AC 60 15 75 20 1.4 6 100 41 0.08 0.02 1.4 120 50 -20 80 0.020593965 0.38245935 2.8 0.45 +57STH41-2804 s h 0 s 0 1.8 2.8 500 AC 60 15 75 20 1.4 4 100 41 0.08 0.02 0.7 120 50 -20 80 0.020593965 0.53936575 2 0.45 +57STH41-2804AG120 s h 0 s 0 1.8 2.8 500 AC 120 1.4 4 41 0.7 120 0.21 5.5 2 0.45 +57STH41-2804AG3 s h 0 s 0 1.8 2.8 500 AC 3 1.4 4 41 0.7 120 0.21 5.5 2 0.45 +57STH41-2804AG7.5 s h 0 s 0 1.8 2.8 500 AC 7.5 1.4 4 41 0.7 120 0.21 5.5 2 0.45 +57STH41-3006 s h 0 s 0 1.8 3 500 AC 60 15 75 20 0.6 6 100 41 0.08 0.02 0.63 120 50 -20 80 0.020593965 0.38245935 1.9 0.45 +57STH51-1006 s h 0 s 0 1.8 1 500 AC 60 15 75 8.2 6 100 51 0.08 0.02 6.6 275 50 -20 0.03530394 0.7060788 6.6 0.65 +57STH51-2006 s h 0 s 0 1.8 2 500 AC 60 15 75 2.2 6 100 51 0.08 0.02 1.65 275 50 -20 0.03530394 0.7060788 3.3 0.65 +57STH51-2804 s h 0 s 0 1.8 2.8 500 AC 60 15 75 2.2 4 100 51 0.08 0.02 0.83 275 50 -20 0.03530394 0.99047165 2.3 0.65 +57STH51-3006 s h 0 s 0 1.8 3 500 AC 60 15 75 0.9 6 100 51 0.08 0.02 0.74 275 50 -20 0.03530394 0.7060788 2.2 0.65 +57STH56-1006 s h 0 s 0 1.8 1 500 AC 60 15 75 20 10 6 100 56 0.08 0.02 7.4 300 50 -20 80 0.0392266 0.8825985 7.4 0.7 +57STH56-2006 s h 0 s 0 1.8 2 500 AC 60 15 75 20 2.5 6 100 56 0.08 0.02 1.8 300 50 -20 80 0.0392266 0.8825985 3.6 0.7 +57STH56-3006 s h 0 s 0 1.8 3 500 AC 60 15 75 20 1.1 6 100 56 0.08 0.02 0.75 300 50 -20 80 0.0392266 0.8825985 2.3 0.7 +57STH76-1006 s h 0 s 0 1.8 1 500 AC 60 15 75 20 14 6 100 76 0.08 0.02 8.6 480 50 -20 80 0.06668522 1.32389775 8.6 1 +57STH76-2006 s h 0 s 0 1.8 2 500 AC 60 15 75 20 3.6 6 100 76 0.08 0.02 2.25 480 50 -20 80 0.06668522 1.32389775 4.5 1 +57STH76-3006 s h 0 s 0 1.8 3 500 AC 60 15 75 20 1.6 6 100 76 0.08 0.02 1 480 50 -20 80 0.06668522 1.32389775 3 1 +60STH101-3004 s h 0 s 0 1.8 0.05 3 500 AC 60 4 4 100 101 0.08 0.02 2 50 -20 80 29.42 1.85 +60STH87-3008 s h 0 s 0 1.8 0.05 3 500 AC 60 3.2 8 100 87 0.08 0.02 1.3 50 -20 80 21.57 1.34 +86STH118-4208 s h 0 s 0 1.8 0.05 4.2 820 3 AC 1 60 220 20 6 8 100 118 0.08 0.02 0.9 2700 50 -20 80 0.2353596 8.5317855 2.4 3.8 +86STH118-6004 s h 0 s 0 1.8 0.05 6 820 3 AC 1 60 220 20 6.5 4 100 118 0.08 0.02 0.6 2700 50 -20 80 0.2353596 8.5317855 2.7 3.8 +86STH156-4208 s h 0 s 0 1.8 0.05 4.2 500 AC 60 60 220 20 8 8 100 156 0.08 0.02 1.25 4000 50 -20 80 0.3530394 11.964113 2.8 5.4 +86STH156-6204 s h 0 s 0 1.8 0.05 6.2 820 3 AC 1 60 220 20 9 4 100 156 0.08 0.02 0.75 4000 50 -20 80 0.3530394 11.964113 3.5 5.4 +86STH65-2808 s h 0 s 0 1.8 0.05 2.8 820 3 AC 1 60 220 20 3.9 8 100 65 0.08 0.02 1.4 1000 50 -20 80 0.0784532 3.334261 4.2 1.7 +86STH65-2808AG12.5 s h 0 s 0 1.8 0.05 2.8 500 AC 60 60 220 20 12.5 3.9 8 100 65 0.02 0.02 1.4 1000 50 -20 80 0.8 3.33 4.2 1.7 +86STH65-2808AG25 s h 0 s 0 1.8 0.05 2.8 500 AC 60 60 220 20 25 3.9 8 100 65 0.02 0.02 1.4 1000 50 -20 80 0.8 3.33 4.2 1.7 +86STH65-2808AG50 s h 0 s 0 1.8 0.05 2.8 500 AC 60 60 220 20 50 3.9 8 100 65 0.02 0.02 1.4 1000 50 -20 80 0.8 3.33 4.2 1.7 +86STH65-5904 s h 0 s 0 1.8 0.05 5.9 820 3 AC 1 60 220 20 1.7 4 100 65 0.08 0.02 0.28 1000 50 -20 80 0.0784532 3.334261 1.65 1.7 +86STH80-4208 s h 0 s 0 1.8 0.05 4.24 820 3 AC 1 60 220 20 3.4 8 80 0.08 0.02 0.75 1400 0.1176798 4.511059 2.4 2.3 +28S10-0504 s h 0 sr1 1 0 1.8 0.05 0.5 500 AC 1 4.5 4.5 20 0.88 4 B 100 9.4 0 0.04 0.06 3.7 1.7 50 -20 80 0.0098 1.85 0.028 +57STC41-2804C s h 1 s 0 0 1.8 0.05 2.8 500 AC 60 15 20 20 1.8 4 B 100 41 1.6 0.08 0.02 0.78 120 50 -20 80 0.21 0.6 2.1 0.45 +57STC41-4204C s h 1 s 0 0 1.8 0.05 4.2 500 AC 60 15 20 20 0.8 4 B 100 41 1.6 0.08 0.02 0.35 120 50 -20 80 0.21 0.6 1.5 0.45 +57STC56-2804C s h 1 s 0 0 1.8 0.05 2.8 500 AC 60 15 20 20 3.2 4 B 100 56 1.6 0.08 0.02 1 300 50 -20 80 0.4 1.4 2.8 0.7 +57STC56-4204C s h 1 s 0 0 1.8 0.05 4.2 500 AC 60 15 20 20 1.6 4 B 100 56 1.6 0.08 0.02 0.5 300 50 -20 80 0.4 1.4 2.1 0.7 +57STC76-2804C s h 1 s 0 0 1.8 0.05 2.8 500 AC 60 15 20 20 5.3 4 B 100 76 1.6 0.08 0.02 1.3 480 50 -20 80 0.68 2.3 3.6 1.2 +57STC76-4204C s h 1 s 0 0 1.8 0.05 4.2 500 AC 60 15 20 20 2.1 4 B 100 76 1.6 0.08 0.02 0.55 480 50 -20 80 0.68 2.3 2.3 1.2 +110BYG2500 s h r 0 1.8 0.05 4 1500 AC 60 60 220 20 100 86 2 0.08 0.02 6000 50 -20 80 0.784532 0.1 0.2 +110BYG2501 s h r 0 1.8 0.05 4 1500 AC 60 60 220 20 100 144 2 0.08 0.02 11000 50 -20 80 1.176798 0.1 0.2 +110BYG2502 s h r 0 1.8 0.05 5 1500 AC 60 60 220 20 100 182 2 0.08 0.02 15000 50 -20 80 1.96133 0.1 0.2 +110BYG2600 s h r 0 1.5 0.05 4 1500 AC 60 60 220 20 100 86 2 0.08 0.02 6000 50 -20 80 0.784532 0.1 0.2 +110BYG2601 s h r 0 1.5 0.05 4 1500 AC 60 60 220 20 100 142 2 0.08 0.02 11000 50 -20 80 1.176798 0.1 0.2 +110BYG2602 s h r 0 1.5 0.05 5 1500 AC 60 60 220 20 100 184 2 0.08 0.02 15000 50 -20 80 1.96133 0.1 0.2 +110BYG3500 s h r 0 1.2 0.05 3 1500 AC 60 60 220 20 100 100 3 0.08 0.02 6000 50 -20 80 0.784532 0.1 0.2 +110BYG3501 s h r 0 1.2 0.05 3 1500 AC 60 60 220 20 100 144 3 0.08 0.02 11000 50 -20 80 1.176798 0.1 0.2 +110BYG3502 s h r 0 1.2 0.05 3 1500 AC 60 60 220 20 100 182 3 0.08 0.02 15000 50 -20 80 1.569064 0.1 0.2 +110BYG3503 s h r 0 1.2 0.05 3 1500 AC 60 60 220 20 100 261 3 0.08 0.02 18000 50 -20 80 1.96133 0.1 0.2 +110BYG5501 s h r 0 0.72 0.05 3 1500 AC 60 60 220 20 100 144 5 0.08 0.02 11000 50 -20 80 0.980665 0.1 0.2 +110BYG5502 s h r 0 0.72 0.05 5 1500 AC 60 60 220 20 100 189 5 0.08 0.02 15000 50 -20 80 1.569064 0.1 0.2 +110BYG5503 s h r 0 0.72 0.05 5 1500 AC 60 60 220 20 100 231 5 0.08 0.02 18000 50 -20 80 1.96133 0.1 0.2 +130BYG2501 s h r 0 1.8 0.05 6 1500 AC 60 60 220 20 100 165 2 0.08 0.02 33000 50 -20 80 2.6477955 0.1 0.2 +130BYG2502 s h r 0 1.8 0.05 7 1500 AC 60 60 220 20 100 230 2 0.08 0.02 48000 50 -20 80 3.92266 0.1 0.2 +130BYG2503 s h r 0 1.8 0.05 7 1500 AC 60 60 220 20 100 270 2 0.08 0.02 60000 50 -20 80 4.903325 0.1 0.2 +130BYG3501 s h r 0 1.2 0.05 6 1500 AC 60 60 220 20 100 165 3 0.08 0.02 33000 50 -20 80 2.4516625 0.1 0.2 +130BYG3502 s h r 0 1.2 0.05 6 1500 AC 60 60 220 20 100 230 3 0.08 0.02 48000 50 -20 80 3.6284605 0.1 0.2 +130BYG3503 s h r 0 1.2 0.05 6 1500 AC 60 60 220 20 100 270 3 0.08 0.02 60000 50 -20 80 4.903325 0.1 0.2 +130BYG5501 s h r 0 0.72 0.05 5 1500 AC 60 60 220 20 100 165 5 0.08 0.02 33000 50 -20 80 1.96133 0.1 0.2 +130BYG5502 s h r 0 0.72 0.05 5 1500 AC 60 60 220 20 100 230 5 0.08 0.02 48000 50 -20 80 2.941995 0.1 0.2 +130BYG5503 s h r 0 0.72 0.05 5 1500 AC 60 60 220 20 100 270 5 0.08 0.02 60000 50 -20 80 3.92266 0.1 0.2 +57ST41-0406 s h r 0 1.8 0.05 0.4 15 75 20 30 6 41 1.6 0.08 0.02 30 57 50 -20 80 0.28243152 12 0.54 +57ST41-1106 s h r 0 1.8 0.05 1.1 15 75 20 3.6 6 41 1.6 0.08 0.02 3.6 57 50 -20 80 0.28243152 4 0.54 +57ST51-0426 s h r 0 1.8 0.05 0.42 15 75 20 36 6 51 1.6 0.08 0.02 29 110 50 -20 80 0.487390505 12 0.6 +57ST51-0856 s h r 0 1.8 0.05 0.85 15 75 20 9 6 51 1.6 0.08 0.02 7.1 110 50 -20 80 0.487390505 6 0.6 +57ST51-2804 s h r 0 1.8 0.05 2.8 15 75 20 2.1 4 51 1.6 0.08 0.02 0.85 110 50 -20 80 0.67665885 2.38 0.6 +57ST56-0606 s h r 0 1.8 0.05 0.6 15 75 20 32 6 56 1.6 0.08 0.02 20 135 50 -20 80 0.593302325 12 0.65 +57ST56-1206 s h r 0 1.8 0.05 1.2 15 75 20 8 6 56 1.6 0.08 0.02 5 135 50 -20 80 0.593302325 6 0.65 +57ST56-2554 s h r 0 1.8 0.05 2.55 15 75 20 3.6 4 56 1.6 0.08 0.02 1.1 135 50 -20 80 0.8237586 2.8 0.65 +57ST76-0686 s h r 0 1.8 0.05 0.68 15 75 20 30 6 76 1.6 0.08 0.02 17.7 200 50 -20 80 0.8825985 12 0.95 +57ST76-3304 s h r 0 1.8 0.05 3.3 15 75 20 3 4 76 1.6 0.08 0.02 0.85 200 50 -20 80 1.22583125 2.7 0.95 +1103P170-01 t h s 0 1.2 0.05 4.1 1800 5 AC 1 60 220 20 F 100 173 0.08 0.02 10500 50 -20 80 13.92 12 8 0.1 0.2 325 +573P42-5206 t h s 0 1.2 0.05 5.2 500 AC 60 15 75 20 1.4 F 100 42 0.08 0.02 1.3 110 50 -20 80 0.021 0.45 0.45 0.1 0.2 6.76 +573P56-5606 t h s 0 1.2 0.05 5.6 500 AC 60 15 75 20 1.7 F 100 56 0.08 0.02 0.7 300 50 -20 80 0.04 0.9 0.75 0.1 0.2 4 +573P79-5806 t h s 0 1.2 0.05 5.8 500 AC 60 15 75 20 2.4 F 100 79 0.08 0.02 1.05 480 50 -20 80 0.068 1.5 1.1 0.1 0.2 6 +863P127-01 t h s 0 1.2 0.05 2.25 1800 3 AC 1 60 220 20 41 F 100 127 0.08 0.02 9 3300 50 -20 125 6.78 6 3.8 0.1 0.2 325 +863P127-02 t h s 0 1.2 0.05 5.2 1800 3 AC 1 60 220 20 13.7 F 100 127 0.08 0.02 2.75 3300 50 -20 80 6.78 6 0.1 0.2 40 +863P67-01 t h s 0 1.2 0.05 1.75 1800 3 AC 1 60 220 20 12.3 F 100 67 0.08 0.02 4.25 1100 50 -20 125 2.26 2 1.65 0.1 0.2 325 +863P97-01 t h s 0 1.2 0.05 2 1800 3 AC 1 60 220 20 23 F 100 97 0.08 0.02 5.4 2320 50 -20 125 4.52 4 2.7 0.1 0.2 325 +863P97-02 t h s 0 1.2 0.05 5.8 1800 3 AC 1 60 220 20 3.2 F 100 97 0.08 0.02 0.9 2320 50 -20 80 4.52 4 2.7 0.1 0.2 40 +423P24-0903 t 0 0 s 0 0 1.2 0.05 0.9 500 AC 60 10 28 20 3.2 3 B 100 24 0.08 0.02 6.2 20 50 -20 80 0.08 5.58 0.14 +423P39-2403 t 0 0 s 0 0 1.2 0.05 2.4 500 AC 60 10 28 20 0.8 3 B 100 39 0.08 0.02 1.2 54 50 -20 80 0.2 2.88 0.28 +573P42 t 0 s 0 0 1.2 0.05 5.2 500 AC 60 15 75 20 1.4 6 B 100 42 0.08 0.02 1.3 110 50 -20 80 0.45 6.76 0.45 +573P56 t 0 s 0 0 1.2 0.05 5.6 500 AC 60 15 75 20 1.7 6 B 100 56 0.08 0.02 0.7 300 50 -20 80 0.9 4 0.75 +573P79 t 0 s 0 0 1.2 0.05 5.8 500 AC 60 15 75 20 2.4 6 B 100 79 0.08 0.02 1.05 480 50 -20 80 1.5 6 1.1 +603P53-1503 t 0 s 0 0 1.2 0.05 1.5 500 AC 60 15 75 20 12 3 B 100 53.5 0.08 0.02 4.5 260 50 -20 80 0.9 6.75 0.8 diff --git a/tests/tests.py b/tests/tests.py new file mode 100755 index 0000000..0926d58 --- /dev/null +++ b/tests/tests.py @@ -0,0 +1,149 @@ +#!/usr/bin/env python3 +import csv +import itertools +import re +import sys +import unittest +from pathlib import Path + +from parameterized import param, parameterized + +thisDir = Path(__file__).parent + +sys.path.insert(0, str(thisDir.parent)) + +from collections import OrderedDict + +dict = OrderedDict + +import FullingMotorModelDecoder +from FullingMotorModelDecoder import decodeModel + + +def tryIntoNum(v: str): + try: + return int(v) + except ValueError: + try: + return float(v) + except ValueError: + return v + + +typeMapping = { + "t": "three_phase", + "b": "brushless", + "p": "permanent", + "s": "stepper", +} + +stepperSeriesMapping = { + "t": "standard", + "h": "hybrid", +} + +shapeMapping = { + "s": "square", + "r": "round", + "sr1": "square with 1 rounded side", +} + +boolsKeys = {"price_performance", "hybrid", "gyro", "encoder", "flat", "high_torque", "hyper_torque", "screwed_shaft", "key_way", "electronics"} + + +def decodeTsvRow(rd: dict) -> dict: + res = {} + res.update(rd) + res["type"] = typeMapping[res["type"]] + res["shape"] = shapeMapping[res["shape"]] + + if res["type"] == "stepper" and "series" in res: + res["series"] = stepperSeriesMapping[res["series"]] + + res = {k: tryIntoNum(v) for k, v in res.items()} + res = {k: (bool(v) if k in boolsKeys else v) for k, v in res.items()} + res = {k: v for k, v in res.items() if v != "" and v is not None} + + if "angle_step" in res: + res["steps_per_revolution"] = 360 / res["angle_step"] + + return res + + +def genTestCases(): + tests = list(csv.DictReader((thisDir / "motors.tsv").read_text().splitlines(), dialect=csv.excel_tab)) + for etalon in tests: + #print("etalon tsv:", etalon) + etalon = decodeTsvRow(etalon) + #print("etalon:", etalon) + modelName = etalon["name"] + yield {"modelName": modelName, "etalon": etalon} + + +cases = genTestCases() + + +class Tests(unittest.TestCase): + + lengthIncons = None + decodedProps = None + + @classmethod + def setUpClass(cls): + cls.lengthIncons = [] + cls.decodedProps = set() + + @classmethod + def tearDownClass(cls): + from icecream import ic + + ic(cls.lengthIncons) + ic(cls.decodedProps) + + @parameterized.expand((param(**case) for case in cases), name_func=lambda func, num, param: func.__name__ + ":" + param.kwargs["modelName"]) + def testParse(self, modelName: str, etalon: dict): + parsed = decodeModel(modelName) + #print("parsed:", parsed) + #print() + self.__class__.decodedProps |= set(parsed) + + etalonCopy = type(etalon)(etalon) + if "torque_rated" in etalonCopy: + etalonCopy["torque_rated"] = round(etalonCopy["torque_rated"], 1) + + if "motor_body_length" in etalonCopy: + etalonCopy["motor_body_length"] = round(etalonCopy["motor_body_length"]) + + etalonSubDictDiff = {} + parsedSubDictDiff = {} + + for k in sorted(set(parsed) | set(etalonCopy)): + a = etalonCopy.get(k, None) + b = parsed.get(k, None) + + if a is not None and b is not None and a != b: + etalonSubDictDiff[k] = a + parsedSubDictDiff[k] = b + + if "high_torque" in parsedSubDictDiff: + #del etalonSubDictDiff["high_torque"] + #del parsedSubDictDiff["high_torque"] + self.__class__.lengthIncons.append((m, etalonSubDictDiff["high_torque"], parsedSubDictDiff["high_torque"])) + + relativeCurrentPerPhaseDeltaThreshold = 0.091 + if "current_per_phase" in parsedSubDictDiff: + if abs(etalonSubDictDiff["current_per_phase"] - parsedSubDictDiff["current_per_phase"]) < etalonSubDictDiff["current_per_phase"] * relativeCurrentPerPhaseDeltaThreshold: + del etalonSubDictDiff["current_per_phase"] + del parsedSubDictDiff["current_per_phase"] + + relativeLengthDeltaThreshold = 0.12 + if "motor_body_length" in parsedSubDictDiff: + if abs(etalonSubDictDiff["motor_body_length"] - parsedSubDictDiff["motor_body_length"]) < etalonSubDictDiff["motor_body_length"] * relativeLengthDeltaThreshold: + del etalonSubDictDiff["motor_body_length"] + del parsedSubDictDiff["motor_body_length"] + + self.assertEqual(etalonSubDictDiff, parsedSubDictDiff) + + +if __name__ == "__main__": + unittest.main()