CLASPLint 0.1.0__tar.gz → 0.2.0__tar.gz

CLASPLint-0.2.0/CLASPLint/__init__.py

@@ -0,0 +1,34 @@
+"""
+THIS FILE IS PART OF CLASPLINT BY MATT BELFAST BROWN
+CLASPLint.__init__ — Package entry point and public API surface.
+
+Exposes the runner and reporter modules as the primary public interface for
+programmatic use of the CLASP 3.0 / PEP 2606 static analysis engine.
+
+Author: Matt Belfast Brown
+Create Date: 2026-06-17
+Version Date: 2026-06-21
+Version: 0.2.0
+
+THIS PROGRAM IS LICENSED UNDER GPL-3.0
+YOU SHOULD HAVE RECEIVED A COPY OF GPL-3.0 LICENSE.
+
+Copyright (C) 2026 Matt Belfast Brown
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, version 3 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+# Define the package version string.
+__version__ = "0.2.0"
+# Expose the runner and reporter modules as the public API.
+__all__ = ["runner", "reporter"]

{CLASPLint-0.1.0 → CLASPLint-0.2.0}/CLASPLint/__main__.py

@@ -1,4 +1,29 @@
-# Provide the CLASPLint command-line interface entry point.
+"""
+THIS FILE IS PART OF CLASPLINT BY MATT BELFAST BROWN
+CLASPLint.__main__ — command-line entry point for the CLASP 3.0 static analysis tool.
+
+Author: Matt Belfast Brown
+Create Date: 2026-06-17
+Version Date: 2026-06-21
+Version: 0.2.0
+
+THIS PROGRAM IS LICENSED UNDER GPL-3.0
+YOU SHOULD HAVE RECEIVED A COPY OF GPL-3.0 LICENSE.
+
+Copyright (C) 2026 Matt Belfast Brown
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, version 3 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
 
 import argparse
 import sys
@@ -12,36 +37,57 @@ def _init_build_parser_function_() -> argparse.ArgumentParser:
     """Construct the argument parser for the CLASPLint CLI."""
     # Create the top-level argument parser with a description.
     parser_result = argparse.ArgumentParser(
+        # Set the program name displayed in help text.
         prog="CLASPLint",
+        # Provide a description of what the tool does.
         description="CLASP 3.0 / PEP 2606 static analysis tool. "
+                    # Continue the description across multiple lines for readability.
                     "Checks variable, dict key, function, class naming "
+                    # Complete the tool description with comment and log conventions.
                     "and comment/log conventions.",
+    # Close the ArgumentParser constructor call.
     )
     # Accept one or more file or directory paths as positional arguments.
     parser_result.add_argument(
+        # Accept zero or more path strings as positional arguments.
         "paths", nargs="*", default=["."],
+        # Provide the help text for the paths argument.
         help="Python files or directories to check (default: current directory).",
+    # Close the first add_argument call.
     )
     # Provide a --version flag to display the tool version.
     parser_result.add_argument(
+        # Use the version action to print the version string and exit.
         "--version", action="version",
+        # Construct the version message from the package version.
         version=f"CLASPLint {__version__}",
+    # Close the second add_argument call.
     )
     # Provide a flag to disable recursive directory traversal.
     parser_result.add_argument(
+        # Store True when --no-recursive is passed on the command line.
         "--no-recursive", action="store_true",
+        # Provide the help text for the no-recursive flag.
         help="Do not recursively check subdirectories.",
+    # Close the third add_argument call.
     )
     # Provide a quiet mode that suppresses per-violation output.
     parser_result.add_argument(
+        # Support both --quiet and -q flags for convenience.
         "--quiet", "-q", action="store_true",
+        # Provide the help text for the quiet flag.
         help="Suppress individual violation output; show only summary.",
+    # Close the fourth add_argument call.
     )
     # Provide a category filter to report only specific violation types.
     parser_result.add_argument(
+        # Accept --category or -c with a choice of violation types.
         "--category", "-c",
-        choices=["variable", "dict_key", "function", "comment", "log"],
+        # Restrict the value to the five supported violation categories.
+        choices=["variable", "dict_key", "function", "comment", "log", "docstring"],
+        # Provide the help text for the category filter.
         help="Only report violations of a specific category.",
+    # Close the fifth add_argument call.
     )
     # Return the fully configured argument parser.
     return parser_result
@@ -61,6 +107,7 @@ def main(argv: list = None) -> int:
         string_absolute = os.path.abspath(string_path)
         # Only include paths that exist on the filesystem.
         if os.path.exists(string_absolute):
+            # Add the resolved absolute path to the list.
             list_resolved.append(string_absolute)
     # Report an error if no valid paths were found.
     if not list_resolved:
@@ -76,9 +123,11 @@ def main(argv: list = None) -> int:
     if args.category:
         # Filter violations to only the requested category.
         report_result.list_violations = [
+            # Iterate over each violation to check against the filter.
             v for v in report_result.list_violations
             # Keep only violations matching the requested category filter.
             if v.string_category == args.category
+        # Close the filtered list comprehension.
         ]
     # Print the summary line to stdout.
     print(report_result.summary())

{CLASPLint-0.1.0 → CLASPLint-0.2.0}/CLASPLint/comment_checker.py

@@ -1,4 +1,29 @@
-# Check that every code line has a proper CLASP 3.0 formatted comment.
+"""
+THIS FILE IS PART OF CLASPLINT BY MATT BELFAST BROWN
+CLASPLint.comment_checker — Validates that every code line has a preceding CLASP 3.0 formatted comment.
+
+Author: Matt Belfast Brown
+Create Date: 2026-06-17
+Version Date: 2026-06-21
+Version: 0.2.0
+
+THIS PROGRAM IS LICENSED UNDER GPL-3.0
+YOU SHOULD HAVE RECEIVED A COPY OF GPL-3.0 LICENSE.
+
+Copyright (C) 2026 Matt Belfast Brown
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, version 3 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
 
 import ast
 import io
@@ -7,11 +32,18 @@ from typing import List, Set
 
 from .reporter import Violation
 
-# Define control flow and operation keywords that require a preceding comment.
-keywords_requirecomment = frozenset({
-    "if", "elif", "else", "for", "while", "try", "except",
-    "finally", "with", "return", "raise", "continue", "break",
-    "pass",
+# Define line-starting keywords that are exempt from the comment requirement.
+# Imports, class definitions, and function definitions are structural declarations.
+keywords_exemptfromcomment = frozenset({
+    # Include the standard import statement keyword.
+    "import",
+    # Include the from-import statement keyword.
+    "from",
+    # Include the class definition keyword.
+    "class",
+    # Include the function definition keyword.
+    "def",
+# Close the exempt keywords frozenset literal.
 })
 
 
@@ -22,9 +54,30 @@ def _tokenize_source(string_source: str) -> List[tokenize.TokenInfo]:
 
 
 class CommentChecker:
-    """Check that every code line has a proper CLASP 3.0 comment."""
+    """
+    Validates that every code line has a preceding comment and that all comments follow the CLASP 3.0 format.
+
+    Public methods:
+        run — Executes both the line-comment presence check and the comment format validation in sequence.
+
+    Private methods:
+        _init_line_comments_function_ — Verifies that every physical code line has a preceding comment per CLASP 3.0.
+        _init_comment_format_function_ — Validates that every comment follows the capitalized sentence format with a trailing period.
+        _init_docstring_line_function_ — Determines whether a given line number falls within a docstring expression.
+    """
 
     def __init__(self, string_filepath: str, string_source: str):
+        """
+        Initialize the comment checker with the file path and full source code.
+
+        Stores the file path for violation reporting, the complete source as a string for
+        tokenization, and splits it into lines for per-line access by format checks.
+
+        :param string_filepath: The absolute path to the Python file being checked.
+        :type string_filepath: str
+        :param string_source: The complete source code of the file as a single string.
+        :type string_source: str
+        """
         # Store the file path for violation reporting.
         self.string_filepath = string_filepath
         # Store the full source code as a string.
@@ -35,16 +88,28 @@ class CommentChecker:
         self.list_violations: List[Violation] = []
 
     def run(self) -> None:
-        """Run all comment format and presence checks."""
+        """
+        Run all comment format and presence checks.
+
+        Executes both the line-comment presence check and the comment format validation
+        in sequence, populating the internal violations list with any issues found.
+        """
         # Check that every code line requiring a comment has one.
         self._init_line_comments_function_()
         # Check that every comment follows the required format.
         self._init_comment_format_function_()
 
     def _init_line_comments_function_(self) -> None:
-        """Verify that every physical code line with a control keyword has a comment."""
+        """
+        Verify that every physical code line has a preceding comment per CLASP 3.0.
+
+        Tokenizes the source code to identify code lines and comment lines, then checks
+        that every non-exempt code line has a comment on the same line or the line before.
+        Import, class, and function definition lines are exempt from this requirement.
+        """
         # Attempt to tokenize the source; skip if tokenization fails.
         try:
+            # Tokenize the full source code into a list of token objects.
             list_tokens = _tokenize_source(self.string_source)
         # Return early if the source cannot be tokenized.
         except tokenize.TokenError:
@@ -58,15 +123,21 @@ class CommentChecker:
         for token_item in list_tokens:
             # Add comment token line numbers to the comment set.
             if token_item.type == tokenize.COMMENT:
+                # Record the line number of this comment token.
                 set_commentlines.add(token_item.start[0])
             # Add single-line string token line numbers to the code set.
             elif token_item.type == tokenize.STRING and token_item.start[0] == token_item.end[0]:
+                # Record the line number of this single-line string token.
                 set_codelines.add(token_item.start[0])
             # Add all other meaningful token line numbers to the code set.
             elif token_item.type not in (
+                # Exclude newline token types from the code line set.
                 tokenize.NEWLINE, tokenize.NL, tokenize.ENDMARKER,
+                # Exclude indentation token types from the code line set.
                 tokenize.INDENT, tokenize.DEDENT, tokenize.ENCODING,
+            # Close the excluded token type tuple.
             ):
+                # Record the line number of this meaningful code token.
                 set_codelines.add(token_item.start[0])
         # Check each code line for required comments.
         for int_lineno in sorted(set_codelines):
@@ -96,33 +167,52 @@ class CommentChecker:
                 string_previoustext = self.list_sourcelines[int_lineno - 2].strip()
                 # Treat a preceding comment line as satisfying the requirement.
                 if string_previoustext.startswith("#"):
+                    # Mark this line as having a valid preceding comment.
                     bool_hascomment = True
-            # Report a violation if no comment was found for a keyword line.
+            # Report a violation if no comment was found for this code line.
             if not bool_hascomment:
-                # Extract the first word of the line to check against required keywords.
+                # Extract the first word to check against exempt structural keywords.
                 list_words = string_linetext.split()
                 # Default to empty string if the line has no words.
                 string_firstword = list_words[0] if list_words else ""
-                # Strip trailing colon from keywords like "if:" or "else:".
-                string_keyword = string_firstword.rstrip(":")
-                # Check if this line's keyword requires a comment.
-                if string_keyword in keywords_requirecomment:
-                    # Record a missing-comment violation for this keyword line.
-                    self.list_violations.append(Violation(
-                        string_filepath=self.string_filepath,
-                        int_linenumber=int_lineno,
-                        string_category="comment",
-                        string_message=(
-                            f"Line {int_lineno} with keyword '{string_keyword}' "
-                            f"lacks a required preceding comment."
-                        ),
-                        string_sourceline=self.list_sourcelines[int_lineno - 1],
-                    ))
+                # Handle "async def" as a two-word function definition starter.
+                if string_firstword == "async" and len(list_words) >= 2:
+                    # Extract the actual keyword following the async modifier.
+                    string_firstword = list_words[1]
+                # Skip import, class, and function definition lines.
+                if string_firstword in keywords_exemptfromcomment:
+                    # Proceed to the next line without reporting a violation.
+                    continue
+                # Record a missing-comment violation for this physical code line.
+                self.list_violations.append(Violation(
+                    # Supply the file path where the violation was detected.
+                    string_filepath=self.string_filepath,
+                    # Supply the line number of the uncommented code line.
+                    int_linenumber=int_lineno,
+                    # Supply the comment violation category identifier.
+                    string_category="comment",
+                    # Build the violation message with the line number.
+                    string_message=(
+                        # Format the line number into the missing-comment message.
+                        f"Line {int_lineno} lacks a required preceding comment."
+                    # Close the parenthesized message string.
+                    ),
+                    # Supply the source line for contextual display.
+                    string_sourceline=self.list_sourcelines[int_lineno - 1],
+                # Close the Violation data class instantiation.
+                ))
 
     def _init_comment_format_function_(self) -> None:
-        """Verify that every comment follows the 'Capitalized sentence.' format."""
+        """
+        Verify that every comment follows the 'Capitalized sentence.' format.
+
+        Tokenizes the source and inspects each comment token for compliance with the
+        CLASP 3.0 comment format: the comment must start with '# ' (hash and space),
+        the text must begin with a capital letter, and it must end with a period.
+        """
         # Attempt to tokenize the source; skip if tokenization fails.
         try:
+            # Tokenize the full source code for comment format checking.
             list_tokens = _tokenize_source(self.string_source)
         # Return early if the source cannot be tokenized.
         except tokenize.TokenError:
@@ -140,14 +230,23 @@ class CommentChecker:
             if not string_comment.startswith("# "):
                 # Record a violation for missing space after hash.
                 self.list_violations.append(Violation(
+                    # Supply the file path where the malformed comment was detected.
                     string_filepath=self.string_filepath,
+                    # Supply the line number of the malformed comment.
                     int_linenumber=token_item.start[0],
+                    # Supply the comment violation category identifier.
                     string_category="comment",
+                    # Build the violation message describing the format issue.
                     string_message=(
+                        # Describe the required comment format.
                         f"Comment must start with '# ' (hash, space). "
+                        # Show the first 20 characters of the malformed comment.
                         f"Found: '{string_comment[:20]}...'"
+                    # Close the parenthesized message string.
                     ),
+                    # Supply the source line for contextual display.
                     string_sourceline=self.list_sourcelines[token_item.start[0] - 1],
+                # Close the Violation data class instantiation.
                 ))
                 # Skip further checks on malformed comments.
                 continue
@@ -165,14 +264,23 @@ class CommentChecker:
             if string_content[0].islower():
                 # Record a violation for lowercase start.
                 self.list_violations.append(Violation(
+                    # Supply the file path where the malformed comment was detected.
                     string_filepath=self.string_filepath,
+                    # Supply the line number of the malformed comment.
                     int_linenumber=token_item.start[0],
+                    # Supply the comment violation category identifier.
                     string_category="comment",
+                    # Build the violation message describing the format issue.
                     string_message=(
+                        # Describe the required capitalization rule.
                         f"Comment text must start with a capital letter. "
+                        # Show the first 30 characters of the malformed content.
                         f"Found: '{string_content[:30]}...'"
+                    # Close the parenthesized message string.
                     ),
+                    # Supply the source line for contextual display.
                     string_sourceline=self.list_sourcelines[token_item.start[0] - 1],
+                # Close the Violation data class instantiation.
                 ))
             # Check that the comment text ends with a period or other valid punctuation.
             if not string_content.endswith("."):
@@ -180,20 +288,41 @@ class CommentChecker:
                 if not any(string_content.endswith(p) for p in (".", "!", "?", ":", ";", ")")):
                     # Record a violation for missing terminal period.
                     self.list_violations.append(Violation(
+                        # Supply the file path where the malformed comment was detected.
                         string_filepath=self.string_filepath,
+                        # Supply the line number of the malformed comment.
                         int_linenumber=token_item.start[0],
+                        # Supply the comment violation category identifier.
                         string_category="comment",
+                        # Build the violation message describing the format issue.
                         string_message=(
+                            # Describe the required trailing punctuation.
                             f"Comment must end with a period. "
+                            # Show the first 40 characters of the malformed content.
                             f"Found: '{string_content[:40]}'"
+                        # Close the parenthesized message string.
                         ),
+                        # Supply the source line for contextual display.
                         string_sourceline=self.list_sourcelines[token_item.start[0] - 1],
+                    # Close the Violation data class instantiation.
                     ))
 
     def _init_docstring_line_function_(self, int_lineno: int) -> bool:
-        """Determine whether a given line is part of a docstring."""
+        """
+        Determine whether a given line is part of a docstring.
+
+        Parses the source into an AST and walks all nodes to locate docstring expressions.
+        For each function, class, and module node with a docstring, checks whether the
+        queried line number falls within the docstring's start and end line range.
+
+        :param int_lineno: The 1-based line number to check for docstring membership.
+        :type int_lineno: int
+        :return: True if the line is within a docstring expression, False otherwise.
+        :rtype: bool
+        """
         # Attempt to parse the source into an AST; skip if parsing fails.
         try:
+            # Parse the source code to locate docstring nodes.
             tree = ast.parse(self.string_source)
         # Return False if the source has syntax errors.
         except SyntaxError:

CLASPLint-0.2.0/CLASPLint/dict_key_checker.py

@@ -0,0 +1,186 @@
+"""
+THIS FILE IS PART OF CLASPLINT BY MATT BELFAST BROWN
+CLASPLint.dict_key_checker — Validates dictionary key names against CLASP 3.0 PascalCase and abbreviation rules.
+
+Author: Matt Belfast Brown
+Create Date: 2026-06-17
+Version Date: 2026-06-21
+Version: 0.2.0
+
+THIS PROGRAM IS LICENSED UNDER GPL-3.0
+YOU SHOULD HAVE RECEIVED A COPY OF GPL-3.0 LICENSE.
+
+Copyright (C) 2026 Matt Belfast Brown
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, version 3 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+
+import ast
+from typing import List
+
+from .naming_utils import validate_dictkey_format
+from .reporter import Violation
+
+
+class DictKeyChecker(ast.NodeVisitor):
+    """
+    Walks the AST and validates dictionary key names against CLASP 3.0 PascalCase naming rules.
+
+    Public methods:
+        visit_Dict — Checks each key in dictionary literal expressions against PascalCase format.
+        visit_Call — Checks keyword argument names in dict() constructor calls.
+        visit_Subscript — Visits subscript nodes for potential dictionary key access in assignments.
+
+    Private methods:
+        _init_key_function_ — Validates a single string-constant dictionary key against CLASP 3.0 rules.
+        _init_keyword_as_key_function_ — Validates a keyword argument name used as a dictionary key identifier.
+    """
+
+    def __init__(self, string_filepath: str, list_sourcelines: List[str]):
+        """Initialize the dict key checker with file path and source lines for context.
+
+        Stores the provided file path and source lines for later use in violation
+        reporting and contextual display. Also initializes an empty list to collect
+        violations discovered during AST traversal.
+
+        :param string_filepath: Path to the file being checked.
+        :type string_filepath: str
+        :param list_sourcelines: Source lines of the file being checked.
+        :type list_sourcelines: List[str]
+        """
+        # Store the file path for violation reporting.
+        self.string_filepath = string_filepath
+        # Store source lines for contextual violation messages.
+        self.list_sourcelines = list_sourcelines
+        # Collect violations found during AST traversal.
+        self.list_violations: List[Violation] = []
+
+    def _init_key_function_(self, node_key: ast.AST, node_dict: ast.AST) -> None:
+        """Validate a single dictionary key literal.
+
+        Verifies that the key is a string constant before applying CLASP 3.0 dict key
+        format validation. Each detected format violation is appended to the violations
+        list with its source line context.
+
+        :param node_key: The dictionary key AST node to validate.
+        :type node_key: ast.AST
+        :param node_dict: The parent dictionary AST node.
+        :type node_dict: ast.AST
+        """
+        # Only string literal keys are checked; skip non-constant or non-string keys.
+        if not isinstance(node_key, ast.Constant):
+            # Exit early for non-constant dict key nodes.
+            return
+        # Skip keys whose values are not strings.
+        if not isinstance(node_key.value, str):
+            # Exit early for keys whose values are not strings.
+            return
+        # Extract the key string value.
+        string_key = node_key.value
+        # Run the CLASP 3.0 dict key format validation.
+        list_issues = validate_dictkey_format(string_key)
+        # Retrieve the source line for contextual output.
+        string_sourceline = ""
+        # Ensure the line number is within bounds before accessing source lines.
+        if node_key.lineno and node_key.lineno <= len(self.list_sourcelines):
+            # Assign the source line at the detected line number.
+            string_sourceline = self.list_sourcelines[node_key.lineno - 1]
+        # Append each detected violation to the violations list.
+        for string_message in list_issues:
+            # Construct a Violation with full file and line context.
+            self.list_violations.append(Violation(
+                # Supply the file path where the violation was detected.
+                string_filepath=self.string_filepath,
+                # Supply the line number of the offending dictionary key.
+                int_linenumber=node_key.lineno,
+                # Supply the violation category identifier.
+                string_category="dict_key",
+                # Supply the human-readable violation message.
+                string_message=string_message,
+                # Supply the source line for contextual display.
+                string_sourceline=string_sourceline,
+            # Close the Violation data class instantiation.
+            ))
+
+    def visit_Dict(self, node: ast.Dict) -> None:
+        """Check keys in dictionary literal expressions.
+
+        Iterates over every key node in the dictionary literal and delegates
+        non-None keys to the key validation method. Then continues generic
+        visitation of child nodes to handle nested dictionary literals.
+
+        :param node: The dictionary AST node to visit.
+        :type node: ast.Dict
+        """
+        # Iterate over each key node in the dictionary literal.
+        for node_key in node.keys:
+            # Process non-None keys through the key validator.
+            if node_key is not None:
+                # Delegate to the key validation method for this dictionary key.
+                self._init_key_function_(node_key, node)
+        # Continue visiting child nodes for nested dictionaries.
+        self.generic_visit(node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        """Check dict() constructor calls for keyword argument key names.
+
+        Detects calls to the built-in dict() constructor and validates each keyword
+        argument name against CLASP 3.0 dict key naming rules. Non-dict calls are
+        skipped and generic visitation continues for nested structures.
+
+        :param node: The call AST node to visit.
+        :type node: ast.Call
+        """
+        # Detect calls to the built-in dict() constructor.
+        if isinstance(node.func, ast.Name) and node.func.id == "dict":
+            # Check each keyword argument name as a potential dict key.
+            for node_keyword in node.keywords:
+                # Validate the keyword argument if it has an explicit name.
+                if node_keyword.arg:
+                    # Delegate to the keyword-as-key validation method.
+                    self._init_keyword_as_key_function_(node_keyword)
+        # Continue visiting child nodes.
+        self.generic_visit(node)
+
+    def _init_keyword_as_key_function_(self, node_keyword: ast.keyword) -> None:
+        """Validate a keyword argument name used as a dictionary key.
+
+        Extracts the keyword argument name from the AST node and validates it against
+        CLASP 3.0 rules. Currently only flags empty keyword names, as Python keyword
+        arguments are identifiers and cannot directly use PascalCase.
+
+        :param node_keyword: The keyword AST node to validate.
+        :type node_keyword: ast.keyword
+        """
+        # Extract the keyword argument name.
+        string_key = node_keyword.arg
+        # Skip empty or missing keyword argument names.
+        if not string_key:
+            # Exit early for empty keyword argument names.
+            return
+        # Python keyword arguments are identifiers and cannot use PascalCase directly;
+        # Only flag if the name clearly violates PascalCase convention expectations.
+        pass
+
+    def visit_Subscript(self, node: ast.Subscript) -> None:
+        """Visit subscript nodes for potential dict key access within Assign statements.
+
+        Subscript key checks are handled during Assign target walking rather than at
+        the individual subscript node level. This method simply continues generic
+        visitation of child nodes for completeness.
+
+        :param node: The subscript AST node to visit.
+        :type node: ast.Subscript
+        """
+        # Subscript key checks are handled during Assign target walking.
+        self.generic_visit(node)