sel2pw-scan 0.1.0__tar.gz

sel2pw_scan-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shan Konduru
+
+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.

sel2pw_scan-0.1.0/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: sel2pw-scan
+Version: 0.1.0
+Summary: Offline inventory of Selenium Java test projects for a Playwright migration assessment
+Author: Shan Konduru
+License-Expression: MIT
+Project-URL: Repository, https://github.com/ShanKonduru/sel2pw-scan
+Project-URL: Issues, https://github.com/ShanKonduru/sel2pw-scan/issues
+Project-URL: Changelog, https://github.com/ShanKonduru/sel2pw-scan/blob/main/CHANGELOG.md
+Keywords: selenium,playwright,migration,assessment,inventory,test-automation,java
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# sel2pw-scan
+
+Offline inventory of a Selenium Java test project, for assessing a migration to Python Playwright.
+
+`sel2pw-scan` reads your `.java` files and build files and writes a report: which test framework you use,
+how many tests, page objects and helper classes you have, and how often your code uses Selenium features
+that need deliberate work in a migration (fixed sleeps, frames, alerts, JavaScript calls, data providers and
+so on).
+
+It is a scanner only. It does not convert or change any code, uses no AI model and makes no network calls.
+
+## Install
+
+Requires Python 3.10 or newer.
+
+```bash
+pip install sel2pw-scan
+```
+
+## Use
+
+```bash
+sel2pw-scan path/to/selenium-project --out inventory.md
+```
+
+| Option | Effect |
+|---|---|
+| `--out FILE` | Write the report to a file instead of printing it |
+| `--format md` | Default. Summary report, described below |
+| `--format json` | Full detail for tooling, including locator values and annotation attributes |
+| `--version` | Print the version |
+
+`python -m sel2pw_scan ...` works the same way.
+
+## What the report contains
+
+The Markdown report (`--format md`) lists:
+
+- the scanned folder path, detected frameworks (TestNG, JUnit 4, JUnit 5), Selenium version and build files
+- counts of Java files, test classes, page objects, base and utility classes, and test methods (including disabled ones)
+- how often each of 27 Selenium constructs appears, such as `fixed_sleep`, `frames`, `alerts`,
+  `javascript_execution`, `data_provider` and `selenium_grid`
+- every test method as `ClassName#method`, with its file, line, assertion count and constructs
+- every class with its role, parent class and the project classes it depends on
+
+It does **not** contain test code, locator values, string literals or test data. Read it before sharing, and
+rename anything you consider sensitive, such as class names.
+
+The JSON report (`--format json`) adds locator values and annotation attributes, so treat it as internal.
+
+## Limits
+
+The scan uses pattern matching, not a full Java parser, so counts can be slightly off for unusual code.
+It finds tests by annotations such as `@Test`; Cucumber `.feature` files and Kotlin or Groovy sources are not read.
+
+## License
+
+[MIT](LICENSE)

sel2pw_scan-0.1.0/README.md

@@ -0,0 +1,58 @@
+# sel2pw-scan
+
+Offline inventory of a Selenium Java test project, for assessing a migration to Python Playwright.
+
+`sel2pw-scan` reads your `.java` files and build files and writes a report: which test framework you use,
+how many tests, page objects and helper classes you have, and how often your code uses Selenium features
+that need deliberate work in a migration (fixed sleeps, frames, alerts, JavaScript calls, data providers and
+so on).
+
+It is a scanner only. It does not convert or change any code, uses no AI model and makes no network calls.
+
+## Install
+
+Requires Python 3.10 or newer.
+
+```bash
+pip install sel2pw-scan
+```
+
+## Use
+
+```bash
+sel2pw-scan path/to/selenium-project --out inventory.md
+```
+
+| Option | Effect |
+|---|---|
+| `--out FILE` | Write the report to a file instead of printing it |
+| `--format md` | Default. Summary report, described below |
+| `--format json` | Full detail for tooling, including locator values and annotation attributes |
+| `--version` | Print the version |
+
+`python -m sel2pw_scan ...` works the same way.
+
+## What the report contains
+
+The Markdown report (`--format md`) lists:
+
+- the scanned folder path, detected frameworks (TestNG, JUnit 4, JUnit 5), Selenium version and build files
+- counts of Java files, test classes, page objects, base and utility classes, and test methods (including disabled ones)
+- how often each of 27 Selenium constructs appears, such as `fixed_sleep`, `frames`, `alerts`,
+  `javascript_execution`, `data_provider` and `selenium_grid`
+- every test method as `ClassName#method`, with its file, line, assertion count and constructs
+- every class with its role, parent class and the project classes it depends on
+
+It does **not** contain test code, locator values, string literals or test data. Read it before sharing, and
+rename anything you consider sensitive, such as class names.
+
+The JSON report (`--format json`) adds locator values and annotation attributes, so treat it as internal.
+
+## Limits
+
+The scan uses pattern matching, not a full Java parser, so counts can be slightly off for unusual code.
+It finds tests by annotations such as `@Test`; Cucumber `.feature` files and Kotlin or Groovy sources are not read.
+
+## License
+
+[MIT](LICENSE)

sel2pw_scan-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sel2pw-scan"
+version = "0.1.0"
+description = "Offline inventory of Selenium Java test projects for a Playwright migration assessment"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Shan Konduru" }]
+keywords = ["selenium", "playwright", "migration", "assessment", "inventory", "test-automation", "java"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[project.urls]
+Repository = "https://github.com/ShanKonduru/sel2pw-scan"
+Issues = "https://github.com/ShanKonduru/sel2pw-scan/issues"
+Changelog = "https://github.com/ShanKonduru/sel2pw-scan/blob/main/CHANGELOG.md"
+
+[project.scripts]
+sel2pw-scan = "sel2pw_scan.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+norecursedirs = ["fixtures"]

sel2pw_scan-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sel2pw_scan-0.1.0/src/sel2pw_scan/__init__.py

@@ -0,0 +1,3 @@
+"""sel2pw-scan: offline inventory of Selenium Java test projects for a Playwright migration assessment."""
+
+__version__ = "0.1.0"

sel2pw_scan-0.1.0/src/sel2pw_scan/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

sel2pw_scan-0.1.0/src/sel2pw_scan/cli.py

@@ -0,0 +1,46 @@
+"""Command line: ``sel2pw-scan SOURCE [--format md|json] [--out FILE]``."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__
+from .inventory import scan_project
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sel2pw-scan",
+        description="Scan a Selenium Java test project and write an inventory report. "
+        "Runs offline: no AI model, no network calls.",
+    )
+    parser.add_argument("--version", action="version", version=f"sel2pw-scan {__version__}")
+    parser.add_argument("source", help="Folder of the Selenium Java project to scan")
+    parser.add_argument("--format", choices=["md", "json"], default="md",
+                        help="md (default): summary report without code or locator values; "
+                        "json: full detail, including locator values")
+    parser.add_argument("--out", help="Write the report to this file instead of printing it")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    source = Path(args.source)
+    if not source.is_dir():
+        print(f"sel2pw-scan: not a folder: {source}", file=sys.stderr)
+        return 2
+    inv = scan_project(source)
+    text = inv.to_json() if args.format == "json" else inv.to_markdown()
+    if args.out:
+        Path(args.out).write_text(text, encoding="utf-8")
+        s = inv.summary()
+        print(f"wrote {args.out} ({s['java_files']} Java files, {s['test_methods']} test methods)")
+    else:
+        sys.stdout.write(text)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sel2pw_scan-0.1.0/src/sel2pw_scan/inventory.py

@@ -0,0 +1,443 @@
+"""Deterministic inventory of a Selenium Java project.
+
+This is a heuristic, regex-based scanner (no Java parser dependency). It gives
+a grounded starting map for a migration assessment: test classes and methods,
+lifecycle hooks, page objects, dependencies between project classes, and
+Selenium constructs that need deliberate translation. Mapping IDs are
+``ClassName#method`` so they stay stable across runs.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+# Directories never scanned (build output, VCS and tool state).
+SKIP_DIRS = {".sel2pw", ".git", ".venv", "venv", "node_modules", "target", "build", ".gradle", ".idea", "__pycache__", ".pytest_cache"}
+
+# Selenium constructs that need deliberate translation when moving to Playwright.
+CONSTRUCT_PATTERNS: dict[str, str] = {
+    "fixed_sleep": r"\bThread\.sleep\s*\(",
+    "explicit_wait": r"\bWebDriverWait\b|\bFluentWait\b",
+    "expected_conditions": r"\bExpectedConditions\.\w+",
+    "custom_expected_condition": r"\bExpectedCondition\s*<|\bnew\s+ExpectedCondition\b",
+    "implicit_wait": r"\bimplicitlyWait\s*\(",
+    "javascript_execution": r"\bJavascriptExecutor\b|\bexecuteScript\s*\(|\bexecuteAsyncScript\s*\(",
+    "frames": r"switchTo\(\)\s*\.\s*(?:frame|parentFrame|defaultContent)\s*\(",
+    "windows_tabs": r"getWindowHandles?\s*\(|switchTo\(\)\s*\.\s*(?:window|newWindow)\s*\(",
+    "alerts": r"switchTo\(\)\s*\.\s*alert\s*\(|\bAlert\b\s+\w+\s*=",
+    "actions_api": r"\bnew\s+Actions\s*\(",
+    "select_dropdown": r"\bnew\s+Select\s*\(",
+    "file_upload_or_download": r"\bLocalFileDetector\b|download\.default_directory|\.sendKeys\([^)]*(?:\.pdf|\.csv|\.xlsx?|\.png|\.jpe?g|\.txt|File\.separator|getAbsolutePath)",
+    "shadow_dom": r"getShadowRoot\s*\(|shadowRoot",
+    "screenshots": r"\bTakesScreenshot\b|getScreenshotAs\s*\(",
+    "cookies": r"manage\(\)\s*\.\s*(?:addCookie|getCookie|deleteCookie|deleteAllCookies)",
+    "browser_capabilities": r"\b(?:Chrome|Firefox|Edge|Safari)Options\b|\bDesiredCapabilities\b|\bMutableCapabilities\b",
+    "selenium_grid": r"\bRemoteWebDriver\b",
+    "page_factory": r"\bPageFactory\b|@FindBy\b|@FindBys\b|@FindAll\b",
+    "data_provider": r"@DataProvider\b|dataProvider\s*=|@ParameterizedTest\b|@(?:Csv|Value|Method|Enum)Source\b",
+    "listeners": r"@Listeners\b|\bITestListener\b|\bTestWatcher\b|@ExtendWith\b|\bWebDriverListener\b|\bEventFiringWebDriver\b",
+    "retries": r"retryAnalyzer\s*=|\bIRetryAnalyzer\b|@RepeatedTest\b|@RetryingTest\b",
+    "parallel_execution": r"parallel\s*=|threadPoolSize\s*=|@Execution\s*\(|\bThreadLocal\s*<\s*WebDriver",
+    "test_dependencies": r"dependsOnMethods\s*=|dependsOnGroups\s*=|@Order\s*\(|priority\s*=",
+    "soft_assertions": r"\bSoftAssert\b|\bassertAll\s*\(|\bSoftAssertions\b",
+    "hover_drag_drop": r"\.moveToElement\s*\(|\.dragAndDrop(?:By)?\s*\(|\.clickAndHold\s*\(",
+    "keyboard_keys": r"\bKeys\.\w+",
+    "stale_element_handling": r"StaleElementReferenceException",
+}
+
+LOCATOR_RE = re.compile(r'By\.(id|name|className|cssSelector|xpath|linkText|partialLinkText|tagName)\s*\(\s*"((?:[^"\\]|\\.)*)"')
+FINDBY_RE = re.compile(r'@FindBy\s*\(\s*(id|name|className|css|xpath|linkText|partialLinkText|tagName|how)\s*=\s*(?:How\.\w+\s*,\s*using\s*=\s*)?"((?:[^"\\]|\\.)*)"')
+PACKAGE_RE = re.compile(r"^\s*package\s+([\w.]+)\s*;", re.M)
+IMPORT_RE = re.compile(r"^\s*import\s+(?:static\s+)?([\w.*]+)\s*;", re.M)
+CLASS_RE = re.compile(r"\b(?:public\s+|abstract\s+|final\s+)*(class|interface|enum)\s+(\w+)(?:\s*<[^>{]*>)?(?:\s+extends\s+([\w.<>, ]+?))?(?:\s+implements\s+([\w.<>, ]+?))?\s*\{")
+METHOD_RE = re.compile(
+    r"(?P<annos>(?:@\w+(?:\.\w+)*(?:\s*\((?:[^()]|\([^()]*\))*\))?\s*)*)"
+    r"(?:(?:public|protected|private|static|final|synchronized|abstract|default)\s+)*"
+    r"(?:<[^>]+>\s+)?(?P<ret>[\w.<>\[\],? ]+?)\s+(?P<name>\w+)\s*\((?P<params>[^()]*(?:\([^()]*\)[^()]*)*)\)\s*"
+    r"(?:throws\s+[\w.,\s]+)?\{"
+)
+ANNOTATION_RE = re.compile(r"@(\w+(?:\.\w+)*)(?:\s*\(((?:[^()]|\([^()]*\))*)\))?")
+
+TEST_ANNOTATIONS = {"Test", "ParameterizedTest", "RepeatedTest", "TestFactory", "TestTemplate", "RetryingTest"}
+LIFECYCLE_ANNOTATIONS = {
+    "Before", "After", "BeforeClass", "AfterClass",  # JUnit 4
+    "BeforeEach", "AfterEach", "BeforeAll", "AfterAll",  # JUnit 5
+    "BeforeMethod", "AfterMethod", "BeforeTest", "AfterTest", "BeforeSuite", "AfterSuite", "BeforeGroups", "AfterGroups",  # TestNG
+}
+DISABLED_ANNOTATIONS = {"Ignore", "Disabled"}
+KEYWORDS = {"if", "for", "while", "switch", "catch", "synchronized", "return", "new", "else", "try", "do"}
+
+
+@dataclass
+class JavaMethod:
+    id: str
+    name: str
+    kind: str  # test | lifecycle | helper
+    line: int
+    annotations: list[str]
+    attributes: dict[str, str]
+    disabled: bool
+    constructs: list[str]
+    assertion_count: int
+    data_rows: int | None = None  # data provider rows / parameterized cases, when statically countable
+
+
+@dataclass
+class JavaClass:
+    name: str
+    file: str
+    package: str
+    role: str  # test | page_object | base_or_util | other
+    extends: str | None
+    framework: str | None
+    methods: list[JavaMethod] = field(default_factory=list)
+    constructs: dict[str, int] = field(default_factory=dict)
+    locators: list[dict[str, str]] = field(default_factory=list)
+    depends_on: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Inventory:
+    root: str
+    java_files: int
+    frameworks: list[str]
+    selenium_version_hint: str | None
+    build_files: list[str]
+    classes: list[JavaClass]
+    construct_totals: dict[str, int]
+
+    @property
+    def tests(self) -> list[tuple[JavaClass, JavaMethod]]:
+        return [(c, m) for c in self.classes for m in c.methods if m.kind == "test"]
+
+    def to_dict(self) -> dict:
+        data = asdict(self)
+        data["summary"] = self.summary()
+        return data
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=2)
+
+    def summary(self) -> dict[str, int]:
+        roles: dict[str, int] = {}
+        for c in self.classes:
+            roles[c.role] = roles.get(c.role, 0) + 1
+        tests = self.tests
+        return {
+            "java_files": self.java_files,
+            "test_classes": roles.get("test", 0),
+            "page_objects": roles.get("page_object", 0),
+            "base_or_util_classes": roles.get("base_or_util", 0),
+            "test_methods": len(tests),
+            "disabled_test_methods": sum(1 for _, m in tests if m.disabled),
+        }
+
+    def to_markdown(self) -> str:
+        s = self.summary()
+        out = [
+            "# Selenium source inventory",
+            "",
+            f"- Root: `{self.root}`",
+            f"- Frameworks detected: {', '.join(self.frameworks) or 'unknown'}",
+            f"- Selenium version hint: {self.selenium_version_hint or 'not found in build files'}",
+            f"- Build files: {', '.join(self.build_files) or 'none'}",
+            f"- Java files: {s['java_files']} | test classes: {s['test_classes']} | page objects: {s['page_objects']} "
+            f"| base/util: {s['base_or_util_classes']} | test methods: {s['test_methods']} (disabled: {s['disabled_test_methods']})",
+            "",
+            "> Heuristic scan. Confirm against the source before relying on counts.",
+            "",
+        ]
+        if self.construct_totals:
+            out += ["## Constructs needing deliberate translation", "", "| Construct | Occurrences |", "|---|---|"]
+            out += [f"| {k} | {v} |" for k, v in sorted(self.construct_totals.items(), key=lambda kv: -kv[1])]
+            out.append("")
+        out += ["## Tests", "", "| ID | File | Line | Disabled | Assertions | Constructs |", "|---|---|---|---|---|---|"]
+        for cls, m in self.tests:
+            out.append(
+                f"| `{m.id}` | {cls.file} | {m.line} | {'yes' if m.disabled else ''} | {m.assertion_count} | {', '.join(m.constructs)} |"
+            )
+        out += ["", "## Classes", "", "| Class | Role | File | Extends | Depends on |", "|---|---|---|---|---|"]
+        for c in self.classes:
+            out.append(f"| {c.name} | {c.role} | {c.file} | {c.extends or ''} | {', '.join(c.depends_on)} |")
+        return "\n".join(out) + "\n"
+
+
+# -- parsing helpers ---------------------------------------------------------
+
+def mask_java(text: str) -> str:
+    """Blank out comments and string/char literal contents, keeping offsets."""
+    out = list(text)
+    i, n = 0, len(text)
+    while i < n:
+        c = text[i]
+        nxt = text[i + 1] if i + 1 < n else ""
+        if c == "/" and nxt == "/":
+            j = text.find("\n", i)
+            j = n if j == -1 else j
+            for k in range(i, j):
+                out[k] = " "
+            i = j
+        elif c == "/" and nxt == "*":
+            j = text.find("*/", i + 2)
+            j = n if j == -1 else j + 2
+            for k in range(i, j):
+                if out[k] != "\n":
+                    out[k] = " "
+            i = j
+        elif c == '"' and text.startswith('"""', i):
+            j = text.find('"""', i + 3)
+            j = n if j == -1 else j + 3
+            for k in range(i + 3, max(j - 3, i + 3)):
+                if out[k] != "\n":
+                    out[k] = " "
+            i = j
+        elif c in "\"'":
+            j = i + 1
+            while j < n and text[j] != c and text[j] != "\n":
+                j += 2 if text[j] == "\\" else 1
+            for k in range(i + 1, min(j, n)):
+                out[k] = " "
+            i = j + 1
+        else:
+            i += 1
+    return "".join(out)
+
+
+def _match_brace(masked: str, open_idx: int) -> int:
+    depth = 0
+    for i in range(open_idx, len(masked)):
+        if masked[i] == "{":
+            depth += 1
+        elif masked[i] == "}":
+            depth -= 1
+            if depth == 0:
+                return i
+    return len(masked) - 1
+
+
+_IMPORT_LINE_RE = re.compile(r"^\s*(?:import|package)\s.*$", re.M)
+
+
+def _constructs(text: str) -> dict[str, int]:
+    text = _IMPORT_LINE_RE.sub("", text)
+    found = {}
+    for name, pattern in CONSTRUCT_PATTERNS.items():
+        count = len(re.findall(pattern, text))
+        if count:
+            found[name] = count
+    return found
+
+
+def _detect_framework(imports: list[str]) -> str | None:
+    joined = " ".join(imports)
+    if "org.testng" in joined:
+        return "testng"
+    if "org.junit.jupiter" in joined:
+        return "junit5"
+    if "org.junit" in joined:
+        return "junit4"
+    return None
+
+
+def _parse_annotations(block: str) -> tuple[list[str], dict[str, str]]:
+    names, attrs = [], {}
+    for m in ANNOTATION_RE.finditer(block):
+        name = m.group(1).split(".")[-1]
+        names.append(name)
+        if m.group(2):
+            for key, val in re.findall(r"(\w+)\s*=\s*(\"[^\"]*\"|\{[^}]*\}|[\w.]+)", m.group(2)):
+                attrs[f"{name}.{key}"] = val.strip('"')
+            if "=" not in m.group(2) and m.group(2).strip():
+                attrs[f"{name}.value"] = m.group(2).strip().strip('"')
+    return names, attrs
+
+
+def _object_array_rows(masked_body: str) -> int | None:
+    """Rows in a ``new Object[][] { {...}, {...} }`` literal (TestNG data providers)."""
+    m = re.search(r"new\s+Object\s*\[\s*\]\s*\[\s*\]\s*\{", masked_body)
+    if not m:
+        return None
+    depth = rows = 0
+    for ch in masked_body[m.end() - 1:]:
+        if ch == "{":
+            depth += 1
+            if depth == 2:
+                rows += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0:
+                return rows
+    return None
+
+
+def _junit_param_rows(attrs: dict[str, str]) -> int | None:
+    for key in ("CsvSource.value", "ValueSource.strings", "ValueSource.ints", "ValueSource.longs", "ValueSource.doubles"):
+        if key in attrs:
+            value = attrs[key].strip()
+            quoted = re.findall(r'"(?:[^"\\]|\\.)*"', value)
+            if quoted:
+                return len(quoted)
+            inner = value.strip("{}").strip()
+            return len([v for v in inner.split(",") if v.strip()]) if inner else 0
+    return None
+
+
+def _link_data_providers(methods: list[JavaMethod]) -> None:
+    providers = {}
+    for m in methods:
+        if "DataProvider" in m.annotations:
+            providers[m.attributes.get("DataProvider.name", m.name)] = m
+    for m in methods:
+        if m.kind != "test":
+            continue
+        name = m.attributes.get("Test.dataProvider")
+        if name and "Test.dataProviderClass" not in m.attributes and name in providers:
+            m.data_rows = providers[name].data_rows
+        elif m.data_rows is None:
+            m.data_rows = _junit_param_rows(m.attributes)
+
+
+def _classify(cls_name: str, rel: str, methods: list[JavaMethod], body: str, extends: str | None) -> str:
+    if any(m.kind == "test" for m in methods):
+        return "test"
+    lower = cls_name.lower()
+    if "@FindBy" in body or lower.endswith(("page", "pageobject", "screen", "component", "section")) or "/pages/" in rel.lower():
+        return "page_object"
+    if lower.startswith("base") or lower.endswith(("base", "util", "utils", "helper", "helpers", "factory", "manager", "config", "listener", "driver")):
+        return "base_or_util"
+    if any(m.kind == "lifecycle" for m in methods):
+        return "base_or_util"
+    return "other"
+
+
+def _scan_file(path: Path, rel: str) -> list[JavaClass]:
+    text = path.read_text(encoding="utf-8", errors="replace")
+    masked = mask_java(text)
+    package = (PACKAGE_RE.search(text) or [None, ""])[1]
+    imports = IMPORT_RE.findall(masked)
+    framework = _detect_framework(imports)
+    classes: list[JavaClass] = []
+
+    for cm in CLASS_RE.finditer(masked):
+        cls_name = cm.group(2)
+        open_idx = cm.end() - 1
+        close_idx = _match_brace(masked, open_idx)
+        body_masked = masked[open_idx:close_idx + 1]
+        body_text = text[open_idx:close_idx + 1]
+        # class-level annotations (e.g. @Listeners) sit just before the declaration
+        prefix_start = masked.rfind(";", 0, cm.start()) + 1
+        class_annos, class_attrs = _parse_annotations(masked[prefix_start:cm.start()])
+
+        methods: list[JavaMethod] = []
+        for mm in METHOD_RE.finditer(body_masked):
+            name = mm.group("name")
+            if name in KEYWORDS or name == cls_name:
+                continue
+            # only direct members: brace depth 1 relative to the class body
+            if body_masked[:mm.start()].count("{") - body_masked[:mm.start()].count("}") != 1:
+                continue
+            m_open = mm.end() - 1
+            m_close = _match_brace(body_masked, m_open)
+            # Include the annotation block so e.g. dataProvider= / retryAnalyzer= count for the method.
+            m_body = body_text[mm.start():m_close + 1]
+            # Annotation args are blanked in the masked text; read them from the original.
+            annos, attrs = _parse_annotations(body_text[mm.start():mm.start() + len(mm.group("annos") or "")])
+            if set(annos) & TEST_ANNOTATIONS:
+                kind = "test"
+            elif set(annos) & LIFECYCLE_ANNOTATIONS:
+                kind = "lifecycle"
+            else:
+                kind = "helper"
+            disabled = bool(set(annos) & DISABLED_ANNOTATIONS) or attrs.get("Test.enabled") == "false"
+            line = text.count("\n", 0, open_idx + mm.start("name")) + 1
+            methods.append(JavaMethod(
+                id=f"{cls_name}#{name}",
+                name=name,
+                kind=kind,
+                line=line,
+                annotations=annos,
+                attributes=attrs,
+                disabled=disabled,
+                constructs=sorted(_constructs(m_body)),
+                assertion_count=len(re.findall(r"\b(?:assert\w*|verify\w*|softly\.assert\w*|expect\w*)\s*\(", m_body)),
+                data_rows=_object_array_rows(body_masked[mm.start():m_close + 1]) if "DataProvider" in annos else None,
+            ))
+        _link_data_providers(methods)
+
+        if class_annos:
+            for m in methods:
+                if m.kind == "test" and ("Ignore" in class_annos or "Disabled" in class_annos):
+                    m.disabled = True
+        extends = cm.group(3).strip() if cm.group(3) else None
+        locators = [{"strategy": s, "value": v} for s, v in LOCATOR_RE.findall(body_text)]
+        locators += [{"strategy": f"@FindBy.{s}", "value": v} for s, v in FINDBY_RE.findall(body_text)]
+        constructs = _constructs(body_text)
+        if class_annos:
+            constructs.update({k: v for k, v in _constructs(text[prefix_start:cm.start()]).items() if k not in constructs})
+        classes.append(JavaClass(
+            name=cls_name,
+            file=rel,
+            package=package,
+            role=_classify(cls_name, rel, methods, body_text, extends),
+            extends=extends,
+            framework=framework,
+            methods=methods,
+            constructs=constructs,
+            locators=locators,
+        ))
+        # Nested classes are found by the outer finditer too; that is fine for inventory purposes.
+    return classes
+
+
+def _build_hints(root: Path) -> tuple[list[str], str | None]:
+    files, version = [], None
+    for name in ("pom.xml", "build.gradle", "build.gradle.kts", "testng.xml"):
+        for path in root.rglob(name):
+            if any(p in SKIP_DIRS for p in path.relative_to(root).parts[:-1]):
+                continue
+            files.append(path.relative_to(root).as_posix())
+            text = path.read_text(encoding="utf-8", errors="replace")
+            m = re.search(r"selenium-java</artifactId>\s*<version>([^<]+)</version>", text) or re.search(
+                r"selenium-java:([\w.\-${}]+)", text
+            ) or re.search(r"<selenium\.version>([^<]+)</selenium\.version>", text)
+            if m and not version:
+                version = m.group(1)
+    return sorted(files), version
+
+
+def scan_project(root: str | Path) -> Inventory:
+    root = Path(root).resolve()
+    java_files = [
+        p for p in sorted(root.rglob("*.java"))
+        if not any(part in SKIP_DIRS for part in p.relative_to(root).parts[:-1])
+    ]
+    classes: list[JavaClass] = []
+    for path in java_files:
+        classes.extend(_scan_file(path, path.relative_to(root).as_posix()))
+
+    names = {c.name for c in classes}
+    for c in classes:
+        text = (root / c.file).read_text(encoding="utf-8", errors="replace")
+        masked = mask_java(text)
+        deps = {n for n in names if n != c.name and re.search(rf"\b{re.escape(n)}\b", masked)}
+        c.depends_on = sorted(deps)
+
+    # Per-file totals so nested classes are not counted twice.
+    totals: dict[str, int] = {}
+    for path in java_files:
+        for k, v in _constructs(path.read_text(encoding="utf-8", errors="replace")).items():
+            totals[k] = totals.get(k, 0) + v
+    frameworks = sorted({c.framework for c in classes if c.framework})
+    build_files, version = _build_hints(root)
+    return Inventory(
+        root=str(root),
+        java_files=len(java_files),
+        frameworks=frameworks,
+        selenium_version_hint=version,
+        build_files=build_files,
+        classes=classes,
+        construct_totals=totals,
+    )

sel2pw_scan-0.1.0/src/sel2pw_scan.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: sel2pw-scan
+Version: 0.1.0
+Summary: Offline inventory of Selenium Java test projects for a Playwright migration assessment
+Author: Shan Konduru
+License-Expression: MIT
+Project-URL: Repository, https://github.com/ShanKonduru/sel2pw-scan
+Project-URL: Issues, https://github.com/ShanKonduru/sel2pw-scan/issues
+Project-URL: Changelog, https://github.com/ShanKonduru/sel2pw-scan/blob/main/CHANGELOG.md
+Keywords: selenium,playwright,migration,assessment,inventory,test-automation,java
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# sel2pw-scan
+
+Offline inventory of a Selenium Java test project, for assessing a migration to Python Playwright.
+
+`sel2pw-scan` reads your `.java` files and build files and writes a report: which test framework you use,
+how many tests, page objects and helper classes you have, and how often your code uses Selenium features
+that need deliberate work in a migration (fixed sleeps, frames, alerts, JavaScript calls, data providers and
+so on).
+
+It is a scanner only. It does not convert or change any code, uses no AI model and makes no network calls.
+
+## Install
+
+Requires Python 3.10 or newer.
+
+```bash
+pip install sel2pw-scan
+```
+
+## Use
+
+```bash
+sel2pw-scan path/to/selenium-project --out inventory.md
+```
+
+| Option | Effect |
+|---|---|
+| `--out FILE` | Write the report to a file instead of printing it |
+| `--format md` | Default. Summary report, described below |
+| `--format json` | Full detail for tooling, including locator values and annotation attributes |
+| `--version` | Print the version |
+
+`python -m sel2pw_scan ...` works the same way.
+
+## What the report contains
+
+The Markdown report (`--format md`) lists:
+
+- the scanned folder path, detected frameworks (TestNG, JUnit 4, JUnit 5), Selenium version and build files
+- counts of Java files, test classes, page objects, base and utility classes, and test methods (including disabled ones)
+- how often each of 27 Selenium constructs appears, such as `fixed_sleep`, `frames`, `alerts`,
+  `javascript_execution`, `data_provider` and `selenium_grid`
+- every test method as `ClassName#method`, with its file, line, assertion count and constructs
+- every class with its role, parent class and the project classes it depends on
+
+It does **not** contain test code, locator values, string literals or test data. Read it before sharing, and
+rename anything you consider sensitive, such as class names.
+
+The JSON report (`--format json`) adds locator values and annotation attributes, so treat it as internal.
+
+## Limits
+
+The scan uses pattern matching, not a full Java parser, so counts can be slightly off for unusual code.
+It finds tests by annotations such as `@Test`; Cucumber `.feature` files and Kotlin or Groovy sources are not read.
+
+## License
+
+[MIT](LICENSE)

sel2pw_scan-0.1.0/src/sel2pw_scan.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/sel2pw_scan/__init__.py
+src/sel2pw_scan/__main__.py
+src/sel2pw_scan/cli.py
+src/sel2pw_scan/inventory.py
+src/sel2pw_scan.egg-info/PKG-INFO
+src/sel2pw_scan.egg-info/SOURCES.txt
+src/sel2pw_scan.egg-info/dependency_links.txt
+src/sel2pw_scan.egg-info/entry_points.txt
+src/sel2pw_scan.egg-info/requires.txt
+src/sel2pw_scan.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_inventory.py

sel2pw_scan-0.1.0/src/sel2pw_scan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sel2pw_scan-0.1.0/src/sel2pw_scan.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sel2pw-scan = sel2pw_scan.cli:main

sel2pw_scan-0.1.0/src/sel2pw_scan.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=8

sel2pw_scan-0.1.0/src/sel2pw_scan.egg-info/top_level.txt

@@ -0,0 +1 @@
+sel2pw_scan

sel2pw_scan-0.1.0/tests/test_cli.py

@@ -0,0 +1,33 @@
+import json
+import subprocess
+import sys
+
+from sel2pw_scan import __version__
+from sel2pw_scan.cli import main
+
+
+def test_markdown_report_to_file(java_src, tmp_path, capsys):
+    out = tmp_path / "inventory.md"
+    assert main([str(java_src), "--out", str(out)]) == 0
+    assert "3 Java files, 3 test methods" in capsys.readouterr().out
+    md = out.read_text(encoding="utf-8")
+    assert md.startswith("# Selenium source inventory")
+    # The markdown report is the shareable one: no locator values.
+    assert "//button[text()='Sign in']" not in md
+
+
+def test_json_report_to_stdout(java_src, capsys):
+    assert main([str(java_src), "--format", "json"]) == 0
+    data = json.loads(capsys.readouterr().out)
+    assert data["summary"]["test_methods"] == 3
+
+
+def test_missing_folder_is_an_error(tmp_path, capsys):
+    assert main([str(tmp_path / "nope")]) == 2
+    assert "not a folder" in capsys.readouterr().err
+
+
+def test_module_entry_point_and_version():
+    proc = subprocess.run([sys.executable, "-m", "sel2pw_scan", "--version"], capture_output=True, text=True)
+    assert proc.returncode == 0
+    assert proc.stdout.strip() == f"sel2pw-scan {__version__}"

sel2pw_scan-0.1.0/tests/test_inventory.py

@@ -0,0 +1,60 @@
+import json
+
+from sel2pw_scan.inventory import mask_java, scan_project
+
+
+def test_scan_finds_tests_lifecycle_and_roles(java_src):
+    inv = scan_project(java_src)
+    s = inv.summary()
+    assert s["java_files"] == 3
+    assert s["test_classes"] == 1 and s["page_objects"] == 1 and s["base_or_util_classes"] == 1
+    assert [m.id for _, m in inv.tests] == [
+        "LoginTest#validLoginShowsDashboard",
+        "LoginTest#invalidLoginShowsError",
+        "LoginTest#logoutConfirmsWithAlert",
+    ]
+    assert inv.frameworks == ["testng"]
+    assert inv.selenium_version_hint == "4.21.0"
+
+    base = next(c for c in inv.classes if c.name == "BaseTest")
+    assert {m.name: m.kind for m in base.methods} == {"setUp": "lifecycle", "tearDown": "lifecycle"}
+    assert base.methods[1].attributes == {"AfterMethod.alwaysRun": "true"}
+
+
+def test_method_details(java_src):
+    inv = scan_project(java_src)
+    tests = {m.name: m for _, m in inv.tests}
+    assert tests["logoutConfirmsWithAlert"].disabled is True
+    assert "alerts" in tests["logoutConfirmsWithAlert"].constructs
+    assert tests["invalidLoginShowsError"].attributes["Test.dataProvider"] == "badCredentials"
+    assert "data_provider" in tests["invalidLoginShowsError"].constructs
+    assert tests["validLoginShowsDashboard"].assertion_count == 2
+    assert "fixed_sleep" in tests["validLoginShowsDashboard"].constructs
+
+
+def test_dependencies_and_locators(java_src):
+    inv = scan_project(java_src)
+    login_test = next(c for c in inv.classes if c.name == "LoginTest")
+    assert login_test.depends_on == ["BaseTest", "LoginPage"]
+    assert login_test.extends == "BaseTest"
+    page = next(c for c in inv.classes if c.name == "LoginPage")
+    values = {(l["strategy"], l["value"]) for l in page.locators}
+    assert ("xpath", "//button[text()='Sign in']") in values
+    assert ("@FindBy.css", "input[name='password']") in values
+    assert "frames" in page.constructs and "explicit_wait" in page.constructs
+
+
+def test_json_and_markdown_render(java_src):
+    inv = scan_project(java_src)
+    data = json.loads(inv.to_json())
+    assert data["summary"]["test_methods"] == 3
+    md = inv.to_markdown()
+    assert "`LoginTest#invalidLoginShowsError`" in md
+
+
+def test_mask_keeps_offsets_and_hides_strings_and_comments():
+    src = 'String s = "@Test {"; // @Test {\n/* @Test */ int x;'
+    masked = mask_java(src)
+    assert len(masked) == len(src)
+    assert "@Test" not in masked and "{" not in masked
+    assert masked.count("\n") == 1