lectes 0.1.0__py3-none-any.whl

lectes/__init__.py

@@ -0,0 +1,4 @@
+from .config.models import Rule as Rule, Configuration as Configuration
+from .engine.models import Regex as Regex
+from .scanner.scanner import Scanner as Scanner
+from .scanner.logger import LogLevel as LogLevel

lectes/config/models.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+
+from lectes.engine.models import Regex
+
+
+@dataclass
+class Rule:
+    """
+    Represents a scanner configuration rule.
+
+    Is actually a proxy for a regular expression.
+
+    ## Example
+
+    ```python
+    from lectes import Regex
+
+    Rule(name="INT_LITERAL", regex=Regex("0|([-]?[1-9]+[0-9]*))
+    ```
+    """
+
+    name: str
+    regex: Regex
+
+
+@dataclass
+class Configuration:
+    """
+    Represents the configured rules of the scanner.
+    """
+
+    rules: list[Rule]

lectes/engine/errors.py

@@ -0,0 +1,13 @@
+from lectes.errors import LectesError
+
+
+class EngineError(LectesError):
+    """
+    Base class for all errors occuring in the regex engine.
+    """
+
+
+class RegexPatternError(EngineError):
+    """
+    The regular expression is invalid or not recognized.
+    """

lectes/engine/models.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import re
+
+from lectes.engine.errors import RegexPatternError
+
+
+@dataclass
+class Match:
+    """
+    Represents a regular expression match.
+
+    Objects hold the matched string, the unmatched part of the string they were
+    checked against and the actual Regex object.
+    """
+
+    unmatched: str | None
+    string: str
+    re: "Regex"
+
+    @classmethod
+    def from_re(cls, match: re.Match) -> "Match":
+        """
+        Create an object from Python's standard library re.Match object.
+        """
+
+        index = match.span()
+        matched = match.string[index[0] : index[1]]
+        unmatched = match.string.replace(matched, "")
+        unmatched = unmatched if len(unmatched) >= 1 else None
+        return Match(unmatched=unmatched, string=matched, re=Regex.from_re(match.re))
+
+    def __bool__(self) -> bool:
+        return True
+
+    def __len__(self) -> int:
+        return len(self.string)
+
+
+class Regex:
+    """
+    Represents a regular expression.
+
+    Can be initialized with any string, but upon invoking a method, the validity
+    of the string will be checked and may raise an error.
+    """
+
+    def __init__(self, pattern: str) -> None:
+        self._pattern = pattern
+        self._re_pattern = None
+
+    @classmethod
+    def from_re(cls, pattern: re.Pattern) -> "Regex":
+        """
+        Create an object from Python's standard library re.Pattern object.
+        """
+        return Regex(pattern.pattern)
+
+    def fullmatch(self, string: str) -> Match | None:
+        """
+        If the whole string matches the regular expression, return a Match.
+        Return None if the string does not match the regular expression.
+        """
+        match = self._compiled_pattern().fullmatch(string)
+
+        if match is None:
+            return None
+
+        return Match.from_re(match)
+
+    def search(self, string: str) -> Match | None:
+        """
+        Scan through string looking for the first location where the regular
+        expression pattern produces a match, and return a Match. Return None if
+        no position in the string matches the regular expression.
+        """
+        match = self._compiled_pattern().search(string)
+
+        if match is None:
+            return None
+
+        return Match.from_re(match)
+
+    def _compiled_pattern(self) -> re.Pattern:
+        if self._re_pattern is None:
+            self._re_pattern = self._compile_pattern()
+
+        return self._re_pattern
+
+    def _compile_pattern(self) -> re.Pattern:
+        try:
+            return re.compile(self._pattern)
+        except re.PatternError as e:
+            raise RegexPatternError(str(e)) from None
+
+    def __repr__(self) -> str:
+        return f"<Regex: {self._compiled_pattern().pattern}>"

lectes/errors.py

@@ -0,0 +1,4 @@
+class LectesError(Exception):
+    """
+    Base class for all exceptions raised in lectes.
+    """

lectes/scanner/logger.py

@@ -0,0 +1,68 @@
+import logging
+from enum import Enum
+
+
+class LogLevel(Enum):
+    """
+    Log level options for the scanner's logger.
+    """
+
+    DEBUG = "DEBUG"
+
+
+class Logger:
+    """
+    Logger class for the scanner.
+    """
+
+    def __init__(self) -> None:
+        self._logger = None
+        self._handler = None
+        self._formatter = None
+
+    def set_level(self, level: LogLevel) -> None:
+        self.logger().setLevel(self._map_level(level))
+        self.handler().setLevel(self._map_level(level))
+
+    def debug(self, message: str) -> None:
+        self.logger().debug(message)
+
+    def logger(self) -> logging.Logger:
+        if self._logger is None:
+            self._logger = self._build_logger()
+
+        return self._logger
+
+    def handler(self) -> logging.StreamHandler:
+        if self._handler is None:
+            self._handler = self._build_handler()
+
+        return self._handler
+
+    def formatter(self) -> logging.Formatter:
+        if self._formatter is None:
+            self._formatter = self._build_formatter()
+
+        return self._formatter
+
+    def _build_logger(self) -> logging.Logger:
+        logger = logging.getLogger(__name__)
+        logger.addHandler(self.handler())
+
+        return logger
+
+    def _build_handler(self) -> logging.StreamHandler:
+        handler = logging.StreamHandler()
+        handler.setFormatter(self.formatter())
+
+        return handler
+
+    def _build_formatter(self) -> logging.Formatter:
+        return logging.Formatter("%(levelname)s: %(message)s")
+
+    def _map_level(self, level: LogLevel) -> int:
+        match level:
+            case LogLevel.DEBUG:
+                return logging.DEBUG
+            case _:
+                return logging.INFO

lectes/scanner/models.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+from lectes.config.models import Rule
+
+
+@dataclass
+class Token:
+    """
+    Represents a token returned by the scanner.
+
+    The scanned token is related to a configuration rule and a string literal.
+    """
+
+    rule: Rule
+    literal: str
+
+    @property
+    def name(self) -> str:
+        return self.rule.name

lectes/scanner/scanner.py

@@ -0,0 +1,150 @@
+from typing import Callable, Generator
+
+from lectes.config.models import Configuration, Rule
+from lectes.engine.models import Match
+from lectes.scanner.models import Token
+from lectes.scanner.logger import Logger, LogLevel
+
+
+class Scanner:
+    """
+    Scans a given text and returns tokens based on the provided configuration.
+
+    ## Example
+
+    ```python
+    from lectes import Rule, Configuration, Regex, Scanner
+
+    config = Configuration(
+        [
+            Rule(name="FOR", regex=Regex("for")),
+            Rule(name="INT", regex=Regex("[1-9]+")),
+            Rule(name="ID", regex=Regex("[a-zA-Z][a-zA-Z0-9]*")),
+            Rule(name="WHITESPACE", regex=Regex("( )")),
+        ]
+    )
+
+    scanner = Scanner(config)
+    program = "somevar in othervar for 9 let"
+
+    for token in scanner.scan(program):
+        print(token)
+    ```
+    """
+
+    def __init__(self, configuration: Configuration, debug: bool = False) -> None:
+        self.configuration = configuration
+        self.set_text("")
+        self._unmatched_handler = self._handle_unmatched
+        self._debug = debug
+        self._logger = None
+        self._match = None
+        self._matched_rule = None
+
+    def scan(self, text: str) -> Generator[Token]:
+        """
+        Scan the given text and yield tokens as they are recognized.
+        """
+        if len(text) == 0:
+            return
+
+        self.set_text(text)
+
+        for character in text:
+            self.logger().debug(f"character: '{character}'")
+
+            current_string = self.current_string()
+            self.logger().debug(f"current_string: '{current_string}'")
+
+            lookahead_string = self.lookahead_string()
+            self.logger().debug(f"lookahead_string: '{lookahead_string}'")
+
+            for rule in self.configuration.rules:
+                if not self._is_last_char() and rule.regex.fullmatch(lookahead_string):
+                    self.logger().debug(
+                        f"rule {rule.name} fullmatched lookahead_string: '{lookahead_string}'"
+                    )
+                    break
+
+                if match := rule.regex.search(current_string):
+                    self.logger().debug(
+                        f"rule {rule.name} matched current_string: '{current_string}'"
+                    )
+                    self._update_matched_state(rule, match)
+
+            if self._match is not None:
+                if self._match.unmatched is not None:
+                    self._unmatched_handler(self._match.unmatched)
+
+                if self._matched_rule is not None:
+                    yield Token(rule=self._matched_rule, literal=self._match.string)
+
+                self.last_position = self.current_position
+
+            self.current_position += 1
+            self._reset_matched_state()
+
+    def set_unmatched_handler(self, handler: Callable[[str], None]) -> None:
+        """
+        Set the given function as the handler that executes when a string is not
+        matched to a configured rule.
+
+        The handler receives the string as argument and does returns None.
+        """
+        self._unmatched_handler = handler
+
+    def set_text(self, text: str) -> None:
+        """
+        Set the text to scan.
+        """
+        self.text = text
+        self.current_position = 1
+        self.last_position = 0
+
+    def current_string(self) -> str:
+        """
+        Return the string that the scanner is currently reading; that is,
+        the characters from the last matched string up to the character that
+        the scanner is currently reading.
+        """
+        return self.text[self.last_position : self.current_position]
+
+    def lookahead_string(self) -> str:
+        """
+        Return the string that the scanner is currently reading plus one character.
+        """
+        return self.text[self.last_position : self.current_position + 1]
+
+    def logger(self) -> Logger:
+        """
+        Return the scanner's logger instance.
+        """
+        if self._logger is None:
+            self._logger = self._build_logger()
+
+        return self._logger
+
+    def _build_logger(self) -> Logger:
+        logger = Logger()
+
+        if self._debug:
+            logger.set_level(LogLevel.DEBUG)
+
+        return logger
+
+    def _is_last_char(self) -> bool:
+        return self.current_position == len(self.text)
+
+    def _update_matched_state(self, rule: Rule, match: Match) -> None:
+        if self._match is None or len(match) > len(self._match):
+            self.logger().debug(f"updating match from {self._match} to {match.string}")
+            self._matched_rule = rule
+            self._match = match
+
+    def _reset_matched_state(self) -> None:
+        self._match = None
+        self._matched_rule = None
+
+    @staticmethod
+    def _handle_unmatched(unmatched: str) -> None:
+        print(f"unmatched: {unmatched}")

lectes/tests/unit/engine/test_models.py

@@ -0,0 +1,150 @@
+from re import Pattern
+from unittest_extensions import args, TestCase
+
+from lectes.engine.models import Regex
+from lectes.engine.errors import RegexPatternError
+
+
+class TestRegexSearch(TestCase):
+    def subject(self, pattern, string=""):
+        return Regex(pattern).search(string)
+
+    def assert_unmatched(self, unmatched):
+        self.assertResultTrue()
+        self.assertSequenceEqual(self.cachedResult().unmatched, unmatched)
+
+    def assert_pattern_error(self):
+        with self.assertRaises(RegexPatternError):
+            self.result()
+
+    @args(pattern="(")
+    def test_unclosed_parentheses(self):
+        self.assert_pattern_error()
+
+    @args(pattern="[a-Z]")
+    def test_all_letters_class(self):
+        self.assert_pattern_error()
+
+    @args(pattern="a", string="a b a")
+    def test_simple_char_two_occurences_in_string(self):
+        self.assert_unmatched(" b ")
+
+    @args(pattern="a", string="bcd")
+    def test_simple_char_absence_in_string(self):
+        self.assertResultFalse()
+
+    @args(pattern="for", string="for i in a:")
+    def test_word_occurence(self):
+        self.assertResultTrue()
+
+    @args(pattern="for", string="a: int = 2")
+    def test_word_absence(self):
+        self.assertResultFalse()
+
+    @args(pattern="for", string="forum")
+    def test_word_occurence_in_substring(self):
+        self.assertResultTrue()
+
+    @args(pattern="ab|cd", string="abd")
+    def test_character_alternation(self):
+        self.assert_unmatched("d")
+
+    @args(pattern="ab|cd", string="aca")
+    def test_alternation_does_not_match(self):
+        self.assertResultFalse()
+
+    @args(pattern="ab|cd", string="cd")
+    def test_character_alternation_presedence(self):
+        self.assertResultTrue()
+
+    @args(pattern="ab|abc|abcd", string="abcde")
+    def test_multiple_alternation(self):
+        self.assert_unmatched("cde")
+
+    @args(pattern="this|that", string="this or that")
+    def test_alternation_first_match(self):
+        self.assert_unmatched(" or that")
+
+    @args(pattern="a?b", string="bcd")
+    def test_zero_or_one_zero(self):
+        self.assert_unmatched("cd")
+
+    @args(pattern="a?b", string="abcd")
+    def test_zero_or_one_one(self):
+        self.assert_unmatched("cd")
+
+    @args(pattern="a?b", string="cd")
+    def test_zero_or_one_absence(self):
+        self.assertResultFalse()
+
+    @args(pattern="a*b", string="bcd")
+    def test_zero_or_more_zero(self):
+        self.assert_unmatched("cd")
+
+    @args(pattern="a*b", string="abcd")
+    def test_zero_or_more_one(self):
+        self.assert_unmatched("cd")
+
+    @args(pattern="a*b", string="aabcd")
+    def test_zero_or_more_two(self):
+        self.assert_unmatched("cd")
+
+    @args(pattern="a*b", string="cd")
+    def test_zero_or_more_absence(self):
+        self.assertResultFalse()
+
+    @args(pattern="a+b", string="bcd")
+    def test_one_or_more_zero(self):
+        self.assertResultFalse()
+
+    @args(pattern="a+b", string="abcd")
+    def test_one_or_more_one(self):
+        self.assert_unmatched("cd")
+
+    @args(pattern="a+b", string="aabcd")
+    def test_one_or_more_two(self):
+        self.assert_unmatched("cd")
+
+    @args(pattern="[a-z]", string="k")
+    def test_small_letter_class(self):
+        self.assertResultTrue()
+
+    @args(pattern="[a-z]", string="K")
+    def test_small_letter_class_with_capital(self):
+        self.assertResultFalse()
+
+    @args(pattern="[A-Z]", string="U")
+    def test_capital_letter_class(self):
+        self.assertResultTrue()
+
+    @args(pattern="[a-d]", string="e")
+    def test_letter_class_out_of_range(self):
+        self.assertResultFalse()
+
+    @args(pattern="[a-z]", string=" ")
+    def test_letter_class_with_whitespace(self):
+        self.assertResultFalse()
+
+    @args(pattern="[A-Z]", string="y")
+    def test_capital_letter_class_with_downcase(self):
+        self.assertResultFalse()
+
+    @args(pattern="[0-4]", string="3")
+    def test_numeric_class_in_range(self):
+        self.assertResultTrue()
+
+    @args(pattern="[2-7]", string="1")
+    def test_numeric_class_out_of_range(self):
+        self.assertResultFalse()
+
+    @args(pattern="[a-zA-Z]", string="b")
+    def test_all_letters_compound_class(self):
+        self.assertResultTrue()
+
+    @args(pattern="[a-zA-Z]", string="G")
+    def test_all_letters_compound_class_capital(self):
+        self.assertResultTrue()
+
+    @args(pattern="[a-zA-Z2-6]", string="5")
+    def test_letter_and_numeric_class(self):
+        self.assertResultTrue()

lectes/tests/unit/scanner/test_scanner.py

@@ -0,0 +1,285 @@
+from unittest_extensions import args, TestCase
+
+from lectes.config.models import Rule, Configuration
+from lectes.engine.models import Regex
+from lectes.scanner.scanner import Scanner
+
+
+def rule(name, regex):
+    return Rule(name=name, regex=Regex(regex))
+
+
+class TestScanner(TestCase):
+    def subject(self, text):
+        return list(self.scanner().scan(text))
+
+    def scanner(self):
+        return Scanner(self.configuration())
+
+    def configuration(self):
+        return Configuration(self.rules())
+
+    def assert_tokens(self, *tokens):
+        self.assertSequenceEqual(list(map(lambda t: t.name, self.result())), tokens)
+
+
+class TestScannerSimpleGrammar(TestScanner):
+    def rules(self):
+        return [
+            rule("FOR", "for"),
+            rule("INT_LITERAL", "[0-9]+"),
+            rule("INT", "int"),
+            rule("ID", "[a-zA-Z][a-zA-Z0-9]*"),
+            rule("WHITESPACE", "( )"),
+        ]
+
+    @args("somevar in othervar for 9 let")
+    def test_scan(self):
+        self.assert_tokens(
+            "ID",
+            "WHITESPACE",
+            "ID",
+            "WHITESPACE",
+            "ID",
+            "WHITESPACE",
+            "FOR",
+            "WHITESPACE",
+            "INT_LITERAL",
+            "WHITESPACE",
+            "ID",
+        )
+
+    @args("int myint ")
+    def test_longer_match(self):
+        self.assert_tokens("INT", "WHITESPACE", "ID", "WHITESPACE")
+
+
+class TestScannerClassicGrammar(TestScanner):
+    def rules(self):
+        return [
+            rule("OPER", "oper"),
+            rule("EXEMP", "exemp"),
+            rule("INT", "int"),
+            rule("DUPL", "dupl"),
+            rule("STR", "str"),
+            rule("ANEF", "anef"),
+            rule("EGO", "ego"),
+            rule("INITUS", "initus"),
+            rule("EXODUS", "exodus"),
+            rule("ID", "(_|[a-zA-Z])(_|[a-zA-Z0-9])*"),
+            rule("INT_LITERAL", "[-]?[0-9]+"),
+            rule("DOUBLE_LITERAL", "[-+]?[0-9]+\.?[0-9]*"),
+            rule("PLUS", "\+"),
+            rule("MINUS", "-"),
+            rule("DIV", "/"),
+            rule("MUL", "\*"),
+            rule("LPAREN", "\("),
+            rule("RPAREN", "\)"),
+            rule("LBRACK", "{"),
+            rule("RBRACK", "}"),
+            rule("COLON", ":"),
+            rule("SEMICOLON", ";"),
+            rule("DOT", "[.]"),
+            rule("COMMA", "[,]"),
+            rule("EQUAL", "="),
+            rule("WHITESPACE", "( )"),
+            rule("NEWLINE", "\\n"),
+            rule("TAB", "\\t"),
+            rule("BEGIN_COMMENT", "/\*"),
+            rule("END_COMMENT", "\*/"),
+        ]
+
+    @args(
+        """oper: int simple_function(int myint) {
+    exodus myint;
+}
+
+oper: int initus() {
+    exodus simple_function(myint=0)
+}"""
+    )
+    def test_scan_simple_program(self):
+        self.assert_tokens(
+            "OPER",
+            "COLON",
+            "WHITESPACE",
+            "INT",
+            "WHITESPACE",
+            "ID",
+            "LPAREN",
+            "INT",
+            "WHITESPACE",
+            "ID",
+            "RPAREN",
+            "WHITESPACE",
+            "LBRACK",
+            "NEWLINE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "EXODUS",
+            "WHITESPACE",
+            "ID",
+            "SEMICOLON",
+            "NEWLINE",
+            "RBRACK",
+            "NEWLINE",
+            "NEWLINE",
+            "OPER",
+            "COLON",
+            "WHITESPACE",
+            "INT",
+            "WHITESPACE",
+            "INITUS",
+            "LPAREN",
+            "RPAREN",
+            "WHITESPACE",
+            "LBRACK",
+            "NEWLINE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "EXODUS",
+            "WHITESPACE",
+            "ID",
+            "LPAREN",
+            "ID",
+            "EQUAL",
+            "INT_LITERAL",
+            "RPAREN",
+            "NEWLINE",
+            "RBRACK",
+        )
+
+    @args(
+        """oper: int add(int a, int b) {
+    exodus a + b;
+}
+
+oper: int mul(int a, int b) {
+    exodus a * b;
+}
+
+oper: int initus() {
+    exodus add(a=2, b=3) + mul(a=4, b=5)
+}"""
+    )
+    def test_scan_program(self):
+        self.assert_tokens(
+            "OPER",
+            "COLON",
+            "WHITESPACE",
+            "INT",
+            "WHITESPACE",
+            "ID",
+            "LPAREN",
+            "INT",
+            "WHITESPACE",
+            "ID",
+            "COMMA",
+            "WHITESPACE",
+            "INT",
+            "WHITESPACE",
+            "ID",
+            "RPAREN",
+            "WHITESPACE",
+            "LBRACK",
+            "NEWLINE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "EXODUS",
+            "WHITESPACE",
+            "ID",
+            "WHITESPACE",
+            "PLUS",
+            "WHITESPACE",
+            "ID",
+            "SEMICOLON",
+            "NEWLINE",
+            "RBRACK",
+            "NEWLINE",
+            "NEWLINE",
+            "OPER",
+            "COLON",
+            "WHITESPACE",
+            "INT",
+            "WHITESPACE",
+            "ID",
+            "LPAREN",
+            "INT",
+            "WHITESPACE",
+            "ID",
+            "COMMA",
+            "WHITESPACE",
+            "INT",
+            "WHITESPACE",
+            "ID",
+            "RPAREN",
+            "WHITESPACE",
+            "LBRACK",
+            "NEWLINE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "EXODUS",
+            "WHITESPACE",
+            "ID",
+            "WHITESPACE",
+            "MUL",
+            "WHITESPACE",
+            "ID",
+            "SEMICOLON",
+            "NEWLINE",
+            "RBRACK",
+            "NEWLINE",
+            "NEWLINE",
+            "OPER",
+            "COLON",
+            "WHITESPACE",
+            "INT",
+            "WHITESPACE",
+            "INITUS",
+            "LPAREN",
+            "RPAREN",
+            "WHITESPACE",
+            "LBRACK",
+            "NEWLINE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "WHITESPACE",
+            "EXODUS",
+            "WHITESPACE",
+            "ID",
+            "LPAREN",
+            "ID",
+            "EQUAL",
+            "INT_LITERAL",
+            "COMMA",
+            "WHITESPACE",
+            "ID",
+            "EQUAL",
+            "INT_LITERAL",
+            "RPAREN",
+            "WHITESPACE",
+            "PLUS",
+            "WHITESPACE",
+            "ID",
+            "LPAREN",
+            "ID",
+            "EQUAL",
+            "INT_LITERAL",
+            "COMMA",
+            "WHITESPACE",
+            "ID",
+            "EQUAL",
+            "INT_LITERAL",
+            "RPAREN",
+            "NEWLINE",
+            "RBRACK",
+        )

lectes-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: lectes
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# lectes
+Python lexer generator

lectes-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+lectes/__init__.py,sha256=OaG0A_KPRZK6-N_JS78Je-czxZLGYF9-TTQ3vI1D4jI,211
+lectes/errors.py,sha256=7DCHpxPzfiKoGo6704tc3RCdv5rKR5pMtfB7JPxtrtM,98
+lectes/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lectes/config/models.py,sha256=h2rtMYxKbhy-OZ3qLcOBQxpSKcCVkEiMffnJNaQYd5w,501
+lectes/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lectes/engine/errors.py,sha256=1cEuWVNDG5dH0no2EkN30mXfnxifLBk_mu6tHz4BDfA,261
+lectes/engine/models.py,sha256=BH0AsAxyE70dBVG70QhcMAnrSIQ7cVNL_-5Vith-LAE,2780
+lectes/scanner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lectes/scanner/logger.py,sha256=-IAi7-rXIkgwVuv2XhHVQTUCesD_gmdb_HIE44lM-UI,1701
+lectes/scanner/models.py,sha256=MF5AdqqAZgrA8dZ6KcryuN2HXOW8Fg9-llhIE-oeJDA,348
+lectes/scanner/scanner.py,sha256=x6WXWheJtRzh9hqGVSPv_0Cvlv-Su_A3bcaKS2BQ-PE,4832
+lectes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lectes/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lectes/tests/unit/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lectes/tests/unit/engine/test_models.py,sha256=9WS9aWUVX7vgWC5IBnaTVbtlXM-yn2EjaNmIjjD8vOQ,4452
+lectes/tests/unit/scanner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lectes/tests/unit/scanner/test_scanner.py,sha256=pBHaesSDr1EH5QN9Xgh_JK7bxXaivoOBEnwJ9gBprLc,6834
+lectes-0.1.0.dist-info/licenses/LICENSE,sha256=7Kt0nEcUePIgPCSj1z3bzBQD7MXF6b2QHspqHCvjWQg,1076
+lectes-0.1.0.dist-info/METADATA,sha256=rI5z6KGnmB36bOHHAEW233_D67eZzG6s1STLvu12DLo,226
+lectes-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lectes-0.1.0.dist-info/top_level.txt,sha256=i3GoBfdsTrXfoaYeaoRHoREwX2KtpFvREBQ6KkYmjUM,7
+lectes-0.1.0.dist-info/RECORD,,

lectes-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lectes-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Maximos Nikiforakis
+
+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.

lectes-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lectes