abstra 3.23.7__py3-none-any.whl → 3.23.9__py3-none-any.whl

abstra_internals/repositories/linter/rules/big_py_files.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+from typing import List
+
+from abstra_internals.repositories.linter.models import LinterIssue, LinterRule
+from abstra_internals.repositories.project.project import LocalProjectRepository
+
+# Constant to make it easy to change the line limit
+MAX_LINES_THRESHOLD = 500
+
+
+class BigPyFileFound(LinterIssue):
+    def __init__(self, file_path: Path, line_count: int):
+        self.label = f"File {file_path.name} has {line_count} lines (limit: {MAX_LINES_THRESHOLD}). Consider splitting this file into multiple smaller files organized by responsibilities to improve code maintainability."
+        self.fixes = []  # No automatic fix available for this type of issue
+
+
+class BigPyFiles(LinterRule):
+    label = "Large Python files"
+    type = "info"
+
+    def find_issues(self) -> List[LinterIssue]:
+        project = LocalProjectRepository().load()
+        issues = []
+
+        # Check all Python files in the project
+        for py_file in project.iter_py_files():
+            try:
+                if py_file.exists() and py_file.is_file():
+                    # Count the number of lines in the file
+                    with open(py_file, "r", encoding="utf-8") as f:
+                        line_count = sum(1 for _ in f)
+
+                    # If it exceeds the limit, add an issue
+                    if line_count > MAX_LINES_THRESHOLD:
+                        issues.append(BigPyFileFound(py_file, line_count))
+            except (UnicodeDecodeError, OSError):
+                # Ignore files that cannot be read as text
+                continue
+
+        return issues

abstra_internals/repositories/linter/rules/big_py_files_test.py

@@ -0,0 +1,93 @@
+from abstra_internals.repositories.linter.rules.big_py_files import (
+    MAX_LINES_THRESHOLD,
+    BigPyFiles,
+)
+from tests.fixtures import BaseTest
+
+
+class BigPyFilesTest(BaseTest):
+    def test_big_py_files_valid_small_file(self):
+        """Tests that small files don't generate issues"""
+        # Create a small file
+        script = self.controller.create_tasklet("Small script", "small_script.py")
+        script.file_path.write_text("print('hello world')\n" * 10)  # 10 lines
+
+        rule = BigPyFiles()
+        issues = rule.find_issues()
+        self.assertEqual(len(issues), 0)
+
+    def test_big_py_files_valid_threshold_file(self):
+        """Tests that files exactly at the limit don't generate issues"""
+        script = self.controller.create_tasklet(
+            "Threshold script", "threshold_script.py"
+        )
+        script.file_path.write_text(
+            "print('line')\n" * MAX_LINES_THRESHOLD
+        )  # Exactly at the limit
+
+        rule = BigPyFiles()
+        issues = rule.find_issues()
+        self.assertEqual(len(issues), 0)
+
+    def test_big_py_files_invalid_large_file(self):
+        """Tests that large files generate issues"""
+        script = self.controller.create_tasklet("Large script", "large_script.py")
+        # Create a file with more lines than the limit
+        script.file_path.write_text("print('line')\n" * (MAX_LINES_THRESHOLD + 50))
+
+        rule = BigPyFiles()
+        issues = rule.find_issues()
+        self.assertEqual(len(issues), 1)
+
+        issue = issues[0]
+        self.assertIn("large_script.py", issue.label)
+        self.assertIn(str(MAX_LINES_THRESHOLD + 50), issue.label)
+        self.assertIn("lines", issue.label)
+        self.assertIn("responsibilities", issue.label)
+
+    def test_big_py_files_multiple_files(self):
+        """Tests behavior with multiple files"""
+        # Small file
+        small_script = self.controller.create_tasklet("Small script", "small.py")
+        small_script.file_path.write_text("print('small')\n" * 10)
+
+        # Large file
+        large_script = self.controller.create_tasklet("Large script", "large.py")
+        large_script.file_path.write_text(
+            "print('large')\n" * (MAX_LINES_THRESHOLD + 100)
+        )
+
+        # Another large file
+        another_large_script = self.controller.create_tasklet(
+            "Another large", "another_large.py"
+        )
+        another_large_script.file_path.write_text(
+            "print('another')\n" * (MAX_LINES_THRESHOLD + 200)
+        )
+
+        rule = BigPyFiles()
+        issues = rule.find_issues()
+        self.assertEqual(len(issues), 2)  # Only the 2 large files
+
+        # Check if the file names are in the issues
+        issue_labels = [issue.label for issue in issues]
+        self.assertTrue(any("large.py" in label for label in issue_labels))
+        self.assertTrue(any("another_large.py" in label for label in issue_labels))
+
+    def test_big_py_files_empty_file(self):
+        """Tests behavior with empty file"""
+        script = self.controller.create_tasklet("Empty script", "empty.py")
+        script.file_path.touch()  # Create empty file
+
+        rule = BigPyFiles()
+        issues = rule.find_issues()
+        self.assertEqual(len(issues), 0)
+
+    def test_big_py_files_nonexistent_file(self):
+        """Tests behavior when file doesn't exist"""
+        script = self.controller.create_tasklet("Nonexistent script", "nonexistent.py")
+        script.file_path.unlink()  # Remove the file
+
+        rule = BigPyFiles()
+        issues = rule.find_issues()
+        self.assertEqual(len(issues), 0)  # Should not generate error or issue

abstra_internals/repositories/linter/rules/duplicate_package_in_requirements.py

@@ -5,7 +5,10 @@ from abstra_internals.repositories.linter.models import (
     LinterIssue,
     LinterRule,
 )
-from abstra_internals.services.requirements import RequirementsRepository
+from abstra_internals.services.requirements import (
+    RequirementsRepository,
+    requirement_to_dict,
+)
 
 
 class MergeDuplicatePackages(LinterFix):
@@ -52,9 +55,18 @@ class DuplicatePackagesInRequirements(LinterRule):
         duplicates = requirements.get_duplicates()
         issues = []
         for name, versions in duplicates.items():
+            # Extract exact versions from specifiers
+            version_list = []
+            for r in versions:
+                req_dict = requirement_to_dict(r)
+                exact_version = None
+                for spec in req_dict.get("specifiers", []):
+                    if spec["operator"] == "==":
+                        exact_version = spec["version"]
+                        break
+                version_list.append(exact_version)
+
             issues.append(
-                DuplicatePackagesInRequirementsFound(
-                    name=name, versions=[r.version for r in versions]
-                )
+                DuplicatePackagesInRequirementsFound(name=name, versions=version_list)
             )
         return issues

abstra_internals/repositories/linter/rules/duplicate_package_in_requirements_test.py

@@ -1,7 +1,10 @@
 from abstra_internals.repositories.linter.rules.duplicate_package_in_requirements import (
     DuplicatePackagesInRequirements,
 )
-from abstra_internals.services.requirements import RequirementsRepository
+from abstra_internals.services.requirements import (
+    RequirementsRepository,
+    requirement_to_dict,
+)
 from tests.fixtures import BaseTest
 
 
@@ -49,7 +52,16 @@ class TestDuplicatePackagesInRequirements(BaseTest):
         requirements = RequirementsRepository.load()
         self.assertEqual(len(requirements.libraries), 1)
         self.assertEqual(requirements.libraries[0].name, "abstra")
-        self.assertEqual(requirements.libraries[0].version, "1.0.0")
+
+        # Use helper function to get version from Requirement
+        req_dict = requirement_to_dict(requirements.libraries[0])
+        # Extract exact version from specifiers
+        exact_version = None
+        for spec in req_dict.get("specifiers", []):
+            if spec["operator"] == "==":
+                exact_version = spec["version"]
+                break
+        self.assertEqual(exact_version, "1.0.0")
 
     def test_invalid_with_distinct_versions_choose_second(self):
         requirements_txt = self.root / "requirements.txt"
@@ -66,4 +78,13 @@ class TestDuplicatePackagesInRequirements(BaseTest):
         requirements = RequirementsRepository.load()
         self.assertEqual(len(requirements.libraries), 1)
         self.assertEqual(requirements.libraries[0].name, "abstra")
-        self.assertEqual(requirements.libraries[0].version, "2.0.0")
+
+        # Use helper function to get version from Requirement
+        req_dict = requirement_to_dict(requirements.libraries[0])
+        # Extract exact version from specifiers
+        exact_version = None
+        for spec in req_dict.get("specifiers", []):
+            if spec["operator"] == "==":
+                exact_version = spec["version"]
+                break
+        self.assertEqual(exact_version, "2.0.0")

abstra_internals/repositories/linter/rules/env_in_bundle.py

@@ -1,5 +1,6 @@
 from typing import List
 
+from abstra_internals.consts.filepaths import ABSTRA_IGNORE_FILEPATH
 from abstra_internals.repositories.linter.models import (
     LinterFix,
     LinterIssue,
@@ -13,7 +14,7 @@ class AddEnvToAbstraIgnore(LinterFix):
     label = "Add env to abstra ignore"
 
     def fix(self):
-        abstraignore_file = Settings.root_path / ".abstraignore"
+        abstraignore_file = Settings.root_path / ABSTRA_IGNORE_FILEPATH
         with abstraignore_file.open("a") as file:
             file.write("\n.env")
 
@@ -34,11 +35,7 @@ class EnvInBundle(LinterRule):
         if not env_file.exists():
             return []
 
-        ignored_patterns = FileSystemService.load_ignore_patterns(Settings.root_path)
-
-        if FileSystemService.is_ignored(
-            ignored_patterns, env_file.relative_to(Settings.root_path)
-        ):
+        if FileSystemService.is_ignored(env_file):
             return []
 
         return [EnvInBundleFound()]

abstra_internals/repositories/linter/rules/env_in_bundle_test.py

@@ -1,5 +1,6 @@
 from unittest import TestCase
 
+from abstra_internals.consts.filepaths import ABSTRA_IGNORE_FILEPATH
 from abstra_internals.repositories.linter.rules.env_in_bundle import EnvInBundle
 from tests.fixtures import clear_dir, init_dir
 
@@ -20,7 +21,7 @@ class EnvInBundleTest(TestCase):
     def test_env_on_bundle_valid_with_env(self):
         rule = EnvInBundle()
         env_file = self.root / ".env"
-        abstraignore_file = self.root / ".abstraignore"
+        abstraignore_file = self.root / ABSTRA_IGNORE_FILEPATH
         abstraignore_file.write_text(".env")
         env_file.touch()
         self.assertEqual(len(rule.find_issues()), 0)
@@ -34,7 +35,7 @@ class EnvInBundleTest(TestCase):
     def test_env_on_bundle_invalid_with_abstraignore_file(self):
         env_file = self.root / ".env"
         env_file.touch()
-        abstraignore_file = self.root / ".abstraignore"
+        abstraignore_file = self.root / ABSTRA_IGNORE_FILEPATH
         abstraignore_file.touch()
         rule = EnvInBundle()
         self.assertEqual(len(rule.find_issues()), 1)
@@ -46,7 +47,7 @@ class EnvInBundleTest(TestCase):
         self.assertEqual(len(rule.find_issues()), 1)
         rule.find_issues()[0].fixes[0].fix()
         self.assertEqual(len(rule.find_issues()), 0)
-        abstraignore_file = self.root / ".abstraignore"
+        abstraignore_file = self.root / ABSTRA_IGNORE_FILEPATH
         self.assertTrue(abstraignore_file.exists())
         with abstraignore_file.open("r") as file:
             content = file.read()

abstra_internals/repositories/linter/rules/missing_packages_in_requirements.py

@@ -8,6 +8,7 @@ from abstra_internals.repositories.linter.models import (
 from abstra_internals.services.requirements import (
     RequirementRecommendation,
     RequirementsRepository,
+    requirement_to_dict,
 )
 
 
@@ -21,7 +22,17 @@ class AddMissingPackagesToRequirements(LinterFix):
     def fix(self):
         requirements = RequirementsRepository.load()
         requirement_name = self.requirement_recommendation.requirement.name
-        requirement_version = self.requirement_recommendation.requirement.version
+        requirement_dict = requirement_to_dict(
+            self.requirement_recommendation.requirement
+        )
+
+        # Extract exact version from specifiers if available
+        requirement_version = None
+        for spec in requirement_dict.get("specifiers", []):
+            if spec["operator"] == "==":
+                requirement_version = spec["version"]
+                break
+
         requirements.add(requirement_name, requirement_version)
         RequirementsRepository.save(requirements)
 

abstra_internals/repositories/linter/rules/syntax_errors.py

@@ -1,32 +1,15 @@
-import webbrowser
-from pathlib import Path
 from typing import List
 
-from abstra_internals.repositories.linter.models import (
-    LinterFix,
-    LinterIssue,
-    LinterRule,
-)
+from abstra_internals.repositories.linter.models import LinterIssue, LinterRule
 from abstra_internals.repositories.project.project import LocalProjectRepository
 from abstra_internals.utils.file import silent_traverse_code
 
 
-class OpenBrokenFile(LinterFix):
-    file: Path
-
-    def __init__(self, file: Path) -> None:
-        self.label = f"Open {file}"
-        self.file = file
-
-    def fix(self):
-        webbrowser.open(self.file.absolute().as_uri())
-
-
 class SyntaxErrorFound(LinterIssue):
     def __init__(self, error: SyntaxError) -> None:
         self.label = str(error)
         if error.filename is not None:
-            self.fixes = [OpenBrokenFile(Path(error.filename))]
+            self.fixes = []
 
 
 class SyntaxErrors(LinterRule):

abstra_internals/repositories/linter/rules/venv_in_bundle.py

@@ -2,6 +2,7 @@ import sys
 from pathlib import Path
 from typing import List
 
+from abstra_internals.consts.filepaths import ABSTRA_IGNORE_FILEPATH
 from abstra_internals.repositories.linter.models import (
     LinterFix,
     LinterIssue,
@@ -36,7 +37,7 @@ class AddVenvToAbstraIgnore(LinterFix):
         root_path, prefix_path = get_root_and_prefix_path()
         venv_folder = prefix_path.replace(root_path, "").lstrip("/")
 
-        abstraignore_file = Settings.root_path / ".abstraignore"
+        abstraignore_file = Settings.root_path / ABSTRA_IGNORE_FILEPATH
         with abstraignore_file.open("a") as file:
             file.write("\n")
             file.write(venv_folder)
@@ -57,7 +58,7 @@ class VenvInBundle(LinterRule):
         return prefix_path.startswith(root_path)
 
     def virtualenv_in_abstraignore(self) -> bool:
-        abstraignore_file = Settings.root_path / ".abstraignore"
+        abstraignore_file = Settings.root_path / ABSTRA_IGNORE_FILEPATH
         if not abstraignore_file.exists():
             return False
 

abstra_internals/server/routes/requirements.py

@@ -1,7 +1,11 @@
 import flask
 
 from abstra_internals.controllers.main import MainController
-from abstra_internals.services.requirements import Requirement, RequirementsRepository
+from abstra_internals.services.requirements import (
+    RequirementsRepository,
+    create_requirement,
+    uninstall_requirement,
+)
 from abstra_internals.usage import editor_usage
 
 
@@ -40,8 +44,8 @@ def get_editor_bp(controller: MainController):
 
     @bp.post("/<name>/uninstall")
     def _uninstall_requirement(name: str):
-        req = Requirement(name=name)
-        streamer = req.uninstall()
+        req = create_requirement(name)
+        streamer = uninstall_requirement(req)
         if streamer is None:
             flask.abort(403)
         reqs = RequirementsRepository.load()

abstra_internals/server/routes/workspace.py

@@ -41,16 +41,6 @@ def get_editor_bp(controller: MainController):
         except Exception as e:
             return {"error": f"Could not get version: {str(e)}"}, 500
 
-    @bp.post("/open-file")
-    @editor_usage
-    def _open_file():
-        if not flask.request.json:
-            flask.abort(400)
-        file_path = flask.request.json["path"]
-        mode = flask.request.json.get("mode", "file")
-        controller.open_file(file_path, create_if_not_exists=True, mode=mode)
-        return {"success": True}
-
     @bp.post("/init-file")
     @editor_usage
     def _init_file():

abstra_internals/services/file_watcher.py

@@ -15,6 +15,7 @@ from watchdog.observers import Observer
 
 from abstra_internals.settings import Settings
 from abstra_internals.utils.crdt import CRDTManager
+from abstra_internals.utils.file import safe_read_file, safe_write_file
 
 IGNORED_PATHS = [
     ".abstra/",
@@ -55,19 +56,21 @@ class FileWatcher(FileSystemEventHandler):
             event_type = "moved"
         elif isinstance(event, FileModifiedEvent):
             event_type = "changed"
-            content = (
-                filepath.read_text(encoding="utf-8") if filepath.is_file() else None
-            )
-
-            if filepath_str not in crdt_managers or crdt_managers[filepath_str] is None:
-                crdt_managers[filepath_str] = CRDTManager(file_path=filepath)
-
-            old_content = crdt_managers[filepath_str].get_content()
-            if content is not None and old_content != content:
-                crdt_managers[filepath_str].apply_operations_from_diff(content)
-                new_content = crdt_managers[filepath_str].get_content()
-                if content != new_content:
-                    filepath.write_text(new_content, encoding="utf-8")
+            content = safe_read_file(filepath, 2.0)
+
+            if content is not None:
+                if (
+                    filepath_str not in crdt_managers
+                    or crdt_managers[filepath_str] is None
+                ):
+                    crdt_managers[filepath_str] = CRDTManager(file_path=filepath)
+
+                old_content = crdt_managers[filepath_str].get_content()
+                if old_content != content:
+                    crdt_managers[filepath_str].apply_operations_from_diff(content)
+                    new_content = crdt_managers[filepath_str].get_content()
+                    if content != new_content:
+                        safe_write_file(filepath, new_content, 2.0)
 
         else:
             return
@@ -90,7 +93,7 @@ class FileWatcher(FileSystemEventHandler):
 
         self._debounce_timers[filepath_str] = threading.Timer(
             interval=0.5, function=execute_handlers
-        )  # 500ms debounce
+        )
         self._debounce_timers[filepath_str].start()
 
     def should_ignore_path(self, path: Path) -> bool: