flake8-digit-separator 0.1.0__tar.gz

flake8_digit_separator-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Timur Valiev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

flake8_digit_separator-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.3
+Name: flake8-digit-separator
+Version: 0.1.0
+Summary: Correct placement of separators
+License: MIT
+Keywords: flake8,linter,PEP515,separator,code-style,python-linter,linting,code-standards,code-quality,flake8-plugin,flake8-formatter,code-checker,numbers,digits,FDS
+Author: Timur Valiev
+Author-email: cptchunk@yandex.ru
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: flake8 (>=7.1,<8.0)
+Project-URL: Homepage, https://github.com/imtoopunkforyou/flake8-digit-separator
+Description-Content-Type: text/markdown
+
+# flake8-digit-separator
+[![coverage](https://raw.githubusercontent.com/imtoopunkforyou/flake8-digit-separator/refs/heads/main/.github/badge/coverage.svg)](https://github.com/pytest-dev/pytest-cov)
+[![tests](https://github.com/imtoopunkforyou/flake8-digit-separator/actions/workflows/tests.yaml/badge.svg)](https://github.com/imtoopunkforyou/flake8-digit-separator/actions/workflows/tests.yaml)
+[![pypi package version](https://img.shields.io/pypi/v/flake8-digit-separator.svg)](https://pypi.org/project/flake8-digit-separator)
+[![pypi downloads](https://img.shields.io/pypi/dm/flake8-digit-separator.svg)](https://pypi.org/project/flake8-digit-separator)
+[![supported python versions](https://img.shields.io/pypi/pyversions/flake8-digit-separator.svg)](https://pypi.org/project/flake8-digit-separator)
+[![wemake-python-styleguide](https://img.shields.io/badge/style-wemake-000000.svg)](https://github.com/wemake-services/wemake-python-styleguide)
+[![license](https://img.shields.io/pypi/l/flake8-digit-separator.svg)](https://github.com/imtoopunkforyou/flake8-digit-separator/blob/main/LICENSE)  
+
+
+<p align="center">
+  <a href="https://pypi.org/project/flake8-digit-separator">
+    <img src="https://raw.githubusercontent.com/imtoopunkforyou/flake8-digit-separator/main/.github/badge/logo.png"
+         alt="FDS logo">
+  </a>
+</p>
+
+A set of [rules](https://github.com/imtoopunkforyou/flake8-digit-separator?tab=readme-ov-file#rules) on top of the capabilities provided by [PEP515](https://peps.python.org/pep-0515/).
+
+```python
+correct_int = 10_000
+correct_float = 10_000.1_234
+correct_binary = 0b_1101_1001
+correct_octal = 0o_134_155
+correct_hex = 0x_CAFE_F00D
+```
+
+## Installation
+```bash
+pip install flake8-digit-separator
+```
+
+### Dependencies
+- `python (>=3.10, <4.0)`
+- `flake8 (>=7.1, <8.0)`
+
+## Usage
+```bash
+flake8 . --select FDS
+```
+
+## Rules
+[PEP515](https://peps.python.org/pep-0515/) allows separators, but does not impose any restrictions on their position in a number (except that a number should not start/end with a separator and there should not be two separators in a row). To introduce more rigor and beauty into the code, we have written a few simple rules that we suggest following.
+
+| Rule   | Number  | Description                              | Correct       | Wrong       |
+|--------|---------|------------------------------------------|---------------|-------------|
+| FDS100 | integer | Group by 3s from right                   | 10_000        | 10_0        |
+| FDS200 | float   | Group by 3s from right                   | 10_000.1_234  | 1_0_0.123_4 |
+| FDS300 | binary  | Group by 4s from right after prefix `0b` | 0b_1101_1001  | 0b110_11    |
+| FDS400 | octal   | Group by 3s from right after prefix `0o` | 0o_12_134_155 | 0o1_23_45   |
+| FDS500 | hex     | Group by 4s from right after prefix `0x` | 0x_CAFE_F00D  | 0xCAFEF0_0D |
+
+## License
+[FDS](https://github.com/imtoopunkforyou/flake8-digit-separator) is released under the MIT License. See the bundled [LICENSE](https://github.com/imtoopunkforyou/flake8-digit-separator/blob/main/LICENSE) file for details.
+
+The logo was created using [Font Meme](https://fontmeme.com/graffiti-creator/).

flake8_digit_separator-0.1.0/README.md

@@ -0,0 +1,56 @@
+# flake8-digit-separator
+[![coverage](https://raw.githubusercontent.com/imtoopunkforyou/flake8-digit-separator/refs/heads/main/.github/badge/coverage.svg)](https://github.com/pytest-dev/pytest-cov)
+[![tests](https://github.com/imtoopunkforyou/flake8-digit-separator/actions/workflows/tests.yaml/badge.svg)](https://github.com/imtoopunkforyou/flake8-digit-separator/actions/workflows/tests.yaml)
+[![pypi package version](https://img.shields.io/pypi/v/flake8-digit-separator.svg)](https://pypi.org/project/flake8-digit-separator)
+[![pypi downloads](https://img.shields.io/pypi/dm/flake8-digit-separator.svg)](https://pypi.org/project/flake8-digit-separator)
+[![supported python versions](https://img.shields.io/pypi/pyversions/flake8-digit-separator.svg)](https://pypi.org/project/flake8-digit-separator)
+[![wemake-python-styleguide](https://img.shields.io/badge/style-wemake-000000.svg)](https://github.com/wemake-services/wemake-python-styleguide)
+[![license](https://img.shields.io/pypi/l/flake8-digit-separator.svg)](https://github.com/imtoopunkforyou/flake8-digit-separator/blob/main/LICENSE)  
+
+
+<p align="center">
+  <a href="https://pypi.org/project/flake8-digit-separator">
+    <img src="https://raw.githubusercontent.com/imtoopunkforyou/flake8-digit-separator/main/.github/badge/logo.png"
+         alt="FDS logo">
+  </a>
+</p>
+
+A set of [rules](https://github.com/imtoopunkforyou/flake8-digit-separator?tab=readme-ov-file#rules) on top of the capabilities provided by [PEP515](https://peps.python.org/pep-0515/).
+
+```python
+correct_int = 10_000
+correct_float = 10_000.1_234
+correct_binary = 0b_1101_1001
+correct_octal = 0o_134_155
+correct_hex = 0x_CAFE_F00D
+```
+
+## Installation
+```bash
+pip install flake8-digit-separator
+```
+
+### Dependencies
+- `python (>=3.10, <4.0)`
+- `flake8 (>=7.1, <8.0)`
+
+## Usage
+```bash
+flake8 . --select FDS
+```
+
+## Rules
+[PEP515](https://peps.python.org/pep-0515/) allows separators, but does not impose any restrictions on their position in a number (except that a number should not start/end with a separator and there should not be two separators in a row). To introduce more rigor and beauty into the code, we have written a few simple rules that we suggest following.
+
+| Rule   | Number  | Description                              | Correct       | Wrong       |
+|--------|---------|------------------------------------------|---------------|-------------|
+| FDS100 | integer | Group by 3s from right                   | 10_000        | 10_0        |
+| FDS200 | float   | Group by 3s from right                   | 10_000.1_234  | 1_0_0.123_4 |
+| FDS300 | binary  | Group by 4s from right after prefix `0b` | 0b_1101_1001  | 0b110_11    |
+| FDS400 | octal   | Group by 3s from right after prefix `0o` | 0o_12_134_155 | 0o1_23_45   |
+| FDS500 | hex     | Group by 4s from right after prefix `0x` | 0x_CAFE_F00D  | 0xCAFEF0_0D |
+
+## License
+[FDS](https://github.com/imtoopunkforyou/flake8-digit-separator) is released under the MIT License. See the bundled [LICENSE](https://github.com/imtoopunkforyou/flake8-digit-separator/blob/main/LICENSE) file for details.
+
+The logo was created using [Font Meme](https://fontmeme.com/graffiti-creator/).

flake8_digit_separator-0.1.0/flake8_digit_separator/__version__.py

@@ -0,0 +1,45 @@
+#       ___           ___           ___
+#      /\  \         /\  \         /\  \
+#     /::\  \       /::\  \       /::\  \
+#    /:/\:\  \     /:/\:\  \     /:/\ \  \
+#   /::\~\:\  \   /:/  \:\__\   _\:\~\ \  \
+#  /:/\:\ \:\__\ /:/__/ \:|__| /\ \:\ \ \__\
+#  \/__\:\ \/__/ \:\  \ /:/  / \:\ \:\ \/__/
+#       \:\__\    \:\  /:/  /   \:\ \:\__\
+#        \/__/     \:\/:/  /     \:\/:/  /
+#                   \::/__/       \::/  /
+#                    ~~            \/__/
+
+from importlib.metadata import PackageMetadata, metadata
+from pathlib import Path
+from typing import Final
+
+pkg_data: PackageMetadata = metadata(str(Path(__file__).parent.name))
+
+NAME: Final[str] = pkg_data['Name']
+"""Package name."""
+
+VERSION: Final[str] = pkg_data['Version']
+"""Package version."""
+
+AUTHOR: Final[str] = pkg_data['Author']
+"""Package author."""
+
+AUTHOR_EMAIL: Final[str] = pkg_data['Author-email']
+"""Package author e-mail."""
+
+LICENSE: Final[str] = pkg_data['License']
+"""Package license."""
+
+
+def get_package_information() -> dict[str, str]:
+    """Short info about package."""
+    pkg_info = {
+        'name': NAME,
+        'version': VERSION,
+        'author': AUTHOR,
+        'author_email': AUTHOR_EMAIL,
+        'license': LICENSE,
+    }
+
+    return pkg_info

flake8_digit_separator-0.1.0/flake8_digit_separator/checker.py

@@ -0,0 +1,74 @@
+import ast
+import tokenize
+from typing import Iterator, TypeVar
+
+from flake8_digit_separator import __version__ as version
+from flake8_digit_separator.classifiers.registry import ClassifierRegistry
+from flake8_digit_separator.error import Error
+from flake8_digit_separator.fds_numbers.types import FDSNumbersAlias
+from flake8_digit_separator.types import ErrorMessage
+from flake8_digit_separator.validators.registry import ValidatorRegistry
+
+SelfChecker = TypeVar('SelfChecker', bound='Checker')
+
+
+class Checker:
+    name = version.NAME
+    version = version.VERSION
+
+    def __init__(
+        self: SelfChecker,
+        tree: ast.AST,
+        file_tokens: list[tokenize.TokenInfo],
+    ) -> None:
+        self.file_tokens = file_tokens
+
+    def run(self: SelfChecker) -> Iterator[ErrorMessage]:
+        """
+        Entry point and start of validation.
+
+        1. Check that the token is a number.
+        2. Classify the token.
+        3. Validate the token.
+        4. Display an error.
+
+        :yield: FDS rule that was broken.
+        :rtype: Iterator[ErrorMessage]
+        """
+        for token in self.file_tokens:
+            if token.type == tokenize.NUMBER:
+                error = self._process_number_token(token)
+                if error:
+                    yield error.as_tuple()
+
+    def _process_number_token(
+        self: SelfChecker,
+        token: tokenize.TokenInfo,
+    ) -> Error | None:
+        number = self._classify(token)
+
+        if number:
+            if not number.is_supported:
+                return None
+
+            validator = ValidatorRegistry.get_validator(number)
+            if validator.validate():
+                return None
+
+            return Error(
+                line=token.start[0],
+                column=token.start[1],
+                message=validator.error_message,
+                object_type=type(self),
+            )
+
+        return None
+
+    def _classify(self: SelfChecker, token: tokenize.TokenInfo) -> FDSNumbersAlias | None:
+        classifiers = ClassifierRegistry.get_ordered_classifiers()
+        for classifier in classifiers:
+            number = classifier(token.string).classify()
+            if number:
+                break
+
+        return number if number else None

flake8_digit_separator-0.1.0/flake8_digit_separator/classifiers/base.py

@@ -0,0 +1,72 @@
+from abc import ABC, abstractmethod
+from typing import TypeAlias, TypeVar
+
+from flake8_digit_separator.classifiers.types import TokenLikeStr
+from flake8_digit_separator.fds_numbers.fds_numbers import (
+    BinaryNumber,
+    ComplexNumber,
+    FloatNumber,
+    HexNumber,
+    IntNumber,
+    OctalNumber,
+    ScientificNumber,
+)
+
+SelfClassifier = TypeVar('SelfClassifier', bound='Classifier')
+SelfBaseClassifier = TypeVar('SelfBaseClassifier', bound='BaseClassifier')
+
+LowerTokenLikeStr: TypeAlias = str
+FDSNumbersWithPrefixAlias: TypeAlias = OctalNumber | HexNumber | BinaryNumber
+FDSNumbersUnsupportedAlias: TypeAlias = ScientificNumber | ComplexNumber
+FDSNumbersAlias: TypeAlias = IntNumber | FloatNumber | FDSNumbersUnsupportedAlias | FDSNumbersWithPrefixAlias
+
+
+class Classifier(ABC):
+    """Abstract classifier class."""
+
+    @property
+    @abstractmethod
+    def token(self: SelfClassifier) -> TokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object.
+
+        :return: Token like string.
+        :rtype: TokenLikeStr
+        """
+
+    @property
+    @abstractmethod
+    def token_lower(self: SelfClassifier) -> LowerTokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object in lower case.
+
+        :return: Token like string in lower case.
+        :rtype: LowerTokenLikeStr
+        """
+
+    @abstractmethod
+    def classify(self: SelfClassifier) -> FDSNumbersAlias | None:
+        """
+        Determines what specific number the token refers to.
+
+        :return: Object of a specific number.
+        :rtype: FDSNumbersAlias | None
+        """
+
+
+class BaseClassifier(Classifier):
+    """
+    Base classifier class.
+
+    Specific classifiers should be inherited from this class.
+    """
+
+    @property
+    def token_lower(self: SelfBaseClassifier) -> LowerTokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object in lower case.
+
+        :return: Token like string in lower case.
+        :rtype: LowerTokenLikeStr
+        """
+        return self.token.lower()

flake8_digit_separator-0.1.0/flake8_digit_separator/classifiers/classifier_binary.py

@@ -0,0 +1,41 @@
+from typing import TypeVar, final
+
+from flake8_digit_separator.classifiers.base import BaseClassifier
+from flake8_digit_separator.classifiers.types import TokenLikeStr
+from flake8_digit_separator.fds_numbers.enums import NumberPrefix
+from flake8_digit_separator.fds_numbers.fds_numbers import BinaryNumber
+
+SelfBinaryClassifier = TypeVar('SelfBinaryClassifier', bound='BinaryClassifier')
+
+
+@final
+class BinaryClassifier(BaseClassifier):
+    """Classifier for binary numbers."""
+
+    def __init__(
+        self: SelfBinaryClassifier,
+        token: TokenLikeStr,
+    ) -> None:
+        self._token = token
+
+    def classify(self: SelfBinaryClassifier) -> BinaryNumber | None:
+        """
+        Returns a binary number if it matches.
+
+        :return: Binary number
+        :rtype: BinaryNumber | None
+        """
+        if self.token_lower.startswith(NumberPrefix.BINARY.get_value_without_separator()):
+            return BinaryNumber(self.token_lower)
+
+        return None
+
+    @property
+    def token(self: SelfBinaryClassifier) -> TokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object.
+
+        :return: Token like string.
+        :rtype: TokenLikeStr
+        """
+        return self._token

flake8_digit_separator-0.1.0/flake8_digit_separator/classifiers/classifier_complex.py

@@ -0,0 +1,40 @@
+from typing import TypeVar, final
+
+from flake8_digit_separator.classifiers.base import BaseClassifier
+from flake8_digit_separator.classifiers.types import TokenLikeStr
+from flake8_digit_separator.fds_numbers.fds_numbers import ComplexNumber
+
+SelfComplexClassifier = TypeVar('SelfComplexClassifier', bound='ComplexClassifier')
+
+
+@final
+class ComplexClassifier(BaseClassifier):
+    """Classifier for complex numbers."""
+
+    def __init__(
+        self: SelfComplexClassifier,
+        token: TokenLikeStr,
+    ) -> None:
+        self._token = token
+
+    def classify(self: SelfComplexClassifier) -> ComplexNumber | None:
+        """
+        Returns a complex number if it matches.
+
+        :return: Complex number
+        :rtype: ComplexNumber | None
+        """
+        if 'j' in self.token_lower:
+            return ComplexNumber(self.token_lower)
+
+        return None
+
+    @property
+    def token(self: SelfComplexClassifier) -> TokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object.
+
+        :return: Token like string.
+        :rtype: TokenLikeStr
+        """
+        return self._token

flake8_digit_separator-0.1.0/flake8_digit_separator/classifiers/classifier_float.py

@@ -0,0 +1,41 @@
+from typing import TypeVar, final
+
+from flake8_digit_separator.classifiers.base import BaseClassifier
+from flake8_digit_separator.classifiers.types import TokenLikeStr
+from flake8_digit_separator.fds_numbers.enums import NumberDelimiter
+from flake8_digit_separator.fds_numbers.fds_numbers import FloatNumber
+
+SelfFloatClassifier = TypeVar('SelfFloatClassifier', bound='FloatClassifier')
+
+
+@final
+class FloatClassifier(BaseClassifier):
+    """Classifier for float numbers."""
+
+    def __init__(
+        self: SelfFloatClassifier,
+        token: TokenLikeStr,
+    ) -> None:
+        self._token = token
+
+    def classify(self: SelfFloatClassifier) -> FloatNumber | None:
+        """
+        Returns a float number if it matches.
+
+        :return: Float number
+        :rtype: FloatNumber | None
+        """
+        if NumberDelimiter.FLOAT.value in self.token:
+            return FloatNumber(self.token)
+
+        return None
+
+    @property
+    def token(self: SelfFloatClassifier) -> TokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object.
+
+        :return: Token like string.
+        :rtype: TokenLikeStr
+        """
+        return self._token

flake8_digit_separator-0.1.0/flake8_digit_separator/classifiers/classifier_hex.py

@@ -0,0 +1,41 @@
+from typing import TypeVar, final
+
+from flake8_digit_separator.classifiers.base import BaseClassifier
+from flake8_digit_separator.classifiers.types import TokenLikeStr
+from flake8_digit_separator.fds_numbers.enums import NumberPrefix
+from flake8_digit_separator.fds_numbers.fds_numbers import HexNumber
+
+SelfHexClassifier = TypeVar('SelfHexClassifier', bound='HexClassifier')
+
+
+@final
+class HexClassifier(BaseClassifier):
+    """Classifier for hex numbers."""
+
+    def __init__(
+        self: SelfHexClassifier,
+        token: TokenLikeStr,
+    ) -> None:
+        self._token = token
+
+    def classify(self: SelfHexClassifier) -> HexNumber | None:
+        """
+        Returns a hex number if it matches.
+
+        :return: Hex number
+        :rtype: HexNumber | None
+        """
+        if self.token_lower.startswith(NumberPrefix.HEX.get_value_without_separator()):
+            return HexNumber(self.token_lower)
+
+        return None
+
+    @property
+    def token(self: SelfHexClassifier) -> TokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object.
+
+        :return: Token like string.
+        :rtype: TokenLikeStr
+        """
+        return self._token

flake8_digit_separator-0.1.0/flake8_digit_separator/classifiers/classifier_int.py

@@ -0,0 +1,37 @@
+from typing import TypeVar, final
+
+from flake8_digit_separator.classifiers.base import BaseClassifier
+from flake8_digit_separator.classifiers.types import TokenLikeStr
+from flake8_digit_separator.fds_numbers.fds_numbers import IntNumber
+
+SelfIntClassifier = TypeVar('SelfIntClassifier', bound='IntClassifier')
+
+
+@final
+class IntClassifier(BaseClassifier):
+    """Classifier for int numbers."""
+
+    def __init__(
+        self: SelfIntClassifier,
+        token: TokenLikeStr,
+    ) -> None:
+        self._token = token
+
+    def classify(self: SelfIntClassifier) -> IntNumber:
+        """
+        Returns a int number if it matches.
+
+        :return: Int number
+        :rtype: IntNumber
+        """
+        return IntNumber(self.token)
+
+    @property
+    def token(self: SelfIntClassifier) -> TokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object.
+
+        :return: Token like string.
+        :rtype: TokenLikeStr
+        """
+        return self._token

flake8_digit_separator-0.1.0/flake8_digit_separator/classifiers/classifier_octal.py

@@ -0,0 +1,41 @@
+from typing import TypeVar, final
+
+from flake8_digit_separator.classifiers.base import BaseClassifier
+from flake8_digit_separator.classifiers.types import TokenLikeStr
+from flake8_digit_separator.fds_numbers.enums import NumberPrefix
+from flake8_digit_separator.fds_numbers.fds_numbers import OctalNumber
+
+SelfOctalClassifier = TypeVar('SelfOctalClassifier', bound='OctalClassifier')
+
+
+@final
+class OctalClassifier(BaseClassifier):
+    """Classifier for octal numbers."""
+
+    def __init__(
+        self: SelfOctalClassifier,
+        token: TokenLikeStr,
+    ) -> None:
+        self._token = token
+
+    def classify(self: SelfOctalClassifier) -> OctalNumber | None:
+        """
+        Returns a octal number if it matches.
+
+        :return: Octal number
+        :rtype: OctalNumber | None
+        """
+        if self.token_lower.startswith(NumberPrefix.OCTAL.get_value_without_separator()):
+            return OctalNumber(self.token_lower)
+
+        return None
+
+    @property
+    def token(self: SelfOctalClassifier) -> TokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object.
+
+        :return: Token like string.
+        :rtype: TokenLikeStr
+        """
+        return self._token

flake8_digit_separator-0.1.0/flake8_digit_separator/classifiers/classifier_scientific.py

@@ -0,0 +1,40 @@
+from typing import TypeVar, final
+
+from flake8_digit_separator.classifiers.base import BaseClassifier
+from flake8_digit_separator.classifiers.types import TokenLikeStr
+from flake8_digit_separator.fds_numbers.fds_numbers import ScientificNumber
+
+SelfScientifiClassifier = TypeVar('SelfScientifiClassifier', bound='ScientifiClassifier')
+
+
+@final
+class ScientifiClassifier(BaseClassifier):
+    """Classifier for scientific numbers."""
+
+    def __init__(
+        self: SelfScientifiClassifier,
+        token: TokenLikeStr,
+    ) -> None:
+        self._token = token
+
+    def classify(self: SelfScientifiClassifier) -> ScientificNumber | None:
+        """
+        Returns a scientific number if it matches.
+
+        :return: Scientific number
+        :rtype: ScientificNumber | None
+        """
+        if 'e' in self.token_lower:
+            return ScientificNumber(self.token_lower)
+
+        return None
+
+    @property
+    def token(self: SelfScientifiClassifier) -> TokenLikeStr:
+        """
+        Token string from `tokenize.TokenInfo` object.
+
+        :return: Token like string.
+        :rtype: TokenLikeStr
+        """
+        return self._token