swarmauri_evaluator_anyusage 0.1.1.dev12__tar.gz

swarmauri_evaluator_anyusage-0.1.1.dev12/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2025] [Jacob Stewart]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

swarmauri_evaluator_anyusage-0.1.1.dev12/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.3
+Name: swarmauri_evaluator_anyusage
+Version: 0.1.1.dev12
+Summary: An evaluator component that detects and penalizes usage of the `Any` type in Python code
+License: Apache-2.0
+Keywords: swarmauri,evaluator,typing,any,static analysis,code quality,type checking,type hints,code evaluation,python
+Author: SwarmAuri Team
+Author-email: team@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Dist: swarmauri_base
+Requires-Dist: swarmauri_core
+Description-Content-Type: text/markdown
+
+pip install swarmauri_evaluator_anyusage

swarmauri_evaluator_anyusage-0.1.1.dev12/README.md

@@ -0,0 +1 @@
+pip install swarmauri_evaluator_anyusage

swarmauri_evaluator_anyusage-0.1.1.dev12/pyproject.toml

@@ -0,0 +1,83 @@
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[project]
+name = "swarmauri_evaluator_anyusage"
+version = "0.1.1.dev12"
+description = "An evaluator component that detects and penalizes usage of the `Any` type in Python code"
+authors = [
+    {name = "SwarmAuri Team", email = "team@swarmauri.com"}
+]
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.10,<3.13"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+]
+keywords = [
+    "swarmauri",
+    "evaluator",
+    "typing",
+    "any",
+    "static analysis",
+    "code quality",
+    "type checking",
+    "type hints",
+    "code evaluation",
+    "python"
+]
+dependencies = [
+    "swarmauri_core",
+    "swarmauri_base",
+]
+
+[tool.uv.sources]
+swarmauri_core = { workspace = true }
+swarmauri_base = { workspace = true }
+swarmauri_standard = { workspace = true }
+
+[project.entry-points."swarmauri.evaluators"]
+AnyTypeUsageEvaluator = "swarmauri_evaluator_anyusage:AnyTypeUsageEvaluator"
+
+[tool.pytest.ini_options]
+norecursedirs = ["combined", "scripts"]
+markers = [
+    "test: standard test",
+    "unit: Unit tests",
+    "i9n: Integration tests",
+    "r8n: Regression tests",
+    "timeout: mark test to timeout after X seconds",
+    "xpass: Expected passes",
+    "xfail: Expected failures",
+    "acceptance: Acceptance tests",
+    "perf: Performance tests that measure execution time and resource usage",
+]
+timeout = 300
+log_cli = true
+log_cli_level = "INFO"
+log_cli_format = "%(asctime)s [%(levelname)s] %(message)s"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"
+asyncio_default_fixture_loop_scope = "function"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24.0",
+    "pytest-xdist>=3.6.1",
+    "pytest-json-report>=1.5.0",
+    "python-dotenv",
+    "requests>=2.32.3",
+    "flake8>=7.0",
+    "pytest-timeout>=2.3.1",
+    "ruff>=0.9.9",
+    "pytest-benchmark>=4.0.0",
+]

swarmauri_evaluator_anyusage-0.1.1.dev12/swarmauri_evaluator_anyusage/AnyTypeUsageEvaluator.py

@@ -0,0 +1,241 @@
+import ast
+import logging
+import os
+import re
+from typing import Any, Dict, List, Literal, Tuple
+
+from pydantic import Field
+from swarmauri_base.evaluators.EvaluatorBase import EvaluatorBase
+from swarmauri_base.ComponentBase import ComponentBase
+from swarmauri_core.programs.IProgram import IProgram as Program
+
+logger = logging.getLogger(__name__)
+
+
+@ComponentBase.register_type(EvaluatorBase, "AnyTypeUsageEvaluator")
+class AnyTypeUsageEvaluator(EvaluatorBase, ComponentBase):
+    """
+    Evaluator that detects and penalizes usage of the `Any` type in Python code.
+
+    This evaluator parses Python source files to identify imports and usages of
+    the `typing.Any` type. It counts occurrences and generates a penalty score
+    proportional to the number of `Any` usages found in the code.
+    """
+
+    type: Literal["AnyTypeUsageEvaluator"] = "AnyTypeUsageEvaluator"
+    penalty_per_occurrence: float = Field(
+        default=0.1, description="Penalty score per Any occurrence"
+    )
+    max_penalty: float = Field(
+        default=1.0, description="Maximum penalty that can be applied"
+    )
+
+    def _compute_score(
+        self, program: Program, **kwargs
+    ) -> Tuple[float, Dict[str, Any]]:
+        """
+        Compute a score based on the usage of `Any` type in the program's files.
+
+        Args:
+            program: The program to evaluate
+            **kwargs: Additional parameters for the evaluation process
+
+        Returns:
+            A tuple containing:
+                - float: A scalar fitness score (1.0 = no Any usage, lower scores indicate Any usage)
+                - Dict[str, Any]: Metadata about the evaluation, including file paths and line numbers
+                  where Any is used
+        """
+        logger.info(f"Evaluating Any type usage in program: {program.name}")
+
+        # Initialize result data
+        any_occurrences = []
+        total_occurrences = 0
+
+        # Get all Python files in the program
+        python_files = self._get_python_files(program)
+        logger.debug(f"Found {len(python_files)} Python files to analyze")
+
+        # Analyze each file for Any usage
+        for file_path in python_files:
+            file_occurrences = self._analyze_file_for_any(file_path)
+            if file_occurrences:
+                total_occurrences += len(file_occurrences)
+                any_occurrences.append(
+                    {"file": file_path, "occurrences": file_occurrences}
+                )
+
+        # Calculate penalty score (1.0 is best, lower is worse)
+        penalty = min(self.max_penalty, total_occurrences * self.penalty_per_occurrence)
+        score = 1.0 - penalty
+
+        metadata = {
+            "total_any_occurrences": total_occurrences,
+            "detailed_occurrences": any_occurrences,
+            "penalty_applied": penalty,
+            "files_analyzed": len(python_files),
+        }
+
+        logger.info(
+            f"Found {total_occurrences} Any type usages across {len(any_occurrences)} files"
+        )
+        return score, metadata
+
+    def _get_python_files(self, program: Program) -> List[str]:
+        """
+        Get all Python files from the program's directory.
+
+        Args:
+            program: The program to evaluate
+
+        Returns:
+            A list of paths to Python files in the program
+        """
+        python_files = []
+
+        # Get the program's root directory
+        if hasattr(program, "path") and program.path:
+            root_dir = program.path
+        else:
+            # Fallback to current directory if path is not available
+            root_dir = os.getcwd()
+            logger.warning(
+                f"Program path not available, using current directory: {root_dir}"
+            )
+
+        # Walk through the directory and collect Python files
+        for dirpath, _, filenames in os.walk(root_dir):
+            for filename in filenames:
+                if filename.endswith(".py"):
+                    python_files.append(os.path.join(dirpath, filename))
+
+        return python_files
+
+    def _analyze_file_for_any(self, file_path: str) -> List[Dict[str, Any]]:
+        """
+        Analyze a Python file for Any type usage.
+
+        This method parses the file and looks for:
+        1. Import statements like 'from typing import Any'
+        2. Direct usage of 'Any' in type annotations
+
+        Args:
+            file_path: Path to the Python file to analyze
+
+        Returns:
+            A list of dictionaries containing line numbers and context for each Any occurrence
+        """
+        occurrences = []
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as file:
+                content = file.read()
+
+            # Parse the file with AST
+            try:
+                tree = ast.parse(content, filename=file_path)
+
+                # Use a visitor to find Any usages in the AST
+                visitor = AnyTypeVisitor()
+                visitor.visit(tree)
+
+                # Add AST-detected occurrences
+                for line_no, context in visitor.any_occurrences:
+                    occurrences.append({"line": line_no, "context": context})
+
+                # Also perform regex search for cases the AST parser might miss
+                lines = content.split("\n")
+                for i, line in enumerate(lines):
+                    # Look for Any that's not part of a word (like "Anything")
+                    # This regex looks for Any as a standalone word or in type annotations
+                    matches = re.finditer(r"\bAny\b|\[Any\]|: Any|-> Any", line)
+                    for match in matches:
+                        # Check if this line is already recorded from AST parsing
+                        if not any(occ["line"] == i + 1 for occ in occurrences):
+                            occurrences.append({"line": i + 1, "context": line.strip()})
+
+            except SyntaxError as e:
+                logger.warning(f"Syntax error in file {file_path}: {str(e)}")
+                # Even with syntax errors, try to find Any with regex
+                lines = content.split("\n")
+                for i, line in enumerate(lines):
+                    if "Any" in line:
+                        # Simple pattern matching for files with syntax errors
+                        if re.search(r"\bAny\b", line):
+                            occurrences.append({"line": i + 1, "context": line.strip()})
+
+        except Exception as e:
+            logger.error(f"Error analyzing file {file_path}: {str(e)}")
+
+        return occurrences
+
+
+class AnyTypeVisitor(ast.NodeVisitor):
+    """
+    AST visitor that finds usages of the Any type in Python code.
+    """
+
+    def __init__(self):
+        self.any_occurrences = []  # List of (line_number, context) tuples
+        self.importing_any = False
+
+    def visit_ImportFrom(self, node):
+        """Visit import from statements to detect 'from typing import Any'."""
+        if node.module == "typing":
+            for name in node.names:
+                if name.name == "Any":
+                    self.any_occurrences.append(
+                        (node.lineno, f"from typing import {name.name}")
+                    )
+                    self.importing_any = True
+        self.generic_visit(node)
+
+    def visit_Name(self, node):
+        """Visit name nodes to find Any identifiers."""
+        if node.id == "Any" and not isinstance(node.ctx, ast.Store):
+            # Get the line of code for context
+            context = "Any used as identifier"
+            self.any_occurrences.append((node.lineno, context))
+        self.generic_visit(node)
+
+    def visit_AnnAssign(self, node):
+        """Visit annotated assignments to find Any in type annotations."""
+        # Check if the annotation contains Any
+        if isinstance(node.annotation, ast.Name) and node.annotation.id == "Any":
+            context = "variable: Any annotation"
+            self.any_occurrences.append((node.lineno, context))
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        """Visit function definitions to find Any in return annotations."""
+        if (
+            node.returns
+            and isinstance(node.returns, ast.Name)
+            and node.returns.id == "Any"
+        ):
+            context = f"def {node.name}(...) -> Any"
+            self.any_occurrences.append((node.lineno, context))
+        self.generic_visit(node)
+
+    def visit_arg(self, node):
+        """Visit function arguments to find Any in parameter annotations."""
+        if (
+            node.annotation
+            and isinstance(node.annotation, ast.Name)
+            and node.annotation.id == "Any"
+        ):
+            context = f"parameter: {node.arg}: Any"
+            self.any_occurrences.append((node.lineno, context))
+        self.generic_visit(node)
+
+    def visit_Subscript(self, node):
+        """Visit subscripts to find Any in complex type annotations like List[Any]."""
+        # Check for Any in subscripts like List[Any]
+        if (
+            isinstance(node.value, ast.Name)
+            and isinstance(node.slice, ast.Name)
+            and node.slice.id == "Any"
+        ):
+            context = f"Complex type with Any: {node.value.id}[Any]"
+            self.any_occurrences.append((node.lineno, context))
+        self.generic_visit(node)

swarmauri_evaluator_anyusage-0.1.1.dev12/swarmauri_evaluator_anyusage/__init__.py

@@ -0,0 +1,16 @@
+from .AnyTypeUsageEvaluator import AnyTypeUsageEvaluator
+
+__all__ = ["AnyTypeUsageEvaluator"]
+
+try:
+    # For Python 3.8 and newer
+    from importlib.metadata import version, PackageNotFoundError
+except ImportError:
+    # For older Python versions, use the backport
+    from importlib_metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("swarmauri_evaluator_anyusage")
+except PackageNotFoundError:
+    # If the package is not installed (for example, during development)
+    __version__ = "0.0.0"