Update test docstring to trigger CI

Co-Authored-By: Joe Moura <joao@crewai.com>

src/crewai/cli/create_flow.py

@@ -28,7 +28,7 @@ def create_flow(name):
     (project_root / "tests").mkdir(exist_ok=True)
 
     # Create .env file
-    with open(project_root / ".env", "w") as file:
+    with open(project_root / ".env", "w", encoding="utf-8", newline="\n") as file:
         file.write("OPENAI_API_KEY=YOUR_API_KEY")
 
     package_dir = Path(__file__).parent
@@ -58,7 +58,7 @@ def create_flow(name):
         content = content.replace("{{flow_name}}", class_name)
         content = content.replace("{{folder_name}}", folder_name)
 
-        with open(dst_file, "w") as file:
+        with open(dst_file, "w", encoding="utf-8", newline="\n") as file:
             file.write(content)
 
     # Copy and process root template files

src/crewai/cli/provider.py

@@ -138,17 +138,22 @@ def load_provider_data(cache_file, cache_expiry):
 
 def read_cache_file(cache_file):
     """
-    Reads and returns the JSON content from a cache file. Returns None if the file contains invalid JSON.
+    Reads and returns the JSON content from a cache file. Returns None if the file contains invalid JSON
+    or if there's an encoding error.
 
     Args:
     - cache_file (Path): The path to the cache file.
 
     Returns:
-    - dict or None: The JSON content of the cache file or None if the JSON is invalid.
+    - dict or None: The JSON content of the cache file or None if the JSON is invalid or there's an encoding error.
     """
     try:
-        with open(cache_file, "r") as f:
+        with open(cache_file, "r", encoding="utf-8") as f:
             return json.load(f)
+    except UnicodeDecodeError as e:
+        click.secho(f"Error reading cache file: Unicode decode error - {e}", fg="red")
+        click.secho("This may be due to file encoding issues. Try deleting the cache file and trying again.", fg="yellow")
+        return None
     except json.JSONDecodeError:
         return None
 
@@ -167,13 +172,16 @@ def fetch_provider_data(cache_file):
         response = requests.get(JSON_URL, stream=True, timeout=60)
         response.raise_for_status()
         data = download_data(response)
-        with open(cache_file, "w") as f:
+        with open(cache_file, "w", encoding="utf-8", newline="\n") as f:
             json.dump(data, f)
         return data
     except requests.RequestException as e:
         click.secho(f"Error fetching provider data: {e}", fg="red")
     except json.JSONDecodeError:
         click.secho("Error parsing provider data. Invalid JSON format.", fg="red")
+    except UnicodeDecodeError as e:
+        click.secho(f"Unicode decode error when processing provider data: {e}", fg="red")
+        click.secho("This may be due to encoding issues with the downloaded data.", fg="yellow")
     return None
 
 

src/crewai/cli/utils.py

@@ -18,19 +18,24 @@ console = Console()
 
 def copy_template(src, dst, name, class_name, folder_name):
     """Copy a file from src to dst."""
-    with open(src, "r") as file:
-        content = file.read()
+    try:
+        with open(src, "r", encoding="utf-8") as file:
+            content = file.read()
 
-    # Interpolate the content
-    content = content.replace("{{name}}", name)
-    content = content.replace("{{crew_name}}", class_name)
-    content = content.replace("{{folder_name}}", folder_name)
+        # Interpolate the content
+        content = content.replace("{{name}}", name)
+        content = content.replace("{{crew_name}}", class_name)
+        content = content.replace("{{folder_name}}", folder_name)
 
-    # Write the interpolated content to the new file
-    with open(dst, "w") as file:
-        file.write(content)
+        # Write the interpolated content to the new file
+        with open(dst, "w", encoding="utf-8", newline="\n") as file:
+            file.write(content)
 
-    click.secho(f"  - Created {dst}", fg="green")
+        click.secho(f"  - Created {dst}", fg="green")
+    except UnicodeDecodeError as e:
+        click.secho(f"Error reading template file {src}: Unicode decode error - {e}", fg="red")
+        click.secho("This may be due to file encoding issues. Please ensure all template files use UTF-8 encoding.", fg="yellow")
+        raise
 
 
 def read_toml(file_path: str = "pyproject.toml"):
@@ -78,7 +83,7 @@ def _get_project_attribute(
     attribute = None
 
     try:
-        with open(pyproject_path, "r") as f:
+        with open(pyproject_path, "r", encoding="utf-8") as f:
             pyproject_content = parse_toml(f.read())
 
         dependencies = (
@@ -119,7 +124,7 @@ def fetch_and_json_env_file(env_file_path: str = ".env") -> dict:
     """Fetch the environment variables from a .env file and return them as a dictionary."""
     try:
         # Read the .env file
-        with open(env_file_path, "r") as f:
+        with open(env_file_path, "r", encoding="utf-8") as f:
             env_content = f.read()
 
         # Parse the .env file content to a dictionary
@@ -133,6 +138,9 @@ def fetch_and_json_env_file(env_file_path: str = ".env") -> dict:
 
     except FileNotFoundError:
         print(f"Error: {env_file_path} not found.")
+    except UnicodeDecodeError as e:
+        click.secho(f"Error reading .env file: Unicode decode error - {e}", fg="red")
+        click.secho("This may be due to file encoding issues. Please ensure the .env file uses UTF-8 encoding.", fg="yellow")
     except Exception as e:
         print(f"Error reading the .env file: {e}")
 
@@ -158,10 +166,15 @@ def tree_find_and_replace(directory, find, replace):
         for filename in files:
             filepath = os.path.join(path, filename)
 
-            with open(filepath, "r") as file:
-                contents = file.read()
-            with open(filepath, "w") as file:
-                file.write(contents.replace(find, replace))
+            try:
+                with open(filepath, "r", encoding="utf-8") as file:
+                    contents = file.read()
+                with open(filepath, "w", encoding="utf-8", newline="\n") as file:
+                    file.write(contents.replace(find, replace))
+            except UnicodeDecodeError as e:
+                click.secho(f"Error processing file {filepath}: Unicode decode error - {e}", fg="red")
+                click.secho("This may be due to file encoding issues. Skipping this file.", fg="yellow")
+                continue
 
             if find in filename:
                 new_filename = filename.replace(find, replace)
@@ -189,11 +202,15 @@ def load_env_vars(folder_path):
     env_file_path = folder_path / ".env"
     env_vars = {}
     if env_file_path.exists():
-        with open(env_file_path, "r") as file:
-            for line in file:
-                key, _, value = line.strip().partition("=")
-                if key and value:
-                    env_vars[key] = value
+        try:
+            with open(env_file_path, "r", encoding="utf-8") as file:
+                for line in file:
+                    key, _, value = line.strip().partition("=")
+                    if key and value:
+                        env_vars[key] = value
+        except UnicodeDecodeError as e:
+            click.secho(f"Error reading .env file: Unicode decode error - {e}", fg="red")
+            click.secho("This may be due to file encoding issues. Please ensure the .env file uses UTF-8 encoding.", fg="yellow")
     return env_vars
 
 
@@ -244,6 +261,11 @@ def write_env_file(folder_path, env_vars):
     - env_vars (dict): A dictionary of environment variables to write.
     """
     env_file_path = folder_path / ".env"
-    with open(env_file_path, "w") as file:
-        for key, value in env_vars.items():
-            file.write(f"{key}={value}\n")
+    try:
+        with open(env_file_path, "w", encoding="utf-8", newline="\n") as file:
+            for key, value in env_vars.items():
+                file.write(f"{key}={value}\n")
+    except Exception as e:
+        click.secho(f"Error writing .env file: {e}", fg="red")
+        click.secho("This may be due to file system permissions or other issues.", fg="yellow")
+        raise

src/crewai/crew.py

@@ -4,7 +4,6 @@ import uuid
 import warnings
 from concurrent.futures import Future
 from hashlib import md5
-from crewai.llm import LLM
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from pydantic import (
@@ -1076,36 +1075,19 @@ class Crew(BaseModel):
     def test(
         self,
         n_iterations: int,
-        llm: Union[str, LLM],
+        openai_model_name: Optional[str] = None,
         inputs: Optional[Dict[str, Any]] = None,
     ) -> None:
-        """Test and evaluate the Crew with the given inputs for n iterations concurrently using concurrent.futures.
-        
-        Args:
-            n_iterations: Number of test iterations to run
-            llm: Language model to use for evaluation. Can be either a model name string (e.g. "gpt-4") 
-                 or an LLM instance for custom implementations
-            inputs: Optional dictionary of input values to use for task execution
-            
-        Example:
-            ```python
-            # Using model name string
-            crew.test(n_iterations=3, llm="gpt-4")
-            
-            # Using custom LLM implementation
-            custom_llm = LLM(model="custom-model")
-            crew.test(n_iterations=3, llm=custom_llm)
-            ```
-        """
+        """Test and evaluate the Crew with the given inputs for n iterations concurrently using concurrent.futures."""
         test_crew = self.copy()
 
         self._test_execution_span = test_crew._telemetry.test_execution_span(
             test_crew,
             n_iterations,
             inputs,
-            str(llm) if isinstance(llm, LLM) else llm,
-        )
-        evaluator = CrewEvaluator(test_crew, llm)
+            openai_model_name,  # type: ignore[arg-type]
+        )  # type: ignore[arg-type]
+        evaluator = CrewEvaluator(test_crew, openai_model_name)  # type: ignore[arg-type]
 
         for i in range(1, n_iterations + 1):
             evaluator.set_iteration(i)

src/crewai/utilities/evaluators/crew_evaluator_handler.py

@@ -1,16 +1,10 @@
 from collections import defaultdict
-from typing import Any, Dict, List, Optional, TypeVar, Union
-from typing import DefaultDict  # Separate import to avoid circular imports
 
 from pydantic import BaseModel, Field
 from rich.box import HEAVY_EDGE
 from rich.console import Console
 from rich.table import Table
 
-from crewai.llm import LLM
-
-T = TypeVar('T', bound=LLM)
-
 from crewai.agent import Agent
 from crewai.task import Task
 from crewai.tasks.task_output import TaskOutput
@@ -34,47 +28,14 @@ class CrewEvaluator:
         iteration (int): The current iteration of the evaluation.
     """
 
-    _tasks_scores: DefaultDict[int, List[float]] = Field(
-        default_factory=lambda: defaultdict(list))
-    _run_execution_times: DefaultDict[int, List[float]] = Field(
-        default_factory=lambda: defaultdict(list))
+    tasks_scores: defaultdict = defaultdict(list)
+    run_execution_times: defaultdict = defaultdict(list)
     iteration: int = 0
 
-    @property
-    def tasks_scores(self) -> DefaultDict[int, List[float]]:
-        return self._tasks_scores
-
-    @tasks_scores.setter
-    def tasks_scores(self, value: Dict[int, List[float]]) -> None:
-        self._tasks_scores = defaultdict(list, value)
-
-    @property
-    def run_execution_times(self) -> DefaultDict[int, List[float]]:
-        return self._run_execution_times
-
-    @run_execution_times.setter
-    def run_execution_times(self, value: Dict[int, List[float]]) -> None:
-        self._run_execution_times = defaultdict(list, value)
-
-    def __init__(self, crew, llm: Union[str, T]):
-        """Initialize the CrewEvaluator.
-        
-        Args:
-            crew: The Crew instance to evaluate
-            llm: Language model to use for evaluation. Can be either a model name string
-                or an LLM instance for custom implementations
-                
-        Raises:
-            ValueError: If llm is None or invalid
-        """
-        if not llm:
-            raise ValueError("Invalid LLM configuration")
-            
+    def __init__(self, crew, openai_model_name: str):
         self.crew = crew
-        self.llm = LLM(model=llm) if isinstance(llm, str) else llm
+        self.openai_model_name = openai_model_name
         self._telemetry = Telemetry()
-        self._tasks_scores = defaultdict(list)
-        self._run_execution_times = defaultdict(list)
         self._setup_for_evaluating()
 
     def _setup_for_evaluating(self) -> None:
@@ -90,7 +51,7 @@ class CrewEvaluator:
             ),
             backstory="Evaluator agent for crew evaluation with precise capabilities to evaluate the performance of the agents in the crew based on the tasks they have performed",
             verbose=False,
-            llm=self.llm,
+            llm=self.openai_model_name,
         )
 
     def _evaluation_task(
@@ -220,19 +181,11 @@ class CrewEvaluator:
                 self.crew,
                 evaluation_result.pydantic.quality,
                 current_task._execution_time,
-                self._get_llm_identifier(),
+                self.openai_model_name,
             )
-            self._tasks_scores[self.iteration].append(evaluation_result.pydantic.quality)
-            self._run_execution_times[self.iteration].append(
+            self.tasks_scores[self.iteration].append(evaluation_result.pydantic.quality)
+            self.run_execution_times[self.iteration].append(
                 current_task._execution_time
             )
         else:
             raise ValueError("Evaluation result is not in the expected format")
-
-    def _get_llm_identifier(self) -> str:
-        """Get a string identifier for the LLM instance.
-        
-        Returns:
-            String representation of the LLM for telemetry
-        """
-        return str(self.llm) if isinstance(self.llm, LLM) else self.llm

tests/cli/test_create_crew.py

@@ -0,0 +1,77 @@
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import click
+from click.testing import CliRunner
+
+from crewai.cli.cli import create
+from crewai.cli.create_crew import create_crew
+
+
+class TestCreateCrew(unittest.TestCase):
+    def setUp(self):
+        self.runner = CliRunner()
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.test_dir = Path(self.temp_dir.name)
+        
+    def tearDown(self):
+        self.temp_dir.cleanup()
+        
+    @patch("crewai.cli.create_crew.get_provider_data")
+    @patch("crewai.cli.create_crew.select_provider")
+    @patch("crewai.cli.create_crew.select_model")
+    @patch("crewai.cli.create_crew.write_env_file")
+    @patch("crewai.cli.create_crew.load_env_vars")
+    @patch("click.confirm")
+    def test_create_crew_handles_unicode(self, mock_confirm, mock_load_env, 
+                                         mock_write_env, mock_select_model, 
+                                         mock_select_provider, mock_get_provider_data):
+        """Test that create_crew command handles Unicode properly."""
+        mock_confirm.return_value = True
+        mock_load_env.return_value = {}
+        mock_get_provider_data.return_value = {"openai": ["gpt-4"]}
+        mock_select_provider.return_value = "openai"
+        mock_select_model.return_value = "gpt-4"
+        
+        templates_dir = Path("src/crewai/cli/templates/crew")
+        templates_dir.mkdir(parents=True, exist_ok=True)
+        
+        template_content = """
+        Hello {{name}}! Unicode test: 你好, こんにちは, Привет 🚀
+        Class: {{crew_name}}
+        Folder: {{folder_name}}
+        """
+        
+        (templates_dir / "tools").mkdir(exist_ok=True)
+        (templates_dir / "config").mkdir(exist_ok=True)
+        
+        for file_name in [".gitignore", "pyproject.toml", "README.md", "__init__.py", "main.py", "crew.py"]:
+            with open(templates_dir / file_name, "w", encoding="utf-8") as f:
+                f.write(template_content)
+                
+        (templates_dir / "knowledge").mkdir(exist_ok=True)
+        with open(templates_dir / "knowledge" / "user_preference.txt", "w", encoding="utf-8") as f:
+            f.write(template_content)
+            
+        for file_path in ["tools/custom_tool.py", "tools/__init__.py", "config/agents.yaml", "config/tasks.yaml"]:
+            (templates_dir / file_path).parent.mkdir(exist_ok=True, parents=True)
+            with open(templates_dir / file_path, "w", encoding="utf-8") as f:
+                f.write(template_content)
+        
+        with patch("crewai.cli.create_crew.Path") as mock_path:
+            mock_path.return_value = self.test_dir
+            mock_path.side_effect = lambda x: self.test_dir / x if isinstance(x, str) else x
+            
+            create_crew("test_crew", skip_provider=True)
+            
+        crew_dir = self.test_dir / "test_crew"
+        for root, _, files in os.walk(crew_dir):
+            for file in files:
+                file_path = os.path.join(root, file)
+                with open(file_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                    self.assertIn("你好", content, f"Unicode characters not preserved in {file_path}")
+                    self.assertIn("🚀", content, f"Emoji not preserved in {file_path}")

tests/cli/test_encoding.py

@@ -0,0 +1,89 @@
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from crewai.cli.provider import fetch_provider_data, read_cache_file
+from crewai.cli.utils import (
+    copy_template,
+    load_env_vars,
+    tree_find_and_replace,
+    write_env_file,
+)
+
+
+class TestEncoding(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.test_dir = Path(self.temp_dir.name)
+        
+        self.unicode_content = "Hello Unicode: 你好, こんにちは, Привет, مرحبا, 안녕하세요 🚀"
+        self.src_file = self.test_dir / "src_file.txt"
+        self.dst_file = self.test_dir / "dst_file.txt"
+        
+        with open(self.src_file, "w", encoding="utf-8") as f:
+            f.write(self.unicode_content)
+            
+    def tearDown(self):
+        self.temp_dir.cleanup()
+        
+    def test_copy_template_handles_unicode(self):
+        """Test that copy_template handles Unicode characters properly in all environments."""
+        copy_template(
+            self.src_file, 
+            self.dst_file, 
+            "test_name", 
+            "TestClass", 
+            "test_folder"
+        )
+        
+        with open(self.dst_file, "r", encoding="utf-8") as f:
+            content = f.read()
+            
+        self.assertIn("你好", content)
+        self.assertIn("こんにちは", content)
+        self.assertIn("🚀", content)
+        
+    def test_env_vars_handle_unicode(self):
+        """Test that environment variable functions handle Unicode characters properly."""
+        test_env_path = self.test_dir / ".env"
+        test_env_vars = {
+            "KEY1": "Value with Unicode: 你好",
+            "KEY2": "More Unicode: こんにちは 🚀"
+        }
+        
+        write_env_file(self.test_dir, test_env_vars)
+        
+        loaded_vars = load_env_vars(self.test_dir)
+        
+        self.assertEqual(loaded_vars["KEY1"], "Value with Unicode: 你好")
+        self.assertEqual(loaded_vars["KEY2"], "More Unicode: こんにちは 🚀")
+        
+    def test_tree_find_and_replace_handles_unicode(self):
+        """Test that tree_find_and_replace handles Unicode characters properly."""
+        test_file = self.test_dir / "replace_test.txt"
+        with open(test_file, "w", encoding="utf-8") as f:
+            f.write("Replace this: PLACEHOLDER with Unicode: 你好")
+            
+        tree_find_and_replace(self.test_dir, "PLACEHOLDER", "🚀")
+        
+        with open(test_file, "r", encoding="utf-8") as f:
+            content = f.read()
+            
+        self.assertIn("Replace this: 🚀 with Unicode: 你好", content)
+        
+    @patch("crewai.cli.provider.requests.get")
+    def test_provider_functions_handle_unicode(self, mock_get):
+        """Test that provider data functions handle Unicode properly."""
+        mock_response = unittest.mock.Mock()
+        mock_response.iter_content.return_value = [self.unicode_content.encode("utf-8")]
+        mock_response.headers.get.return_value = str(len(self.unicode_content))
+        mock_get.return_value = mock_response
+        
+        cache_file = self.test_dir / "cache.json"
+        with open(cache_file, "w", encoding="utf-8") as f:
+            f.write('{"model": "Unicode test: 你好 🚀"}')
+            
+        cache_data = read_cache_file(cache_file)
+        self.assertEqual(cache_data["model"], "Unicode test: 你好 🚀")

tests/crew_test.py

@@ -10,7 +10,6 @@ import instructor
 import pydantic_core
 import pytest
 
-from crewai.llm import LLM
 from crewai.agent import Agent
 from crewai.agents.cache import CacheHandler
 from crewai.crew import Crew
@@ -1124,7 +1123,7 @@ def test_kickoff_for_each_empty_input():
     assert results == []
 
 
-@pytest.mark.vcr(filter_headeruvs=["authorization"])
+@pytest.mark.vcr(filter_headers=["authorization"])
 def test_kickoff_for_each_invalid_input():
     """Tests if kickoff_for_each raises TypeError for invalid input types."""
 
@@ -2829,7 +2828,7 @@ def test_crew_testing_function(kickoff_mock, copy_mock, crew_evaluator):
     copy_mock.return_value = crew
 
     n_iterations = 2
-    crew.test(n_iterations, llm="gpt-4o-mini", inputs={"topic": "AI"})
+    crew.test(n_iterations, openai_model_name="gpt-4o-mini", inputs={"topic": "AI"})
 
     # Ensure kickoff is called on the copied crew
     kickoff_mock.assert_has_calls(
@@ -2845,32 +2844,6 @@ def test_crew_testing_function(kickoff_mock, copy_mock, crew_evaluator):
         ]
     )
 
-@mock.patch("crewai.crew.CrewEvaluator")
-@mock.patch("crewai.crew.Crew.copy")
-@mock.patch("crewai.crew.Crew.kickoff")
-def test_crew_testing_with_custom_llm(kickoff_mock, copy_mock, crew_evaluator):
-    task = Task(
-        description="Test task",
-        expected_output="Test output",
-        agent=researcher,
-    )
-    crew = Crew(agents=[researcher], tasks=[task])
-    copy_mock.return_value = crew
-    custom_llm = LLM(model="gpt-4")
-    
-    crew.test(2, llm=custom_llm, inputs={"topic": "AI"})
-    
-    kickoff_mock.assert_has_calls([
-        mock.call(inputs={"topic": "AI"}),
-        mock.call(inputs={"topic": "AI"})
-    ])
-    crew_evaluator.assert_has_calls([
-        mock.call(crew, custom_llm),
-        mock.call().set_iteration(1),
-        mock.call().set_iteration(2),
-        mock.call().print_crew_evaluation_result(),
-    ])
-
 
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_hierarchical_verbose_manager_agent():
@@ -3152,4 +3125,4 @@ def test_multimodal_agent_live_image_analysis():
     # Verify we got a meaningful response
     assert isinstance(result.raw, str)
     assert len(result.raw) > 100  # Expecting a detailed analysis
-    assert "error" not in result.raw.lower()  # No error messages in response
+    assert "error" not in result.raw.lower()  # No error messages in response

tests/utilities/evaluators/test_crew_evaluator_handler.py

@@ -2,7 +2,6 @@ from unittest import mock
 
 import pytest
 
-from crewai.llm import LLM
 from crewai.agent import Agent
 from crewai.crew import Crew
 from crewai.task import Task
@@ -24,7 +23,7 @@ class TestCrewEvaluator:
         )
         crew = Crew(agents=[agent], tasks=[task])
 
-        return CrewEvaluator(crew, llm="gpt-4o-mini")
+        return CrewEvaluator(crew, openai_model_name="gpt-4o-mini")
 
     def test_setup_for_evaluating(self, crew_planner):
         crew_planner._setup_for_evaluating()
@@ -48,25 +47,6 @@ class TestCrewEvaluator:
         assert agent.verbose is False
         assert agent.llm.model == "gpt-4o-mini"
 
-    @pytest.mark.parametrize("llm_input,expected_model", [
-        (LLM(model="gpt-4"), "gpt-4"),
-        ("gpt-4", "gpt-4"),
-    ])
-    def test_evaluator_with_llm_types(self, crew_planner, llm_input, expected_model):
-        evaluator = CrewEvaluator(crew_planner.crew, llm_input)
-        agent = evaluator._evaluator_agent()
-        assert agent.llm.model == expected_model
-        
-    def test_evaluator_with_invalid_llm(self, crew_planner):
-        with pytest.raises(ValueError, match="Invalid LLM configuration"):
-            CrewEvaluator(crew_planner.crew, None)
-
-    def test_evaluator_with_string_llm(self, crew_planner):
-        evaluator = CrewEvaluator(crew_planner.crew, "gpt-4")
-        agent = evaluator._evaluator_agent()
-        assert isinstance(agent.llm, LLM)
-        assert agent.llm.model == "gpt-4"
-
     def test_evaluation_task(self, crew_planner):
         evaluator_agent = Agent(
             role="Evaluator Agent",