gyomu-python-analysis 0.3.0__tar.gz → 0.5.0__tar.gz

gyomu_python_analysis-0.5.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.5
+Name: gyomu-python-analysis
+Version: 0.5.0
+Summary: Gyomu Python Analysis
+Author: Yoshihisa Matsumoto
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.13
+Requires-Dist: docstring-parser>=0.18.0
+Requires-Dist: griffelib>=2.2.0
+Requires-Dist: gyomu-infra
+Requires-Dist: gyomu-schema
+Requires-Dist: pydantic
+Requires-Dist: returns
+Description-Content-Type: text/markdown
+
+# gyomu-python-analysis
+
+python analysis components for Gyomu Python.

{gyomu_python_analysis-0.3.0 → gyomu_python_analysis-0.5.0}/pyproject.toml

@@ -7,10 +7,24 @@ requires-python = ">=3.13"
 dependencies = [
     "gyomu-schema",
     "gyomu-infra",
+    "pydantic",
     "returns",
     "griffelib>=2.2.0",
     "docstring-parser>=0.18.0",
 ]
+license = "MIT"
+authors = [
+    { name = "Yoshihisa Matsumoto" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
 
 [build-system]
 requires = ["hatchling"]

gyomu_python_analysis-0.5.0/python_analysis_test_support/fixtures/src/analysis/ast/call.py

@@ -0,0 +1,67 @@
+
+
+from typing import Any
+
+
+def combine(*values: Any, **options: Any) -> Any:
+    return values, options
+
+
+def convert(value: int) -> str:
+    return str(value)
+
+
+def create_value(value: int) -> str:
+    return str(value)
+
+
+def build_option(value: int = 0) -> dict[str, int]:
+    return {"value": value}
+
+
+class Service:
+    def execute(self, *args: Any, **kwargs: Any) -> Any:
+        return args, kwargs
+
+
+service = Service()
+
+
+def simple_call(value: int) -> str:
+    return convert(value)
+
+
+def positional_call(value: int) -> Any:
+    return combine(value, convert(value))
+
+
+def keyword_call(value: int) -> Any:
+    return combine(value, prefix="value", suffix="!")
+
+
+def attribute_call(value: int) -> Any:
+    return service.execute(value)
+
+
+def nested_call(value: int) -> Any:
+    return service.execute(
+        create_value(value),
+        option=build_option(value),
+    )
+
+
+def starred_call(values: list[int]) -> Any:
+    return combine(*values)
+
+
+def double_starred_call(options: dict[str, Any]) -> Any:
+    return combine(**options)
+
+
+def complex_call(value: int, values: list[int]) -> Any:
+    return service.execute(
+        convert(value),
+        *values,
+        option=build_option(value),
+        **{"value": value},
+    )

gyomu_python_analysis-0.5.0/python_analysis_test_support/fixtures/src/analysis/ast/comprehension.py

@@ -0,0 +1,40 @@
+def list_comprehension(values: list[int]) -> list[int]:
+    return [value * 2 for value in values]
+
+
+def list_comprehension_with_if(values: list[int]) -> list[int]:
+    return [value * 2 for value in values if value > 0]
+
+
+def list_comprehension_multiple_for(
+    values: list[list[int]],
+) -> list[int]:
+    return [value for items in values for value in items]
+
+
+def set_comprehension(values: list[int]) -> set[int]:
+    return {value * 2 for value in values}
+
+
+def set_comprehension_with_if(values: list[int]) -> set[int]:
+    return {value * 2 for value in values if value > 0}
+
+
+def dict_comprehension(values: list[int]) -> dict[int, int]:
+    return {value: value * 2 for value in values}
+
+
+def dict_comprehension_with_if(values: list[int]) -> dict[int, int]:
+    return {value: value * 2 for value in values if value > 0}
+
+
+def generator_expression(values: list[int]):
+    return (value * 2 for value in values)
+
+
+def generator_expression_with_if(values: list[int]):
+    return (value * 2 for value in values if value > 0)
+
+
+def nested_comprehension(values: list[list[int]]) -> list[int]:
+    return [value * 2 for items in values for value in items if value > 0]

gyomu_python_analysis-0.5.0/python_analysis_test_support/fixtures/src/analysis/ast/for.py

@@ -0,0 +1,63 @@
+from collections.abc import AsyncIterator
+
+
+def simple_for(values: list[int]) -> int:
+    total = 0
+
+    for value in values:
+        total += value
+
+    return total
+
+
+def for_with_else(values: list[int]) -> int:
+    total = 0
+
+    for value in values:
+        total += value
+    else:
+        total += 1
+
+    return total
+
+
+def for_with_break(values: list[int]) -> int:
+    total = 0
+
+    for value in values:
+        if value < 0:
+            break
+        total += value
+
+    return total
+
+
+def nested_for(values: list[list[int]]) -> int:
+    total = 0
+
+    for items in values:
+        for value in items:
+            total += value
+
+    return total
+
+
+class AsyncValues:
+    def __init__(self, values: list[int]) -> None:
+        self.values = values
+
+    def __aiter__(self) -> AsyncIterator[int]:
+        return self._iterate()
+
+    async def _iterate(self) -> AsyncIterator[int]:
+        for value in self.values:
+            yield value
+
+
+async def async_for(values: AsyncValues) -> int:
+    total = 0
+
+    async for value in values:
+        total += value
+
+    return total

gyomu_python_analysis-0.5.0/python_analysis_test_support/fixtures/src/analysis/ast/function.py

@@ -0,0 +1,22 @@
+def outer() -> None:
+    def inner(value: int) -> str:
+        return str(value)
+
+    result = inner(10)
+
+
+def outer_with_multiple_functions(value: int) -> int:
+    def add(left: int, right: int) -> int:
+        return left + right
+
+    def multiply(left: int, right: int) -> int:
+        return left * right
+
+    return add(value, 2) + multiply(value, 3)
+
+
+def outer_with_async_function() -> None:
+    async def inner(value: int) -> str:
+        return str(value)
+
+    result = inner(10)

gyomu_python_analysis-0.5.0/python_analysis_test_support/fixtures/src/analysis/ast/if.py

@@ -0,0 +1,40 @@
+def simple_if(value: int) -> str:
+    if value > 0:
+        return "positive"
+    return "non-positive"
+
+
+def if_else(value: int) -> str:
+    if value > 0:
+        return "positive"
+    else:
+        return "non-positive"
+
+
+def if_elif_else(value: int) -> str:
+    if value > 0:
+        return "positive"
+    elif value == 0:
+        return "zero"
+    else:
+        return "negative"
+
+
+def nested_if(value: int, threshold: int) -> str:
+    if value > 0:
+        if value >= threshold:
+            return "large"
+        else:
+            return "small"
+    return "non-positive"
+
+
+def if_with_multiple_statements(value: int) -> int:
+    result = 0
+
+    if value > 0:
+        result = value
+        result += 1
+        return result
+
+    return result

gyomu_python_analysis-0.5.0/python_analysis_test_support/fixtures/src/analysis/ast/match.py

@@ -0,0 +1,60 @@
+def simple_match(value: int) -> str:
+    match value:
+        case 0:
+            return "zero"
+        case 1:
+            return "one"
+        case _:
+            return "other"
+
+
+def match_with_guard(value: int) -> str:
+    match value:
+        case number if number > 0:
+            return "positive"
+        case number if number < 0:
+            return "negative"
+        case _:
+            return "zero"
+
+
+def match_with_or_pattern(value: int) -> str:
+    match value:
+        case 0 | 1:
+            return "small"
+        case 2 | 3:
+            return "medium"
+        case _:
+            return "large"
+
+
+def match_sequence(value: list[int]) -> str:
+    match value:
+        case []:
+            return "empty"
+        case [first]:
+            return f"one: {first}"
+        case [first, second]:
+            return f"two: {first}, {second}"
+        case _:
+            return "many"
+
+
+def match_mapping(value: dict[str, int]) -> str:
+    match value:
+        case {"name": name, "age": age}:
+            return f"{name}: {age}"
+        case {"name": name}:
+            return str(name)
+        case _:
+            return "unknown"
+
+
+def match_class(value: object) -> str:
+    match value:
+        case int(number):
+            return f"int: {number}"
+        case str(text):
+            return f"str: {text}"
+        case _:
+            return "other"

gyomu_python_analysis-0.5.0/python_analysis_test_support/fixtures/src/analysis/ast/try.py

@@ -0,0 +1,41 @@
+def simple_try(value: int) -> int:
+    try:
+        return int(value)
+    except ValueError:
+        return 0
+
+
+def try_except_as(value: str) -> int:
+    try:
+        return int(value)
+    except ValueError as error:
+        return 0
+
+
+def try_multiple_except(value: str) -> int:
+    try:
+        return int(value)
+    except ValueError:
+        return 0
+    except TypeError:
+        return -1
+
+
+def try_except_else(value: str) -> int:
+    try:
+        result = int(value)
+    except ValueError:
+        return 0
+    else:
+        return result
+
+
+def try_except_finally(value: str) -> int:
+    try:
+        result = int(value)
+    except ValueError:
+        result = 0
+    finally:
+        result += 1 
+
+    return result

gyomu_python_analysis-0.5.0/python_analysis_test_support/fixtures/src/analysis/ast/with.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+
+def simple_with(path: Path) -> str:
+    with path.open("r") as file:
+        return file.read()
+
+
+def with_as(path: Path) -> str:
+    with path.open("r") as file:
+        content = file.read()
+    return content
+
+
+def with_multiple(path1: Path, path2: Path) -> str:
+    with path1.open("r") as file1, path2.open("r") as file2:
+        return file1.read() + file2.read()
+
+
+def with_without_as(path: Path) -> None:
+    with path.open("r"):
+        pass
+
+
+def nested_with(path1: Path, path2: Path) -> str:
+    with path1.open("r") as file1:
+        with path2.open("r") as file2:
+            return file1.read() + file2.read()
+
+
+def with_multiple_statements(path: Path) -> str:
+    with path.open("r") as file:
+        content = file.read()
+        content = content.strip()
+        return content

{gyomu_python_analysis-0.3.0 → gyomu_python_analysis-0.5.0}/python_analysis_test_support/fixtures/src/analysis/symbol/classes.py

@@ -61,14 +61,16 @@ class Nested:
     def __init__(self, value: int) -> None:
         self.parent_value = value
 
+    def abstract(self)->None:...
+
     class Inner:
         def __init__(self, value: int) -> None:
             self.child_value = value
-
+        def abstract(self)->None:...
         class InnerMost:
             def __init__(self, value: int) -> None:
                 self.grandchild_value = value
-
+            def abstract(self)->None:...
 
 class TypeAlias:
     type UserId = int

{gyomu_python_analysis-0.3.0 → gyomu_python_analysis-0.5.0}/python_analysis_test_support/fixtures/src/analysis/symbol/functions.py

@@ -18,3 +18,5 @@ def parameters(
 
 async def test_async() -> str:
     return "a"
+
+async def abstract()->str:...

{gyomu_python_analysis-0.3.0 → gyomu_python_analysis-0.5.0}/python_analysis_test_support/fixtures/src/analysis/symbol/types.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from enum import Enum
 from typing import Literal
 
@@ -35,3 +35,5 @@ value_tuple_nested3: tuple[tuple[int, ...], ...]
 # Set
 value_set: set[str]
 value_set_nested: set[tuple[str, int]]
+
+CONFIG_OPTIONS: Mapping[str, str] = {}