Datasets:

FudanSELab

/

ClassEval

like 8

[ "import logging", "import datetime" ]

[ { "method_name": "filter", "method_description": "def filter(self, request):\n \"\"\"\n Filter the incoming request based on certain rules and conditions.\n :param request: dict, the incoming request details\n :return: bool, True if the request is allowed, False otherwise\n >>> filter = AccessGatewayFilter()\n >>> filter.filter({'path': '/login', 'method': 'POST'})\n True\n\n \"\"\"", "test_class": "AccessGatewayFilterTestFilter", "test_code": "class AccessGatewayFilterTestFilter(unittest.TestCase):\n def test_filter_1(self):\n agf = AccessGatewayFilter()\n request = {'path': '/api/data', 'method': 'GET'}\n res = agf.filter(request)\n self.assertTrue(res)\n\n def test_filter_2(self):\n agf = AccessGatewayFilter()\n request = {'path': '/api/data', 'method': 'POST'}\n res = agf.filter(request)\n self.assertTrue(res)\n\n def test_filter_3(self):\n agf = AccessGatewayFilter()\n request = {'path': '/login/data', 'method': 'GET'}\n res = agf.filter(request)\n self.assertTrue(res)\n\n def test_filter_4(self):\n agf = AccessGatewayFilter()\n request = {'path': '/login/data', 'method': 'POST'}\n res = agf.filter(request)\n self.assertTrue(res)\n\n def test_filter_5(self):\n agf = AccessGatewayFilter()\n request = {'path': '/abc', 'method': 'POST',\n 'headers': {\n 'Authorization': {'user': {'name': 'user1', 'level': 5, 'address': 'address1'},\n 'jwt': 'user1' + str(datetime.date.today())}}}\n res = agf.filter(request)\n self.assertTrue(res)\n\n def test_filter_6(self):\n agf = AccessGatewayFilter()\n request = {'path': '/abc', 'method': 'POST',\n 'headers': {\n 'Authorization': {'user': {'name': 'user1', 'level': 3, 'address': 'address1'},\n 'jwt': 'user1' + str(datetime.date.today() - datetime.timedelta(days=365))}}}\n res = agf.filter(request)\n self.assertFalse(res)\n\n def test_filter_7(self):\n agf = AccessGatewayFilter()\n request = {'path': '/abc', 'method': 'POST',\n 'headers': {\n 'Authorization': {'user': {'name': 'user1', 'level': 1, 'address': 'address1'},\n 'jwt': 'user1' + str(datetime.date.today())}}}\n res = agf.filter(request)\n self.assertIsNone(res)\n\n def test_filter_8(self):\n agf = AccessGatewayFilter()\n request = {'path': '/abc', 'method': 'POST',\n 'headers': {\n 'Authorization': {'user': {'name': 'user1', 'level': 3, 'address': 'address1'},\n 'jwt': 'user2' + str(datetime.date.today() - datetime.timedelta(days=365))}}}\n res = agf.filter(request)\n self.assertTrue(res)", "solution_code": "def filter(self, request):\n request_uri = request['path']\n method = request['method']\n\n if self.is_start_with(request_uri):\n return True\n\n try:\n token = self.get_jwt_user(request)\n user = token['user']\n if user['level'] > 2:\n self.set_current_user_info_and_log(user)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "is_start_with", "get_jwt_user", "set_current_user_info_and_log" ] } }, { "method_name": "is_start_with", "method_description": "def is_start_with(self, request_uri):\n \"\"\"\n Check if the request URI starts with certain prefixes.\n Currently, the prefixes being checked are \"/api\" and \"/login\".\n :param request_uri: str, the URI of the request\n :return: bool, True if the URI starts with certain prefixes, False otherwise\n >>> filter = AccessGatewayFilter()\n >>> filter.is_start_with('/api/data')\n True\n\n \"\"\"", "test_class": "AccessGatewayFilterTestIsStartWith", "test_code": "class AccessGatewayFilterTestIsStartWith(unittest.TestCase):\n def test_is_start_with_1(self):\n agf = AccessGatewayFilter()\n request_uri = '/api/data'\n res = agf.is_start_with(request_uri)\n self.assertTrue(res)\n\n def test_is_start_with_2(self):\n agf = AccessGatewayFilter()\n request_uri = '/admin/settings'\n res = agf.is_start_with(request_uri)\n self.assertFalse(res)\n\n def test_is_start_with_3(self):\n agf = AccessGatewayFilter()\n request_uri = '/login/data'\n res = agf.is_start_with(request_uri)\n self.assertTrue(res)\n\n def test_is_start_with_4(self):\n agf = AccessGatewayFilter()\n request_uri = '/abc/data'\n res = agf.is_start_with(request_uri)\n self.assertFalse(res)\n\n def test_is_start_with_5(self):\n agf = AccessGatewayFilter()\n request_uri = '/def/data'\n res = agf.is_start_with(request_uri)\n self.assertFalse(res)", "solution_code": "def is_start_with(self, request_uri):\n start_with = [\"/api\", '/login']\n for s in start_with:\n if request_uri.startswith(s):\n return True\n return False", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "get_jwt_user", "method_description": "def get_jwt_user(self, request):\n \"\"\"\n Get the user information from the JWT token in the request.\n :param request: dict, the incoming request details\n :return: dict or None, the user information if the token is valid, None otherwise\n >>> filter = AccessGatewayFilter()\n >>> filter.get_jwt_user({'headers': {'Authorization': {'user': {'name': 'user1'}, 'jwt': 'user1'+str(datetime.date.today())}}})\n {'user': {'name': 'user1'}\n\n \"\"\"", "test_class": "AccessGatewayFilterTestGetJwtUser", "test_code": "class AccessGatewayFilterTestGetJwtUser(unittest.TestCase):\n def test_get_jwt_user_1(self):\n agf = AccessGatewayFilter()\n request = {\n 'headers': {'Authorization': {'user': {'name': 'user1'}, 'jwt': 'user1' + str(datetime.date.today())}}}\n res = agf.get_jwt_user(request)\n self.assertIsNotNone(res)\n\n def test_get_jwt_user_2(self):\n agf = AccessGatewayFilter()\n request = {\n 'headers': {'Authorization': {'user': {'name': 'user2'}, 'jwt': 'user2' + str(datetime.date.today())}}}\n res = agf.get_jwt_user(request)\n self.assertIsNotNone(res)\n\n def test_get_jwt_user_3(self):\n agf = AccessGatewayFilter()\n request = {\n 'headers': {'Authorization': {'user': {'name': 'user3'}, 'jwt': 'user3' + str(datetime.date.today())}}}\n res = agf.get_jwt_user(request)\n self.assertIsNotNone(res)\n\n def test_get_jwt_user_4(self):\n agf = AccessGatewayFilter()\n request = {\n 'headers': {'Authorization': {'user': {'name': 'user4'}, 'jwt': 'user4' + str(datetime.date.today())}}}\n res = agf.get_jwt_user(request)\n self.assertIsNotNone(res)\n\n def test_get_jwt_user_5(self):\n agf = AccessGatewayFilter()\n request = {'headers': {'Authorization': {'user': {'name': 'user1'}, 'jwt': 'user1' + str(\n datetime.date.today() - datetime.timedelta(days=5))}}}\n res = agf.get_jwt_user(request)\n self.assertIsNone(res)", "solution_code": "def get_jwt_user(self, request):\n token = request['headers']['Authorization']\n user = token['user']\n if token['jwt'].startswith(user['name']):\n jwt_str_date = token['jwt'].split(user['name'])[1]\n jwt_date = datetime.datetime.strptime(jwt_str_date, \"%Y-%m-%d\")\n if datetime.datetime.today() - jwt_date >= datetime.timedelta(days=3):\n return None\n return token", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "set_current_user_info_and_log", "method_description": "def set_current_user_info_and_log(self, user):\n \"\"\"\n Set the current user information and log the access.\n :param user: dict, the user information\n :return: None\n >>> filter = AccessGatewayFilter()\n >>> user = {'name': 'user1', 'address': '127.0.0.1'}\n >>> filter.set_current_user_info_and_log(user)\n\n \"\"\"", "test_class": "AccessGatewayFilterTest", "test_code": "class AccessGatewayFilterTest(unittest.TestCase):\n def test_AccessGatewayFilter(self):\n agf = AccessGatewayFilter()\n request = {'path': '/api/data', 'method': 'GET'}\n res = agf.filter(request)\n self.assertTrue(res)\n\n request_uri = '/api/data'\n res = agf.is_start_with(request_uri)\n self.assertTrue(res)\n\n request = {\n 'headers': {'Authorization': {'user': {'name': 'user1'}, 'jwt': 'user1' + str(datetime.date.today())}}}\n res = agf.get_jwt_user(request)\n self.assertIsNotNone(res)", "solution_code": "def set_current_user_info_and_log(self, user):\n host = user['address']\n logging.log(msg=user['name'] + host + str(datetime.datetime.now()), level=1)", "dependencies": { "Standalone": false, "lib_dependencies": [ "logging", "datetime" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "AccessGatewayFilterTestFilter", "AccessGatewayFilterTestIsStartWith", "AccessGatewayFilterTestGetJwtUser", "AccessGatewayFilterTest" ]

[]

[ "import math" ]

[ { "method_name": "calculate_circle_area", "method_description": "def calculate_circle_area(self):\n \"\"\"\n calculate the area of circle based on self.radius\n :return: area of circle, float\n >>> areaCalculator = AreaCalculator(2)\n >>> areaCalculator.calculate_circle_area()\n 12.566370614359172\n \"\"\"", "test_class": "AreaCalculatorTestCalculateCircleArea", "test_code": "class AreaCalculatorTestCalculateCircleArea(unittest.TestCase):\n def test_calculate_circle_area(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(12.56, areaCalculator.calculate_circle_area(), delta=0.01)\n def test_calculate_circle_area_2(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(19.63, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_circle_area_3(self):\n areaCalculator = AreaCalculator(2000)\n self.assertAlmostEqual(12566370.61, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_circle_area_4(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(0, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_circle_area_5(self):\n areaCalculator = AreaCalculator(0.1)\n self.assertAlmostEqual(0.031, areaCalculator.calculate_circle_area(), delta=0.01)", "solution_code": "def calculate_circle_area(self):\n return math.pi * self.radius ** 2", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [ "self.radius" ], "method_dependencies": [] } }, { "method_name": "calculate_sphere_area", "method_description": "def calculate_sphere_area(self):\n \"\"\"\n calculate the area of sphere based on self.radius\n :return: area of sphere, float\n >>> areaCalculator = AreaCalculator(2)\n >>> areaCalculator.calculate_sphere_area()\n 50.26548245743669\n \"\"\"", "test_class": "AreaCalculatorTestCalculateSphereArea", "test_code": "class AreaCalculatorTestCalculateSphereArea(unittest.TestCase):\n def test_calculate_sphere_area(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(50.27, areaCalculator.calculate_sphere_area(), delta=0.01)\n\n def test_calculate_sphere_area_2(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(19.63, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_sphere_area_3(self):\n areaCalculator = AreaCalculator(2000)\n self.assertAlmostEqual(12566370.61, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_sphere_area_4(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(0, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_sphere_area_5(self):\n areaCalculator = AreaCalculator(0.1)\n self.assertAlmostEqual(0.031, areaCalculator.calculate_circle_area(), delta=0.01)", "solution_code": "def calculate_sphere_area(self):\n return 4 * math.pi * self.radius ** 2", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [ "self.radius" ], "method_dependencies": [] } }, { "method_name": "calculate_cylinder_area", "method_description": "def calculate_cylinder_area(self, height):\n \"\"\"\n calculate the area of cylinder based on self.radius and height\n :param height: height of cylinder, float\n :return: area of cylinder, float\n >>> areaCalculator = AreaCalculator(2)\n >>> areaCalculator.calculate_cylinder_area(3)\n 62.83185307179586\n \"\"\"", "test_class": "AreaCalculatorTestCalculateCylinderArea", "test_code": "class AreaCalculatorTestCalculateCylinderArea(unittest.TestCase):\n def test_calculate_cylinder_area(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(50.27, areaCalculator.calculate_cylinder_area(2), delta=0.01)\n\n def test_calculate_cylinder_area_2(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(25.13, areaCalculator.calculate_cylinder_area(0), delta=0.01)\n\n def test_calculate_cylinder_area_3(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(0, areaCalculator.calculate_cylinder_area(2000), delta=0.01)\n\n def test_calculate_cylinder_area_4(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(70.68, areaCalculator.calculate_cylinder_area(2), delta=0.01)\n\n def test_calculate_cylinder_area_5(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(62.83, areaCalculator.calculate_cylinder_area(1.5), delta=0.01)", "solution_code": "def calculate_cylinder_area(self, height):\n return 2 * math.pi * self.radius * (self.radius + height)", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [ "self.radius" ], "method_dependencies": [] } }, { "method_name": "calculate_sector_area", "method_description": "def calculate_sector_area(self, angle):\n \"\"\"\n calculate the area of sector based on self.radius and angle\n :param angle: angle of sector, float\n :return: area of sector, float\n >>> areaCalculator = AreaCalculator(2)\n >>> areaCalculator.calculate_sector_area(math.pi)\n 6.283185307179586\n \"\"\"", "test_class": "AreaCalculatorTestCalculateSectorArea", "test_code": "class AreaCalculatorTestCalculateSectorArea(unittest.TestCase):\n def test_calculate_sector_area(self):\n areaCalculator = AreaCalculator(1.5)\n self.assertAlmostEqual(3.53, areaCalculator.calculate_sector_area(math.pi), delta=0.01)\n\n def test_calculate_sector_area_2(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(3.14, areaCalculator.calculate_sector_area(math.pi/2), delta=0.01)\n\n def test_calculate_sector_area_3(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(0, areaCalculator.calculate_sector_area(0), delta=0.01)\n\n def test_calculate_sector_area_4(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(12.56, areaCalculator.calculate_sector_area(2*math.pi), delta=0.01)\n\n def test5_calculate_sector_area_5(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(0, areaCalculator.calculate_sector_area(math.pi), delta=0.01)", "solution_code": "def calculate_sector_area(self, angle):\n return self.radius ** 2 * angle / 2", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.radius" ], "method_dependencies": [] } }, { "method_name": "calculate_annulus_area", "method_description": "def calculate_annulus_area(self, inner_radius, outer_radius):\n \"\"\"\n calculate the area of annulus based on inner_radius and out_radius\n :param inner_radius: inner radius of sector, float\n :param outer_radius: outer radius of sector, float\n :return: area of annulus, float\n >>> areaCalculator.calculate_annulus_area(2, 3)\n 15.707963267948966\n \"\"\"", "test_class": "AreaCalculatorTestCalculateAnnulusArea", "test_code": "class AreaCalculatorTestCalculateAnnulusArea(unittest.TestCase):\n def test_calculate_annulus_area(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(25.128, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)\n\n def test_calculate_annulus_area_2(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(0, areaCalculator.calculate_annulus_area(3, 3), delta=0.01)\n\n def test_calculate_annulus_area_3(self):\n areaCalculator = AreaCalculator(2000)\n self.assertAlmostEqual(3.14, areaCalculator.calculate_annulus_area(0, 1), delta=0.01)\n\n def test_calculate_annulus_area_4(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(25.13, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)\n\n def test_calculate_annulus_area_5(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(25.13, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)", "solution_code": "def calculate_annulus_area(self, inner_radius, outer_radius):\n return math.pi * (outer_radius ** 2 - inner_radius ** 2)", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "AreaCalculatorTestCalculateCircleArea", "AreaCalculatorTestCalculateSphereArea", "AreaCalculatorTestCalculateCylinderArea", "AreaCalculatorTestCalculateSectorArea", "AreaCalculatorTestCalculateAnnulusArea", "AreaCalculatorTestCalculateMain" ]

[ "self.radius" ]

[]

[ { "method_name": "parse_arguments", "method_description": "def parse_arguments(self, command_string):\n \"\"\"\n Parses the given command line argument string and invoke _convert_type to stores the parsed result in specific type in the arguments dictionary.\n Checks for missing required arguments, if any, and returns False with the missing argument names, otherwise returns True.\n :param command_string: str, command line argument string, formatted like \"python script.py --arg1=value1 -arg2 value2 --option1 -option2\"\n :return tuple: (True, None) if parsing is successful, (False, missing_args) if parsing fails,\n where missing_args is a set of the missing argument names which are str.\n >>> parser.parse_arguments(\"python script.py --arg1=value1 -arg2 value2 --option1 -option2\")\n (True, None)\n >>> parser.arguments\n {'arg1': 'value1', 'arg2': 'value2', 'option1': True, 'option2': True}\n \"\"\"", "test_class": "ArgumentParserTestParseArguments", "test_code": "class ArgumentParserTestParseArguments(unittest.TestCase):\n\n def setUp(self):\n self.parser = ArgumentParser()\n\n # key value arguments\n def test_parse_arguments_1(self):\n command_str = \"script --name=John --age=25\"\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", arg_type=int)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertTrue(result)\n self.assertIsNone(missing_args)\n self.assertEqual(self.parser.get_argument(\"name\"), \"John\")\n self.assertEqual(self.parser.get_argument(\"age\"), 25)\n\n # switches options\n def test_parse_arguments_2(self):\n command_str = \"script --verbose -d\"\n self.parser.add_argument(\"verbose\", arg_type=bool)\n self.parser.add_argument(\"d\", arg_type=bool)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertTrue(result)\n self.assertIsNone(missing_args)\n self.assertEqual(self.parser.get_argument(\"verbose\"), True)\n self.assertEqual(self.parser.get_argument(\"d\"), True)\n\n # miss required\n def test_parse_arguments_3(self):\n command_str = \"script --name=John\"\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=True, arg_type=int)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertFalse(result)\n self.assertEqual(missing_args, {\"age\"})\n\n def test_parse_arguments_4(self):\n command_str = \"script --name=John\"\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertTrue(result)\n self.assertEqual(missing_args, None)\n\n def test_parse_arguments_5(self):\n command_str = \"script --name=John\"\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", arg_type=int)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertTrue(result)\n self.assertEqual(missing_args, None)", "solution_code": "def parse_arguments(self, command_string):\n args = command_string.split()[1:]\n for i in range(len(args)):\n arg = args[i]\n if arg.startswith('--'):\n key_value = arg[2:].split('=')\n if len(key_value) == 2:\n self.arguments[key_value[0]] = self._convert_type(key_value[0], key_value[1])\n else:\n self.arguments[key_value[0]] = True\n elif arg.startswith('-'):\n key = arg[1:]\n if i + 1 < len(args) and not args[i + 1].startswith('-'):\n self.arguments[key] = self._convert_type(key, args[i + 1])\n else:\n self.arguments[key] = True\n missing_args = self.required - set(self.arguments.keys())\n if missing_args:\n return False, missing_args\n\n return True, None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.arguments", "self.required" ], "method_dependencies": [ "_convert_type" ] } }, { "method_name": "get_argument", "method_description": "def get_argument(self, key):\n \"\"\"\n Retrieves the value of the specified argument from the arguments dictionary and returns it.\n :param key: str, argument name\n :return: The value of the argument, or None if the argument does not exist.\n >>> parser.arguments\n {'arg1': 'value1', 'arg2': 'value2', 'option1': True, 'option2': True}\n >>> parser.get_argument('arg2')\n 'value2'\n \"\"\"", "test_class": "ArgumentParserTestGetArgument", "test_code": "class ArgumentParserTestGetArgument(unittest.TestCase):\n\n def setUp(self):\n self.parser = ArgumentParser()\n\n # key exists\n def test_get_argument_1(self):\n self.parser.arguments = {\"name\": \"John\"}\n result = self.parser.get_argument(\"name\")\n self.assertEqual(result, \"John\")\n\n # key not exists\n def test_get_argument_2(self):\n self.parser.arguments = {\"name\": \"John\", \"age\": 25}\n result = self.parser.get_argument(\"age\")\n self.assertEqual(result, 25)\n\n def test_get_argument_3(self):\n self.parser.arguments = {\"name\": \"John\", \"age\": \"25\", \"verbose\": True}\n result = self.parser.get_argument(\"verbose\")\n self.assertEqual(result, True)\n\n def test_get_argument_4(self):\n self.parser.arguments = {\"name\": \"Amy\", \"age\": 25, \"verbose\": True, \"d\": True}\n result = self.parser.get_argument(\"d\")\n self.assertEqual(result, True)\n\n def test_get_argument_5(self):\n self.parser.arguments = {\"name\": \"John\", \"age\": 25, \"verbose\": True, \"d\": True, \"option\": \"value\"}\n result = self.parser.get_argument(\"option\")\n self.assertEqual(result, \"value\")", "solution_code": "def get_argument(self, key):\n return self.arguments.get(key)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.arguments" ], "method_dependencies": [] } }, { "method_name": "add_argument", "method_description": "def add_argument(self, arg, required=False, arg_type=str):\n \"\"\"\n Adds an argument to self.types and self.required.\n Check if it is a required argument and store the argument type.\n If the argument is set as required, it wull be added to the required set.\n The argument type and name are stored in the types dictionary as key-value pairs.\n :param arg: str, argument name\n :param required: bool, whether the argument is required, default is False\n :param arg_type:str, Argument type, default is str\n >>> parser.add_argument('arg1', True, 'int')\n >>> parser.required\n {'arg1'}\n >>> parser.types\n {'arg1': 'int'}\n \"\"\"", "test_class": "ArgumentParserTestAddArgument", "test_code": "class ArgumentParserTestAddArgument(unittest.TestCase):\n\n def setUp(self):\n self.parser = ArgumentParser()\n\n def test_add_argument(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=True, arg_type=int)\n\n self.assertEqual(self.parser.required, {\"age\"})\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int})\n\n def test_add_argument_2(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n self.parser.add_argument(\"verbose\", arg_type=bool)\n\n self.assertEqual(self.parser.required, set())\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int, \"verbose\": bool})\n\n def test_add_argument_3(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n self.parser.add_argument(\"verbose\", arg_type=bool)\n self.parser.add_argument(\"d\")\n\n self.assertEqual(self.parser.required, set())\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int, \"verbose\": bool, \"d\": str})\n\n def test_add_argument_4(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n self.parser.add_argument(\"verbose\", arg_type=bool)\n self.parser.add_argument(\"d\")\n self.parser.add_argument(\"option\")\n\n self.assertEqual(self.parser.required, set())\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int, \"verbose\": bool, \"d\": str, \"option\": str})\n\n def test_add_argument_5(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n self.parser.add_argument(\"verbose\", arg_type=bool)\n self.parser.add_argument(\"d\")\n self.parser.add_argument(\"option\")\n self.parser.add_argument(\"option2\", arg_type=bool)\n\n self.assertEqual(self.parser.required, set())\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int, \"verbose\": bool, \"d\": str, \"option\": str, \"option2\": bool})", "solution_code": "def add_argument(self, arg, required=False, arg_type=str):\n if required:\n self.required.add(arg)\n self.types[arg] = arg_type", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.required", "self.types" ], "method_dependencies": [] } }, { "method_name": "_convert_type", "method_description": "def _convert_type(self, arg, value):\n \"\"\"\n Try to convert the type of input value by searching in self.types.\n :param value: str, the input value in command line\n :return: return corresponding value in self.types if convert successfully, or the input value oherwise\n >>> parser.types\n {'arg1': int}\n >>> parser._convert_type('arg1', '21')\n 21\n \"\"\"", "test_class": "ArgumentParserTestConvertType", "test_code": "class ArgumentParserTestConvertType(unittest.TestCase):\n\n def setUp(self):\n self.parser = ArgumentParser()\n\n def test_convert_type_1(self):\n self.parser.types = {\"age\": int}\n result = self.parser._convert_type(\"age\", \"25\")\n self.assertEqual(result, 25)\n\n # fail\n def test_convert_type_2(self):\n self.parser.types = {\"age\": int}\n result = self.parser._convert_type(\"age\", \"twenty-five\")\n self.assertEqual(result, \"twenty-five\")\n\n def test_convert_type_3(self):\n self.parser.types = {\"age\": int}\n result = self.parser._convert_type(\"age\", \"25\")\n self.assertEqual(result, 25)\n\n def test_convert_type_4(self):\n self.parser.types = {\"age\": int, \"verbose\": bool}\n result = self.parser._convert_type(\"verbose\", \"True\")\n self.assertEqual(result, True)\n \n def test_convert_type_5(self):\n self.parser.types = {\"age\": int, \"verbose\": bool}\n result = self.parser._convert_type(\"verbose\", \"False\")\n self.assertEqual(result, True)", "solution_code": "def _convert_type(self, arg, value):\n try:\n return self.types[arg](value)\n except (ValueError, KeyError):\n return value", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.types" ], "method_dependencies": [] } } ]

[ "ArgumentParserTestParseArguments", "ArgumentParserTestGetArgument", "ArgumentParserTestAddArgument", "ArgumentParserTestConvertType", "ArgumentParserTestMain" ]

[ "self.arguments", "self.required", "self.types" ]

[ "import itertools" ]

[ { "method_name": "count", "method_description": "def count(n, m=None):\n \"\"\"\n Counts the number of arrangements by choosing m items from n items (permutations).\n If m is not provided or n equals m, returns factorial(n).\n :param n: int, the total number of items.\n :param m: int, the number of items to be chosen (default=None).\n :return: int, the count of arrangements.\n >>> ArrangementCalculator.count(5, 3)\n 60\n\n \"\"\"", "test_class": "ArrangementCalculatorTestCount", "test_code": "class ArrangementCalculatorTestCount(unittest.TestCase):\n def test_count_1(self):\n res = ArrangementCalculator.count(5, 3)\n self.assertEqual(res, 60)\n\n def test_count_2(self):\n res = ArrangementCalculator.count(4, 3)\n self.assertEqual(res, 24)\n\n def test_count_3(self):\n res = ArrangementCalculator.count(6, 3)\n self.assertEqual(res, 120)\n\n def test_count_4(self):\n res = ArrangementCalculator.count(7, 3)\n self.assertEqual(res, 210)\n\n def test_count_5(self):\n res = ArrangementCalculator.count(4, 4)\n self.assertEqual(res, 24)", "solution_code": "def count(n, m=None):\n if m is None or n == m:\n return ArrangementCalculator.factorial(n)\n else:\n return ArrangementCalculator.factorial(n) // ArrangementCalculator.factorial(n - m)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "factorial" ] } }, { "method_name": "count_all", "method_description": "@staticmethod\n def count_all(n):\n \"\"\"\n Counts the total number of all possible arrangements by choosing at least 1 item and at most n items from n items.\n :param n: int, the total number of items.\n :return: int, the count of all arrangements.\n >>> ArrangementCalculator.count_all(4)\n 64\n\n \"\"\"", "test_class": "ArrangementCalculatorTestCountAll", "test_code": "class ArrangementCalculatorTestCountAll(unittest.TestCase):\n def test_count_all_1(self):\n res = ArrangementCalculator.count_all(4)\n self.assertEqual(res, 64)\n\n def test_count_all_2(self):\n res = ArrangementCalculator.count_all(1)\n self.assertEqual(res, 1)\n\n def test_count_all_3(self):\n res = ArrangementCalculator.count_all(2)\n self.assertEqual(res, 4)\n\n def test_count_all_4(self):\n res = ArrangementCalculator.count_all(3)\n self.assertEqual(res, 15)\n\n def test_count_all_5(self):\n res = ArrangementCalculator.count_all(5)\n self.assertEqual(res, 325)", "solution_code": "@staticmethod\n def count_all(n):\n total = 0\n for i in range(1, n + 1):\n total += ArrangementCalculator.count(n, i)\n return total", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "count" ] } }, { "method_name": "select", "method_description": "def select(self, m=None):\n \"\"\"\n Generates a list of arrangements by selecting m items from the internal datas.\n If m is not provided, selects all items.\n :param m: int, the number of items to be chosen (default=None).\n :return: List, a list of arrangements.\n >>> ac = ArrangementCalculator([1, 2, 3, 4])\n >>> ac.select(2)\n [[1, 2], [1, 3], [1, 4], [2, 1], [2, 3], [2, 4], [3, 1], [3, 2], [3, 4], [4, 1], [4, 2], [4, 3]]\n\n \"\"\"", "test_class": "ArrangementCalculatorTestSelect", "test_code": "class ArrangementCalculatorTestSelect(unittest.TestCase):\n def test_select_1(self):\n ac = ArrangementCalculator([1, 2, 3, 4])\n res = ac.select(2)\n expected = [[1, 2], [1, 3], [1, 4], [2, 1], [2, 3], [2, 4], [3, 1], [3, 2], [3, 4], [4, 1], [4, 2], [4, 3]]\n self.assertEqual(res, expected)\n\n def test_select_2(self):\n ac = ArrangementCalculator([1, 2, 3])\n res = ac.select(2)\n expected = [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]\n self.assertEqual(res, expected)\n\n def test_select_3(self):\n ac = ArrangementCalculator([2, 3, 4])\n res = ac.select(2)\n expected = [[2, 3], [2, 4], [3, 2], [3, 4], [4, 2], [4, 3]]\n self.assertEqual(res, expected)\n\n def test_select_4(self):\n ac = ArrangementCalculator([1, 2])\n res = ac.select(2)\n expected = [[1, 2], [2, 1]]\n self.assertEqual(res, expected)\n\n def test_select_5(self):\n ac = ArrangementCalculator([1, 2, 3, 4])\n res = ac.select(1)\n expected = [[1], [2], [3], [4]]\n self.assertEqual(res, expected)\n\n def test_select_6(self):\n ac = ArrangementCalculator([1, 2])\n res = ac.select()\n expected = [[1, 2], [2, 1]]\n self.assertEqual(res, expected)", "solution_code": "def select(self, m=None):\n if m is None:\n m = len(self.datas)\n result = []\n for permutation in itertools.permutations(self.datas, m):\n result.append(list(permutation))\n return result", "dependencies": { "Standalone": false, "lib_dependencies": [ "itertools" ], "field_dependencies": [ "self.datas" ], "method_dependencies": [] } }, { "method_name": "select_all", "method_description": "def select_all(self):\n \"\"\"\n Generates a list of all arrangements by selecting at least 1 item and at most the number of internal datas.\n :return: List, a list of all arrangements.\n >>> ac = ArrangementCalculator([1, 2, 3])\n >>> ac.select_all()\n [[1], [2], [3], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2], [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]\n\n \"\"\"", "test_class": "ArrangementCalculatorTestSelectAll", "test_code": "class ArrangementCalculatorTestSelectAll(unittest.TestCase):\n def test_select_all_1(self):\n ac = ArrangementCalculator([1, 2, 3])\n res = ac.select_all()\n expected = [[1], [2], [3], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2], [1, 2, 3], [1, 3, 2], [2, 1, 3],\n [2, 3, 1], [3, 1, 2], [3, 2, 1]]\n self.assertEqual(res, expected)\n\n def test_select_all_2(self):\n ac = ArrangementCalculator([1, 2, 4])\n res = ac.select_all()\n expected = [[1], [2], [4], [1, 2], [1, 4], [2, 1], [2, 4], [4, 1], [4, 2], [1, 2, 4], [1, 4, 2], [2, 1, 4],\n [2, 4, 1], [4, 1, 2], [4, 2, 1]]\n self.assertEqual(res, expected)\n\n def test_select_all_3(self):\n ac = ArrangementCalculator([1, 2])\n res = ac.select_all()\n expected = [[1], [2], [1, 2], [2, 1]]\n self.assertEqual(res, expected)\n\n def test_select_all_4(self):\n ac = ArrangementCalculator([1, 3])\n res = ac.select_all()\n expected = [[1], [3], [1, 3], [3, 1]]\n self.assertEqual(res, expected)\n\n def test_select_all_5(self):\n ac = ArrangementCalculator([1])\n res = ac.select_all()\n expected = [[1]]\n self.assertEqual(res, expected)", "solution_code": "def select_all(self):\n result = []\n for i in range(1, len(self.datas) + 1):\n result.extend(self.select(i))\n return result", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.datas" ], "method_dependencies": [ "select" ] } }, { "method_name": "factorial", "method_description": "@staticmethod\n def factorial(n):\n \"\"\"\n Calculates the factorial of a given number.\n :param n: int, the number to calculate the factorial.\n :return: int, the factorial of the given number.\n >>> ArrangementCalculator.factorial(4)\n 24\n\n \"\"\"", "test_class": "ArrangementCalculatorTestFactorial", "test_code": "class ArrangementCalculatorTestFactorial(unittest.TestCase):\n def test_factorial_1(self):\n res = ArrangementCalculator.factorial(4)\n self.assertEqual(res, 24)\n\n def test_factorial_2(self):\n res = ArrangementCalculator.factorial(5)\n self.assertEqual(res, 120)\n\n def test_factorial_3(self):\n res = ArrangementCalculator.factorial(3)\n self.assertEqual(res, 6)\n\n def test_factorial_4(self):\n res = ArrangementCalculator.factorial(2)\n self.assertEqual(res, 2)\n\n def test_factorial_5(self):\n res = ArrangementCalculator.factorial(1)\n self.assertEqual(res, 1)", "solution_code": "@staticmethod\n def factorial(n):\n result = 1\n for i in range(2, n + 1):\n result *= i\n return result", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "ArrangementCalculatorTestCount", "ArrangementCalculatorTestCountAll", "ArrangementCalculatorTestSelect", "ArrangementCalculatorTestSelectAll", "ArrangementCalculatorTestFactorial", "ArrangementCalculatorTest" ]

[ "self.datas" ]

[]

[ { "method_name": "add_student", "method_description": "def add_student(self, name, grade, major):\n \"\"\"\n Add a new student into self.students dict\n :param name: str, student name\n :param grade: int, student grade\n :param major: str, student major\n >>> system.add_student('student 1', 3, 'SE')\n >>> system.students\n {'student 1': {'name': 'student 1', 'grade': 3, 'major': 'SE', 'courses': {}}}\n \"\"\"", "test_class": "AssessmentSystemTestAddStudent", "test_code": "class AssessmentSystemTestAddStudent(unittest.TestCase):\n def test_add_student(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n self.assertEqual(assessment_system.students[\"Alice\"],\n {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}})\n\n def test_add_student_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n assessment_system.add_student(\"Bob\", 2, \"Science\")\n self.assertEqual(assessment_system.students,\n {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}},\n 'Bob': {'name': 'Bob', 'grade': 2, 'major': 'Science', 'courses': {}}})\n\n def test_add_student_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n assessment_system.add_student(\"Bob\", 2, \"Science\")\n assessment_system.add_student(\"Charlie\", 4, \"Chemistry\")\n self.assertEqual(assessment_system.students,\n {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}},\n 'Bob': {'name': 'Bob', 'grade': 2, 'major': 'Science', 'courses': {}},\n 'Charlie': {'name': 'Charlie', 'grade': 4, 'major': 'Chemistry', 'courses': {}}})\n\n def test_add_student_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n assessment_system.add_student(\"Bob\", 2, \"Science\")\n assessment_system.add_student(\"Charlie\", 4, \"Chemistry\")\n assessment_system.add_student(\"David\", 1, \"Physics\")\n self.assertEqual(assessment_system.students,\n {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}},\n 'Bob': {'name': 'Bob', 'grade': 2, 'major': 'Science', 'courses': {}},\n 'Charlie': {'name': 'Charlie', 'grade': 4, 'major': 'Chemistry', 'courses': {}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {}}})\n\n def test_add_student_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n assessment_system.add_student(\"Bob\", 2, \"Science\")\n assessment_system.add_student(\"Charlie\", 4, \"Chemistry\")\n assessment_system.add_student(\"David\", 1, \"Physics\")\n assessment_system.add_student(\"Eve\", 3, \"Mathematics\")\n self.assertEqual(assessment_system.students,\n {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}},\n 'Bob': {'name': 'Bob', 'grade': 2, 'major': 'Science', 'courses': {}},\n 'Charlie': {'name': 'Charlie', 'grade': 4, 'major': 'Chemistry', 'courses': {}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {}},\n 'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {}}})", "solution_code": "def add_student(self, name, grade, major):\n self.students[name] = {'name': name, 'grade': grade, 'major': major, 'courses': {}}", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [] } }, { "method_name": "add_course_score", "method_description": "def add_course_score(self, name, course, score):\n \"\"\"\n Add score of specific course for student in self.students\n :param name: str, student name\n :param cource: str, cource name\n :param score: int, cource score\n >>> system.add_student('student 1', 3, 'SE')\n >>> system.add_course_score('student 1', 'math', 94)\n >>> system.students\n {'student 1': {'name': 'student 1', 'grade': 3, 'major': 'SE', 'courses': {'math': 94}}}\n \"\"\"", "test_class": "AssessmentSystemTestAddCourseScore", "test_code": "class AssessmentSystemTestAddCourseScore(unittest.TestCase):\n def test_add_course_score(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {\"Alice\": {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}}\n assessment_system.add_course_score(\"Alice\", \"Math\", 90)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 90)\n\n def test_add_course_score_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.students[\"Alice\"] = {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}\n assessment_system.add_course_score(\"Alice\", \"Math\", 90)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 90)\n\n def test_add_course_score_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students[\"Alice\"] = {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}\n assessment_system.add_course_score(\"Alice\", \"Math\", 90)\n assessment_system.add_course_score(\"Alice\", \"Science\", 80)\n assessment_system.add_course_score(\"Alice\", \"Math\", 95)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 95)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Science\"], 80)\n\n def test_add_course_score_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students[\"Alice\"] = {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}\n assessment_system.add_course_score(\"Alice\", \"Math\", 90)\n assessment_system.add_course_score(\"Alice\", \"Science\", 80)\n assessment_system.add_course_score(\"Alice\", \"Math\", 95)\n assessment_system.add_course_score(\"Alice\", \"Science\", 85)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 95)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Science\"], 85)\n\n def test_add_course_score_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students[\"Alice\"] = {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}\n assessment_system.add_course_score(\"Bob\", \"Math\", 90)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"], {})", "solution_code": "def add_course_score(self, name, course, score):\n if name in self.students:\n self.students[name]['courses'][course] = score", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [] } }, { "method_name": "get_gpa", "method_description": "def get_gpa(self, name):\n \"\"\"\n Get average grade of one student.\n :param name: str, student name\n :return: if name is in students and this students have courses grade, return average grade(float)\n or None otherwise\n >>> system.add_student('student 1', 3, 'SE')\n >>> system.add_course_score('student 1', 'math', 94)\n >>> system.add_course_score('student 1', 'Computer Network', 92)\n >>> system.get_gpa('student 1')\n 93.0\n\n \"\"\"", "test_class": "AssessmentSystemTestGetGPA", "test_code": "class AssessmentSystemTestGetGPA(unittest.TestCase):\n def test_get_gpa_1(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}}}\n self.assertEqual(assessment_system.get_gpa(\"Alice\"), 85.0)\n\n\n # No such student\n def test_get_gpa_2(self):\n assessment_system = AssessmentSystem()\n self.assertEqual(assessment_system.get_gpa('Alice'), None)\n\n # student don't have any scores\n def test_get_gpa_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}}\n self.assertEqual(assessment_system.get_gpa('Alice'), None)\n\n def test_get_gpa_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_gpa('Bob'), None)\n\n def test_get_gpa_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_gpa('Alice'), 90.0)", "solution_code": "def get_gpa(self, name):\n if name in self.students and self.students[name]['courses']:\n return sum(self.students[name]['courses'].values()) / len(self.students[name]['courses'])\n else:\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [] } }, { "method_name": "get_all_students_with_fail_course", "method_description": "def get_all_students_with_fail_course(self):\n \"\"\"\n Get all students who have any score blow 60\n :return: list of str ,student name\n >>> system.add_course_score('student 1', 'Society', 59)\n >>> system.get_all_students_with_fail_course()\n ['student 1']\n \"\"\"", "test_class": "AssessmentSystemTestGetAllStudentsWithFailCourse", "test_code": "class AssessmentSystemTestGetAllStudentsWithFailCourse(unittest.TestCase):\n def test_get_all_students_with_fail_course(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 50}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {'Physics': 60}},\n 'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), ['Bob'])\n\n def test_get_all_students_with_fail_course_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 70}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {'Physics': 70}},\n 'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), [])\n\n def test_get_all_students_with_fail_course_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), [])\n\n def test_get_all_students_with_fail_course_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), [])\n\n def test_get_all_students_with_fail_course_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 50}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 50}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {'Physics': 70}},\n 'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), ['Alice', 'Bob'])", "solution_code": "def get_all_students_with_fail_course(self):\n students = []\n for name, student in self.students.items():\n for course, score in student['courses'].items():\n if score < 60:\n students.append(name)\n break\n return students", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [] } }, { "method_name": "get_course_average", "method_description": "def get_course_average(self, course):\n \"\"\"\n Get the average score of a specific course.\n :param course: str, course name\n :return: float, average scores of this course if anyone have score of this course, or None if nobody have records.\n \"\"\"", "test_class": "AssessmentSystemTestGetCourseAverage", "test_code": "class AssessmentSystemTestGetCourseAverage(unittest.TestCase):\n\n def test_get_course_average_1(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 90}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70,'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_course_average(\"Physics\"), 85.0)\n\n def test_get_course_average_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70,'Physics': None }}\n }\n self.assertEqual(assessment_system.get_course_average('Physics'), 85)\n\n def test_get_course_average_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_course_average('Computer'), None)\n\n def test_get_course_average_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {}\n self.assertEqual(assessment_system.get_course_average('Computer'), None)\n\n def test_get_course_average_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_course_average('Mathematics'), 90)", "solution_code": "def get_course_average(self, course):\n total = 0\n count = 0\n for student in self.students.values():\n if course in student['courses']:\n score = student['courses'][course]\n if score is not None:\n total += score\n count += 1\n return total / count if count > 0 else None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [] } }, { "method_name": "get_top_student", "method_description": "def get_top_student(self):\n \"\"\"\n Calculate every student's gpa with get_gpa method, and find the student with highest gpa\n :return: str, name of student whose gpa is highest\n >>> system.add_student('student 1', 3, 'SE')\n >>> system.add_student('student 2', 2, 'SE')\n >>> system.add_course_score('student 1', 'Computer Network', 92)\n >>> system.add_course_score('student 2', 'Computer Network', 97)\n >>> system.get_top_student()\n 'student 2'\n \"\"\"", "test_class": "AssessmentSystemTestGetTopStudent", "test_code": "class AssessmentSystemTestGetTopStudent(unittest.TestCase):\n def test_get_top_student(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}}\n }\n self.assertEqual(assessment_system.get_top_student(), \"Alice\")\n\n def test_get_top_student_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': { }},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_top_student(), \"Bob\")\n\n def test_get_top_student_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {}\n self.assertEqual(assessment_system.get_top_student(), None)\n\n def test_get_top_student_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 60}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_top_student(), \"Bob\")\n\n def test_get_top_student_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 60}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}},\n 'David': {'name': 'David', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_top_student(), \"Bob\")", "solution_code": "def get_top_student(self):\n top_student = None\n top_gpa = 0\n for name, student in self.students.items():\n gpa = self.get_gpa(name)\n if gpa is not None and gpa > top_gpa:\n top_gpa = gpa\n top_student = name\n return top_student", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [ "get_gpa" ] } } ]

[ "AssessmentSystemTestAddStudent", "AssessmentSystemTestAddCourseScore", "AssessmentSystemTestGetGPA", "AssessmentSystemTestGetAllStudentsWithFailCourse", "AssessmentSystemTestGetCourseAverage", "AssessmentSystemTestGetTopStudent", "AssessmentSystemTestMain" ]

[ "self.students" ]

[]

[ { "method_name": "interpret", "method_description": "def interpret(self, display=False):\n \"\"\"\n Interpret the music score to be played\n :param display:Bool, representing whether to print the interpreted score\n :return: list of dict, The dict includes two fields, Chord and Tune, which are letters and numbers, respectively. If the input is empty or contains only whitespace, an empty list is returned.\n >>> context = AutomaticGuitarSimulator(\"C53231323 Em43231323 F43231323 G63231323\")\n >>> play_list = context.interpret(display = False)\n [{'Chord': 'C', 'Tune': '53231323'}, {'Chord': 'Em', 'Tune': '43231323'}, {'Chord': 'F', 'Tune': '43231323'}, {'Chord': 'G', 'Tune': '63231323'}]\n\n \"\"\"", "test_class": "AutomaticGuitarSimulatorTestInterpret", "test_code": "class AutomaticGuitarSimulatorTestInterpret(unittest.TestCase):\n def test_interpret_1(self):\n context = AutomaticGuitarSimulator(\"C53231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'C', 'Tune': '53231323'}])\n\n def test_interpret_2(self):\n context = AutomaticGuitarSimulator(\"F43231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'F', 'Tune': '43231323'}])\n\n def test_interpret_3(self):\n context = AutomaticGuitarSimulator(\"Em43231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'Em', 'Tune': '43231323'}])\n\n def test_interpret_4(self):\n context = AutomaticGuitarSimulator(\"G63231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'G', 'Tune': '63231323'}])\n\n def test_interpret_5(self):\n context = AutomaticGuitarSimulator(\"F43231323 G63231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'F', 'Tune': '43231323'}, {'Chord': 'G', 'Tune': '63231323'}])\n\n def test_interpret_6(self):\n context = AutomaticGuitarSimulator(\" \")\n play_list = context.interpret()\n self.assertEqual(play_list, [])\n\n def test_interpret_7(self):\n context = AutomaticGuitarSimulator(\"ABC43231323 DEF63231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'ABC', 'Tune': '43231323'}, {'Chord': 'DEF', 'Tune': '63231323'}])\n\n def test_interpret_8(self):\n context = AutomaticGuitarSimulator(\"C53231323\")\n play_list = context.interpret(display=True)\n self.assertEqual(play_list, [{'Chord': 'C', 'Tune': '53231323'}])\n\n def test_interpret_9(self):\n context = AutomaticGuitarSimulator(\"\")\n play_list = context.interpret()\n self.assertEqual(play_list, [])\n", "solution_code": "def interpret(self, display=False):\n if not self.play_text.strip():\n return []\n else:\n play_list = []\n play_segs = self.play_text.split(\" \")\n for play_seg in play_segs:\n pos = 0\n for ele in play_seg:\n if ele.isalpha():\n pos += 1\n continue\n break\n play_chord = play_seg[0:pos]\n play_value = play_seg[pos:]\n play_list.append({'Chord': play_chord, 'Tune': play_value})\n if display:\n self.display(play_chord, play_value)\n return play_list", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.play_text" ], "method_dependencies": [ "display" ] } }, { "method_name": "display", "method_description": "def display(self, key, value):\n \"\"\"\n Print out chord and play tune with following format: Normal Guitar Playing -- Chord: %s, Play Tune: %s\n :param key:str, chord\n :param value:str, play tune\n :return: str\n >>> context = AutomaticGuitarSimulator(\"C53231323 Em43231323 F43231323 G63231323\")\n >>> context.display(\"C\", \"53231323\")\n Normal Guitar Playing -- Chord: C, Play Tune: 53231323\n\n \"\"\"", "test_class": "AutomaticGuitarSimulatorTestDisplay", "test_code": "class AutomaticGuitarSimulatorTestDisplay(unittest.TestCase):\n def test_display_1(self):\n context = AutomaticGuitarSimulator(\"C53231323 Em43231323\")\n play_list = context.interpret()\n str = context.display(play_list[0]['Chord'], play_list[0]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: C, Play Tune: 53231323\")\n\n def test_display_2(self):\n context = AutomaticGuitarSimulator(\"C53231323 Em43231323\")\n play_list = context.interpret()\n str = context.display(play_list[1]['Chord'], play_list[1]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: Em, Play Tune: 43231323\")\n\n def test_display_3(self):\n context = AutomaticGuitarSimulator(\"F43231323 G63231323\")\n play_list = context.interpret()\n str = context.display(play_list[0]['Chord'], play_list[0]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: F, Play Tune: 43231323\")\n\n def test_display_4(self):\n context = AutomaticGuitarSimulator(\"F43231323 G63231323\")\n play_list = context.interpret()\n str = context.display(play_list[1]['Chord'], play_list[1]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: G, Play Tune: 63231323\")\n\n def test_display_5(self):\n context = AutomaticGuitarSimulator(\"\")\n str = context.display('', '')\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: , Play Tune: \")", "solution_code": "def display(self, key, value):\n return \"Normal Guitar Playing -- Chord: %s, Play Tune: %s\" % (key, value)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "AutomaticGuitarSimulatorTestInterpret", "AutomaticGuitarSimulatorTestDisplay", "AutomaticGuitarSimulatorTest" ]

[ "self.play_text" ]

[]

[ { "method_name": "setNum", "method_description": "def setNum(self):\n \"\"\"\n Calculate the size of each block and the remainder of the division.\n :return: the size of each block and the remainder of the division, tuple.\n >>> a = AvgPartition([1, 2, 3, 4], 2)\n >>> a.setNum()\n (2, 0)\n\n \"\"\"", "test_class": "AvgPartitionTestSetNum", "test_code": "class AvgPartitionTestSetNum(unittest.TestCase):\n def test_setNum(self):\n a = AvgPartition([1, 2, 3, 4], 2)\n self.assertEqual(a.setNum(), (2, 0))\n\n def test_setNum_2(self):\n a = AvgPartition([1, 2, 3, 4, 5], 2)\n self.assertEqual(a.setNum(), (2, 1))\n\n def test_setNum_3(self):\n a = AvgPartition([1, 2, 3, 4, 5], 3)\n self.assertEqual(a.setNum(), (1, 2))\n\n def test_setNum_4(self):\n a = AvgPartition([1, 2, 3, 4, 5], 4)\n self.assertEqual(a.setNum(), (1, 1))\n\n def test_setNum_5(self):\n a = AvgPartition([1, 2, 3, 4, 5], 5)\n self.assertEqual(a.setNum(), (1, 0))", "solution_code": "def setNum(self):\n size = len(self.lst) // self.limit\n remainder = len(self.lst) % self.limit\n return size, remainder", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.limit", "self.lst" ], "method_dependencies": [] } }, { "method_name": "get", "method_description": "def get(self, index):\n \"\"\"\n calculate the size of each block and the remainder of the division, and calculate the corresponding start and end positions based on the index of the partition.\n :param index: the index of the partition,int.\n :return: the corresponding block, list.\n >>> a = AvgPartition([1, 2, 3, 4], 2)\n >>> a.get(0)\n [1, 2]\n\n \"\"\"", "test_class": "AvgPartitionTestGet", "test_code": "class AvgPartitionTestGet(unittest.TestCase):\n\n def test_get(self):\n a = AvgPartition([1, 2, 3, 4], 2)\n self.assertEqual(a.get(0), [1, 2])\n\n def test_get_2(self):\n a = AvgPartition([1, 2, 3, 4], 2)\n self.assertEqual(a.get(1), [3, 4])\n\n def test_get_3(self):\n a = AvgPartition([1, 2, 3, 4, 5], 2)\n self.assertEqual(a.get(0), [1, 2, 3])\n\n def test_get_4(self):\n a = AvgPartition([1, 2, 3, 4, 5], 2)\n self.assertEqual(a.get(1), [4, 5])\n\n def test_get_5(self):\n a = AvgPartition([1, 2, 3, 4, 5], 3)\n self.assertEqual(a.get(0), [1, 2])", "solution_code": "def get(self, index):\n size, remainder = self.setNum()\n start = index * size + min(index, remainder)\n end = start + size\n if index + 1 <= remainder:\n end += 1\n return self.lst[start:end]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.lst" ], "method_dependencies": [ "setNum" ] } } ]

[ "AvgPartitionTestSetNum", "AvgPartitionTestGet", "AvgPartitionTestMain" ]

[ "self.limit", "self.lst" ]

[]

[ { "method_name": "clear_expr", "method_description": "def clear_expr(self):\n \"\"\"\n Clears the expression of all characters that are not brackets.\n >>> b = BalancedBrackets(\"a(b)c\")\n >>> b.clear_expr()\n >>> b.expr\n '()'\n\n \"\"\"", "test_class": "BalancedBracketsTestClearExpr", "test_code": "class BalancedBracketsTestClearExpr(unittest.TestCase):\n def test_clear_expr(self):\n b = BalancedBrackets(\"a(b)c\")\n b.clear_expr()\n self.assertEqual(b.expr, \"()\")\n\n def test_clear_expr_2(self):\n b = BalancedBrackets(\"a(b){c}\")\n b.clear_expr()\n self.assertEqual(b.expr, \"(){}\")\n\n def test_clear_expr_3(self):\n b = BalancedBrackets(\"[a](b){c}\")\n b.clear_expr()\n self.assertEqual(b.expr, \"[](){}\")\n\n def test_clear_expr_4(self):\n b = BalancedBrackets(\"[a(b){c}\")\n b.clear_expr()\n self.assertEqual(b.expr, \"[(){}\")\n\n def test_clear_expr_5(self):\n b = BalancedBrackets(\"a(b){c}]\")\n b.clear_expr()\n self.assertEqual(b.expr, \"(){}]\")", "solution_code": "def clear_expr(self):\n self.expr = ''.join(c for c in self.expr if (c in self.left_brackets or c in self.right_brackets))", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.expr", "self.left_brackets", "self.right_brackets" ], "method_dependencies": [] } }, { "method_name": "check_balanced_brackets", "method_description": "def check_balanced_brackets(self):\n \"\"\"\n Checks if the expression has balanced brackets.\n :return: True if the expression has balanced brackets, False otherwise.\n >>> b = BalancedBrackets(\"a(b)c\")\n >>> b.check_balanced_brackets()\n True\n\n \"\"\"", "test_class": "BalancedBracketsTestCheckBalancedBrackets", "test_code": "class BalancedBracketsTestCheckBalancedBrackets(unittest.TestCase):\n def test_check_balanced_brackets(self):\n b = BalancedBrackets(\"a(b)c\")\n self.assertEqual(b.check_balanced_brackets(), True)\n\n def test_check_balanced_brackets_2(self):\n b = BalancedBrackets(\"a(b){c}\")\n self.assertEqual(b.check_balanced_brackets(), True)\n\n def test_check_balanced_brackets_3(self):\n b = BalancedBrackets(\"[a](b){c}\")\n self.assertEqual(b.check_balanced_brackets(), True)\n\n def test_check_balanced_brackets_4(self):\n b = BalancedBrackets(\"[a(b){c}\")\n self.assertEqual(b.check_balanced_brackets(), False)\n\n def test_check_balanced_brackets_5(self):\n b = BalancedBrackets(\"a(b{c}]\")\n self.assertEqual(b.check_balanced_brackets(), False)\n\n def test_check_balanced_brackets_6(self):\n b = BalancedBrackets(\"a(b{c]]\")\n self.assertEqual(b.check_balanced_brackets(), False)\n\n def test_check_balanced_brackets_7(self):\n b = BalancedBrackets(\"[a)(b){c}\")\n self.assertEqual(b.check_balanced_brackets(), False)", "solution_code": "def check_balanced_brackets(self):\n self.clear_expr()\n for Brkt in self.expr:\n if Brkt in self.left_brackets:\n self.stack.append(Brkt)\n else:\n Current_Brkt = self.stack.pop()\n if Current_Brkt == \"(\":\n if Brkt != \")\":\n return False\n if Current_Brkt == \"{\":\n if Brkt != \"}\":\n return False\n if Current_Brkt == \"[\":\n if Brkt != \"]\":\n return False\n if self.stack:\n return False\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.expr", "self.left_brackets", "self.stack" ], "method_dependencies": [ "clear_expr" ] } } ]

[ "BalancedBracketsTestClearExpr", "BalancedBracketsTestCheckBalancedBrackets", "BalancedBracketsTestMain" ]

[ "self.expr", "self.left_brackets", "self.right_brackets", "self.stack" ]

[]

[ { "method_name": "deposit", "method_description": "def deposit(self, amount):\n \"\"\"\n Deposits a certain amount into the account, increasing the account balance, return the current account balance.\n If amount is negative, raise a ValueError(\"Invalid amount\").\n :param amount: int\n \"\"\"", "test_class": "BankAccountTestDeposit", "test_code": "class BankAccountTestDeposit(unittest.TestCase):\n\n def test_deposit(self):\n account1 = BankAccount()\n ret = account1.deposit(1000)\n self.assertEqual(ret, 1000)\n\n def test_deposit_2(self):\n account1 = BankAccount()\n account1.deposit(1000)\n ret = account1.deposit(2000)\n self.assertEqual(ret, 3000)\n\n\n def test_deposit_3(self):\n account1 = BankAccount()\n with self.assertRaises(ValueError) as context:\n account1.deposit(-1000)\n self.assertEqual(str(context.exception), \"Invalid amount\")\n\n def test_deposit_4(self):\n account1 = BankAccount()\n ret = account1.deposit(0)\n self.assertEqual(ret, 0)\n\n def test_deposit_5(self):\n account1 = BankAccount()\n account1.deposit(1000)\n ret = account1.deposit(1000)\n self.assertEqual(ret, 2000)", "solution_code": "def deposit(self, amount):\n if amount < 0:\n raise ValueError(\"Invalid amount\")\n self.balance += amount\n return self.balance", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.balance" ], "method_dependencies": [] } }, { "method_name": "withdraw", "method_description": "def withdraw(self, amount):\n \"\"\"\n Withdraws a certain amount from the account, decreasing the account balance, return the current account balance.\n If amount is negative, raise a ValueError(\"Invalid amount\").\n If the withdrawal amount is greater than the account balance, raise a ValueError(\"Insufficient balance.\").\n :param amount: int\n \"\"\"", "test_class": "BankAccountTestWithdraw", "test_code": "class BankAccountTestWithdraw(unittest.TestCase):\n\n def test_withdraw(self):\n account1 = BankAccount()\n account1.balance = 1000\n ret = account1.withdraw(200)\n self.assertEqual(ret, 800)\n\n def test_withdraw_2(self):\n account1 = BankAccount()\n account1.balance = 500\n with self.assertRaises(ValueError) as context:\n account1.withdraw(1000)\n self.assertEqual(str(context.exception), \"Insufficient balance.\")\n\n def test_withdraw_3(self):\n account1 = BankAccount()\n with self.assertRaises(ValueError) as context:\n account1.withdraw(-1000)\n self.assertEqual(str(context.exception), \"Invalid amount\")\n\n def test_withdraw_4(self):\n account1 = BankAccount()\n account1.balance = 1000\n ret = account1.withdraw(500)\n self.assertEqual(ret, 500)\n\n def test_withdraw_5(self):\n account1 = BankAccount()\n account1.balance = 1000\n ret = account1.withdraw(1000)\n self.assertEqual(ret, 0)", "solution_code": "def withdraw(self, amount):\n if amount < 0:\n raise ValueError(\"Invalid amount\")\n if amount > self.balance:\n raise ValueError(\"Insufficient balance.\")\n self.balance -= amount\n return self.balance", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.balance" ], "method_dependencies": [] } }, { "method_name": "view_balance", "method_description": "def view_balance(self):\n \"\"\"\n Return the account balance.\n \"\"\"", "test_class": "BankAccountTestViewBalance", "test_code": "class BankAccountTestViewBalance(unittest.TestCase):\n\n def test_view_balance(self):\n account1 = BankAccount()\n self.assertEqual(account1.view_balance(), 0)\n\n def test_view_balance_2(self):\n account1 = BankAccount()\n account1.balance = 1000\n self.assertEqual(account1.view_balance(), 1000)\n\n def test_view_balance_3(self):\n account1 = BankAccount()\n account1.balance = 500\n self.assertEqual(account1.view_balance(), 500)\n\n def test_view_balance_4(self):\n account1 = BankAccount()\n account1.balance = 1500\n self.assertEqual(account1.view_balance(), 1500)\n\n def test_view_balance_5(self):\n account1 = BankAccount()\n account1.balance = 2000\n self.assertEqual(account1.view_balance(), 2000)", "solution_code": "def view_balance(self):\n return self.balance", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.balance" ], "method_dependencies": [] } }, { "method_name": "transfer", "method_description": "def transfer(self, other_account, amount):\n \"\"\"\n Transfers a certain amount from the current account to another account.\n :param other_account: BankAccount\n :param amount: int\n >>> account1 = BankAccount()\n >>> account2 = BankAccount()\n >>> account1.deposit(1000)\n >>> account1.transfer(account2, 300)\n account1.balance = 700 account2.balance = 300\n \"\"\"", "test_class": "BankAccountTestTransfer", "test_code": "class BankAccountTestTransfer(unittest.TestCase):\n\n def test_transfer(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 800\n account2.balance = 1000\n account1.transfer(account2, 300)\n self.assertEqual(account1.view_balance(), 500)\n self.assertEqual(account2.view_balance(), 1300)\n\n def test_transfer_2(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 500\n with self.assertRaises(ValueError) as context:\n account1.transfer(account2, 600)\n self.assertEqual(str(context.exception), \"Insufficient balance.\")\n\n def test_transfer_3(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 500\n account2.balance = 1000\n with self.assertRaises(ValueError) as context:\n account1.transfer(account2, -600)\n self.assertEqual(str(context.exception), \"Invalid amount\")\n\n def test_transfer_4(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 500\n account2.balance = 1000\n account1.transfer(account2, 500)\n self.assertEqual(account1.view_balance(), 0)\n self.assertEqual(account2.view_balance(), 1500)\n\n def test_transfer_5(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 500\n account2.balance = 1000\n account1.transfer(account2, 200)\n self.assertEqual(account1.view_balance(), 300)\n self.assertEqual(account2.view_balance(), 1200)", "solution_code": "def transfer(self, other_account, amount):\n self.withdraw(amount)\n other_account.deposit(amount)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "deposit", "withdraw" ] } } ]

[ "BankAccountTestDeposit", "BankAccountTestWithdraw", "BankAccountTestViewBalance", "BankAccountTestTransfer", "BankAccountTest" ]

[ "self.balance" ]

[]

[ { "method_name": "add", "method_description": "def add(num1, num2):\n \"\"\"\n Adds two big numbers.\n :param num1: The first number to add,str.\n :param num2: The second number to add,str.\n :return: The sum of the two numbers,str.\n >>> bigNum = BigNumCalculator()\n >>> bigNum.add(\"12345678901234567890\", \"98765432109876543210\")\n '111111111011111111100'\n\n \"\"\"", "test_class": "BigNumCalculatorTestAdd", "test_code": "class BigNumCalculatorTestAdd(unittest.TestCase):\n def test_add(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"12345678901234567890\", \"98765432109876543210\"), \"111111111011111111100\")\n\n def test_add_2(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"123456789012345678922\", \"98765432109876543210\"), \"222222221122222222132\")\n\n def test_add_3(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"123456789012345678934\", \"98765432109876543210\"), \"222222221122222222144\")\n\n def test_add_4(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"123456789012345678946\", \"98765432109876543210\"), \"222222221122222222156\")\n\n def test_add_5(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"123456789012345678958\", \"98765432109876543210\"), \"222222221122222222168\")", "solution_code": "def add(num1, num2):\n max_length = max(len(num1), len(num2))\n num1 = num1.zfill(max_length)\n num2 = num2.zfill(max_length)\n\n carry = 0\n result = []\n for i in range(max_length - 1, -1, -1):\n digit_sum = int(num1[i]) + int(num2[i]) + carry\n carry = digit_sum // 10\n digit = digit_sum % 10\n result.insert(0, str(digit))\n\n if carry > 0:\n result.insert(0, str(carry))\n\n return ''.join(result)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "subtract", "method_description": "@staticmethod\n def subtract(num1, num2):\n \"\"\"\n Subtracts two big numbers.\n :param num1: The first number to subtract,str.\n :param num2: The second number to subtract,str.\n :return: The difference of the two numbers,str.\n >>> bigNum = BigNumCalculator()\n >>> bigNum.subtract(\"12345678901234567890\", \"98765432109876543210\")\n '-86419753208641975320'\n\n \"\"\"", "test_class": "BigNumCalculatorTestSubtract", "test_code": "class BigNumCalculatorTestSubtract(unittest.TestCase):\n def test_subtract(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"12345678901234567890\", \"98765432109876543210\"), \"-86419753208641975320\")\n\n def test_subtract_2(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"123456789012345678922\", \"98765432109876543210\"), \"24691356902469135712\")\n\n def test_subtract_3(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"123456789012345678934\", \"98765432109876543\"), \"123358023580235802391\")\n\n def test_subtract_4(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"12345678901234567\", \"98765432109876543210\"), \"-98753086430975308643\")\n\n def test_subtract_5(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"923456789\", \"187654321\"), \"735802468\")", "solution_code": "@staticmethod\n def subtract(num1, num2):\n\n if len(num1) < len(num2):\n num1, num2 = num2, num1\n negative = True\n elif len(num1) > len(num2):\n negative = False\n else:\n if num1 < num2:\n num1, num2 = num2, num1\n negative = True\n else:\n negative = False\n\n max_length = max(len(num1), len(num2))\n num1 = num1.zfill(max_length)\n num2 = num2.zfill(max_length)\n\n borrow = 0\n result = []\n for i in range(max_length - 1, -1, -1):\n digit_diff = int(num1[i]) - int(num2[i]) - borrow\n\n if digit_diff < 0:\n digit_diff += 10\n borrow = 1\n else:\n borrow = 0\n\n result.insert(0, str(digit_diff))\n\n while len(result) > 1 and result[0] == '0':\n result.pop(0)\n\n if negative:\n result.insert(0, '-')\n\n return ''.join(result)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "multiply", "method_description": "@staticmethod\n def multiply(num1, num2):\n \"\"\"\n Multiplies two big numbers.\n :param num1: The first number to multiply,str.\n :param num2: The second number to multiply,str.\n :return: The product of the two numbers,str.\n >>> bigNum = BigNumCalculator()\n >>> bigNum.multiply(\"12345678901234567890\", \"98765432109876543210\")\n '1219326311370217952237463801111263526900'\n\n \"\"\"", "test_class": "BigNumCalculatorTestMultiply", "test_code": "class BigNumCalculatorTestMultiply(unittest.TestCase):\n def test_multiply(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"12345678901234567890\", \"98765432109876543210\"), \"1219326311370217952237463801111263526900\")\n\n def test_multiply_2(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"123456789012345678922\", \"98765432109876543210\"), \"12193263113702179524547477517529919219620\")\n\n def test_multiply_3(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"123456789012345678934\", \"98765432109876543\"), \"12193263113702179499806737010255845162\")\n\n def test_multiply_4(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"12345678901234567\", \"98765432109876543210\"), \"1219326311370217864336229223321140070\")\n\n def test_multiply_5(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"923456789\", \"187654321\"), \"173290656712635269\")\n\n def test_multiply_6(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"000000001\", \"000000001\"), \"1\")", "solution_code": "@staticmethod\n def multiply(num1, num2):\n len1, len2 = len(num1), len(num2)\n result = [0] * (len1 + len2)\n\n for i in range(len1 - 1, -1, -1):\n for j in range(len2 - 1, -1, -1):\n mul = int(num1[i]) * int(num2[j])\n p1, p2 = i + j, i + j + 1\n total = mul + result[p2]\n\n result[p1] += total // 10\n result[p2] = total % 10\n\n start = 0\n while start < len(result) - 1 and result[start] == 0:\n start += 1\n\n return ''.join(map(str, result[start:]))", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "BigNumCalculatorTestAdd", "BigNumCalculatorTestSubtract", "BigNumCalculatorTestMultiply", "BigNumCalculatorTestMain" ]

[]

[]

[ { "method_name": "clean_non_binary_chars", "method_description": "def clean_non_binary_chars(self):\n \"\"\"\n Clean the binary string by removing all non 0 or 1 characters.\n >>> bdp = BinaryDataProcessor(\"01101000daf3e4r01100101011011000110110001101111\")\n >>> bdp.clean_non_binary_chars()\n >>> bdp.binary_string\n '0110100001100101011011000110110001101111'\n\n \"\"\"", "test_class": "BinaryDataProcessorTestCleanNonBinaryChars", "test_code": "class BinaryDataProcessorTestCleanNonBinaryChars(unittest.TestCase):\n def test_clean_non_binary_chars(self):\n bdp = BinaryDataProcessor(\"01101000daf3e4r01100101011011000110110001101111\")\n self.assertEqual(bdp.binary_string, \"0110100001100101011011000110110001101111\")\n\n def test_clean_non_binary_chars_2(self):\n bdp = BinaryDataProcessor(\"01101000daf3e4r01100101011011addf0110001d1111\")\n self.assertEqual(bdp.binary_string, \"011010000110010101101101100011111\")\n\n def test_clean_non_binary_chars_3(self):\n bdp = BinaryDataProcessor(\"0sd1000daf3e4r01100101011011addf0110001d1111\")\n self.assertEqual(bdp.binary_string, \"010000110010101101101100011111\")\n\n def test_clean_non_binary_chars_4(self):\n bdp = BinaryDataProcessor(\"sdsdf\")\n self.assertEqual(bdp.binary_string, \"\")\n\n def test_clean_non_binary_chars_5(self):\n bdp = BinaryDataProcessor(\"0\")\n self.assertEqual(bdp.binary_string, \"0\")", "solution_code": "def clean_non_binary_chars(self):\n self.binary_string = ''.join(filter(lambda x: x in '01', self.binary_string))", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.binary_string" ], "method_dependencies": [] } }, { "method_name": "calculate_binary_info", "method_description": "def calculate_binary_info(self):\n \"\"\"\n Calculate the binary string information, including the percentage of 0 and 1, and the total length of the binary string.\n >>> bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n >>> bdp.calculate_binary_info()\n {'Zeroes': 0.475, 'Ones': 0.525, 'Bit length': 40}\n\n \"\"\"", "test_class": "BinaryDataProcessorTestCalculateBinaryInfo", "test_code": "class BinaryDataProcessorTestCalculateBinaryInfo(unittest.TestCase):\n def test_calculate_binary_info(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.calculate_binary_info(), {'Zeroes': 0.475, 'Ones': 0.525, 'Bit length': 40})\n\n def test_calculate_binary_info_2(self):\n bdp = BinaryDataProcessor(\"0110100001100101011010011111\")\n self.assertEqual(bdp.calculate_binary_info(), {'Bit length': 28, 'Ones': 0.5357142857142857, 'Zeroes': 0.4642857142857143})\n\n def test_calculate_binary_info_3(self):\n bdp = BinaryDataProcessor(\"01101001111100101011010011111\")\n self.assertEqual(bdp.calculate_binary_info(), {'Bit length': 29, 'Ones': 0.6206896551724138, 'Zeroes': 0.3793103448275862})\n\n def test_calculate_binary_info_4(self):\n bdp = BinaryDataProcessor(\"011010011111001\")\n self.assertEqual(bdp.calculate_binary_info(), {'Bit length': 15, 'Ones': 0.6, 'Zeroes': 0.4})\n\n def test_calculate_binary_info_5(self):\n bdp = BinaryDataProcessor(\"0110100111110010\")\n self.assertEqual(bdp.calculate_binary_info(), {'Bit length': 16, 'Ones': 0.5625, 'Zeroes': 0.4375})", "solution_code": "def calculate_binary_info(self):\n zeroes_count = self.binary_string.count('0')\n ones_count = self.binary_string.count('1')\n total_length = len(self.binary_string)\n\n zeroes_percentage = (zeroes_count / total_length)\n ones_percentage = (ones_count / total_length)\n\n return {\n 'Zeroes': zeroes_percentage,\n 'Ones': ones_percentage,\n 'Bit length': total_length\n }", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.binary_string" ], "method_dependencies": [] } }, { "method_name": "convert_to_ascii", "method_description": "def convert_to_ascii(self):\n \"\"\"\n Convert the binary string to ascii string.\n >>> bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n >>> bdp.convert_to_ascii()\n 'hello'\n\n \"\"\"", "test_class": "BinaryDataProcessorTestConvertToAscii", "test_code": "class BinaryDataProcessorTestConvertToAscii(unittest.TestCase):\n def test_convert_to_ascii(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"hello\")\n\n def test_convert_to_ascii_2(self):\n bdp = BinaryDataProcessor(\"0110100000100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"h%llo\")\n\n def test_convert_to_ascii_3(self):\n bdp = BinaryDataProcessor(\"01101000011011010110001001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"hmbo\")\n\n def test_convert_to_ascii_4(self):\n bdp = BinaryDataProcessor(\"01101000011001010110001001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"hebo\")\n\n def test_convert_to_ascii_5(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"hello\")", "solution_code": "def convert_to_ascii(self):\n byte_array = bytearray()\n for i in range(0, len(self.binary_string), 8):\n byte = self.binary_string[i:i+8]\n decimal = int(byte, 2)\n byte_array.append(decimal)\n\n return byte_array.decode('ascii')", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.binary_string" ], "method_dependencies": [] } }, { "method_name": "convert_to_utf8", "method_description": "def convert_to_utf8(self):\n \"\"\"\n Convert the binary string to utf-8 string.\n >>> bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n >>> bdp.convert_to_utf8()\n 'hello'\n\n \"\"\"", "test_class": "BinaryDataProcessorTestConvertToUtf8", "test_code": "class BinaryDataProcessorTestConvertToUtf8(unittest.TestCase):\n def test_convert_to_utf8(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_utf8(), \"hello\")\n\n def test_convert_to_utf8_2(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101001\")\n self.assertEqual(bdp.convert_to_utf8(), \"helli\")\n\n def test_convert_to_utf8_3(self):\n bdp = BinaryDataProcessor(\"0110000001100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_utf8(), \"`ello\")\n\n def test_convert_to_utf8_4(self):\n bdp = BinaryDataProcessor(\"0110101101100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_utf8(), \"kello\")\n\n def test_convert_to_utf8_5(self):\n bdp = BinaryDataProcessor(\"0110101101100100011011000110110001101111\")\n self.assertEqual(bdp.convert_to_utf8(), \"kdllo\")", "solution_code": "def convert_to_utf8(self):\n byte_array = bytearray()\n for i in range(0, len(self.binary_string), 8):\n byte = self.binary_string[i:i+8]\n decimal = int(byte, 2)\n byte_array.append(decimal)\n\n return byte_array.decode('utf-8')", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.binary_string" ], "method_dependencies": [] } } ]

[ "BinaryDataProcessorTestCleanNonBinaryChars", "BinaryDataProcessorTestCalculateBinaryInfo", "BinaryDataProcessorTestConvertToAscii", "BinaryDataProcessorTestConvertToUtf8", "BinaryDataProcessorTestMain" ]

[ "self.binary_string" ]

[]

[ { "method_name": "add", "method_description": "def add(states, stat):\n \"\"\"\n Add a status to the current status,and check the parameters wheather they are legal.\n :param states: Current status,int.\n :param stat: Status to be added,int.\n :return: The status after adding the status,int.\n >>> bit_status_util = BitStatusUtil()\n >>> bit_status_util.add(2,4)\n 6\n\n \"\"\"", "test_class": "BitStatusUtilTestAdd", "test_code": "class BitStatusUtilTestAdd(unittest.TestCase):\n def test_add(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(2, 4), 6)\n\n def test_add_2(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(2, 0), 2)\n\n def test_add_3(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(0, 0), 0)\n\n def test_add_4(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(0, 2), 2)\n\n def test_add_5(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(2, 2), 2)", "solution_code": "def add(states, stat):\n BitStatusUtil.check([states, stat])\n return states | stat", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "check" ] } }, { "method_name": "has", "method_description": "@staticmethod\n def has(states, stat):\n \"\"\"\n Check if the current status contains the specified status,and check the parameters wheather they are legal.\n :param states: Current status,int.\n :param stat: Specified status,int.\n :return: True if the current status contains the specified status,otherwise False,bool.\n >>> bit_status_util = BitStatusUtil()\n >>> bit_status_util.has(6,2)\n True\n\n \"\"\"", "test_class": "BitStatusUtilTestHas", "test_code": "class BitStatusUtilTestHas(unittest.TestCase):\n def test_has(self):\n bit_status_util = BitStatusUtil()\n self.assertTrue(bit_status_util.has(6, 2))\n\n def test_has_2(self):\n bit_status_util = BitStatusUtil()\n self.assertFalse(bit_status_util.has(8, 2))\n\n def test_has_3(self):\n bit_status_util = BitStatusUtil()\n self.assertTrue(bit_status_util.has(6, 4))\n\n def test_has_4(self):\n bit_status_util = BitStatusUtil()\n self.assertFalse(bit_status_util.has(8, 6))\n\n def test_has_5(self):\n bit_status_util = BitStatusUtil()\n self.assertTrue(bit_status_util.has(6, 6))", "solution_code": "@staticmethod\n def has(states, stat):\n BitStatusUtil.check([states, stat])\n return (states & stat) == stat", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "check" ] } }, { "method_name": "remove", "method_description": "@staticmethod\n def remove(states, stat):\n \"\"\"\n Remove the specified status from the current status,and check the parameters wheather they are legal.\n :param states: Current status,int.\n :param stat: Specified status,int.\n :return: The status after removing the specified status,int.\n >>> bit_status_util = BitStatusUtil()\n >>> bit_status_util.remove(6,2)\n 4\n\n \"\"\"", "test_class": "BitStatusUtilTestRemove", "test_code": "class BitStatusUtilTestRemove(unittest.TestCase):\n def test_remove(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(6, 2), 4)\n\n def test_remove_2(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(8, 2), 8)\n\n def test_remove_3(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(6, 4), 2)\n\n def test_remove_4(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(8, 6), 8)\n\n def test_remove_5(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(6, 6), 0)", "solution_code": "@staticmethod\n def remove(states, stat):\n BitStatusUtil.check([states, stat])\n if BitStatusUtil.has(states, stat):\n return states ^ stat\n return states", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "has", "check" ] } }, { "method_name": "check", "method_description": "@staticmethod\n def check(args):\n \"\"\"\n Check if the parameters are legal, args must be greater than or equal to 0 and must be even,if not,raise ValueError.\n :param args: Parameters to be checked,list.\n :return: None.\n >>> bit_status_util = BitStatusUtil()\n >>> bit_status_util.check([2,3,4])\n Traceback (most recent call last):\n ...\n ValueError: 3 not even\n \"\"\"", "test_class": "BitStatusUtilTestCheck", "test_code": "class BitStatusUtilTestCheck(unittest.TestCase):\n def test_check(self):\n bit_status_util = BitStatusUtil()\n bit_status_util.check([2])\n\n def test_check_2(self):\n bit_status_util = BitStatusUtil()\n with self.assertRaises(ValueError):\n bit_status_util.check([3])\n\n def test_check_3(self):\n bit_status_util = BitStatusUtil()\n with self.assertRaises(ValueError):\n bit_status_util.check([-1])\n\n def test_check_4(self):\n bit_status_util = BitStatusUtil()\n with self.assertRaises(ValueError):\n bit_status_util.check([2, 3, 4])\n\n def test_check_5(self):\n bit_status_util = BitStatusUtil()\n with self.assertRaises(ValueError):\n bit_status_util.check([2, 3, 4, 5])", "solution_code": "@staticmethod\n def check(args):\n for arg in args:\n if arg < 0:\n raise ValueError(f\"{arg} must be greater than or equal to 0\")\n if arg % 2 != 0:\n raise ValueError(f\"{arg} not even\")", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "BitStatusUtilTestAdd", "BitStatusUtilTestHas", "BitStatusUtilTestRemove", "BitStatusUtilTestCheck", "BitStatusUtilTestMain" ]

[]

[ "import random" ]

[ { "method_name": "create_deck", "method_description": "def create_deck(self):\n \"\"\"\n Create a deck of 52 cards, which stores 52 rondom order poker with the Jokers removed.\n :return: a list of 52 rondom order poker with the Jokers removed, format is ['AS', '2S', ...].\n >>> black_jack_game = BlackjackGame()\n >>> black_jack_game.create_deck()\n ['QD', '9D', 'JC', 'QH', '2S', 'JH', '7D', '6H', '9S', '5C', '7H', 'QS', '5H',\n '6C', '7C', '3D', '10C', 'AD', '4C', '5D', 'AH', '2D', 'QC', 'KH', '9C', '9H',\n '4H', 'JS', '6S', '8H', '8C', '4S', '3H', '10H', '7S', '6D', '3C', 'KC', '3S',\n '2H', '10D', 'KS', '4D', 'AC', '10S', '2C', 'KD', '5S', 'JD', '8S', 'AS', '8D']\n \"\"\"", "test_class": "BlackjackGameTestCreateDeck", "test_code": "class BlackjackGameTestCreateDeck(unittest.TestCase):\n def setUp(self):\n self.blackjackGame = BlackjackGame()\n self.deck = self.blackjackGame.deck\n\n def test_create_deck_1(self):\n self.assertEqual(len(self.deck), 52)\n\n def test_create_deck_2(self):\n suits = ['S', 'C', 'D', 'H']\n ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']\n for suit in suits:\n for rank in ranks:\n self.assertIn(rank + suit, self.deck)\n\n def test_create_deck_3(self):\n suits = ['S', 'C', 'D', 'H']\n ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9']\n for suit in suits:\n for rank in ranks:\n self.assertIn(rank + suit, self.deck)\n\n def test_create_deck_4(self):\n suits = ['S', 'C', 'D', 'H']\n ranks = ['10', 'J', 'Q', 'K']\n for suit in suits:\n for rank in ranks:\n self.assertIn(rank + suit, self.deck)\n\n def test_create_deck_5(self):\n suits = ['S', 'C', 'D', 'H']\n ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9']\n for suit in suits:\n for rank in ranks:\n self.assertIn(rank + suit, self.deck)", "solution_code": "def create_deck(self):\n deck = []\n suits = ['S', 'C', 'D', 'H']\n ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']\n for suit in suits:\n for rank in ranks:\n deck.append(rank + suit)\n random.shuffle(deck)\n return deck", "dependencies": { "Standalone": false, "lib_dependencies": [ "random" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "calculate_hand_value", "method_description": "def calculate_hand_value(self, hand):\n \"\"\"\n Calculate the value of the poker cards stored in hand list according to the rules of the Blackjack Game.\n If the card is a digit, its value is added to the total hand value.\n Value of J, Q, or K is 10, while Aces are worth 11.\n If the total hand value exceeds 21 and there are Aces present, one Ace is treated as having a value of 1 instead of 11,\n until the hand value is less than or equal to 21, or all Aces have been counted as value of 1.\n :param hand: list\n :return: the value of the poker cards stored in hand list, a number.\n >>> black_jack_game.calculate_hand_value(['QD', '9D', 'JC', 'QH', 'AS'])\n 40\n \"\"\"", "test_class": "BlackjackGameTestCalculateHandValue", "test_code": "class BlackjackGameTestCalculateHandValue(unittest.TestCase):\n def test_calculate_hand_value_1(self):\n blackjackGame = BlackjackGame()\n hand = ['2S', '3S', '4S', '5S']\n self.assertEqual(blackjackGame.calculate_hand_value(hand), 14)\n\n def test_calculate_hand_value_2(self):\n blackjackGame = BlackjackGame()\n hand = ['2S', '3S', 'JS', 'QS']\n self.assertEqual(blackjackGame.calculate_hand_value(hand), 25)\n\n def test_calculate_hand_value_3(self):\n blackjackGame = BlackjackGame()\n hand = ['2S', '3S', '4S', 'AS']\n self.assertEqual(blackjackGame.calculate_hand_value(hand), 20)\n\n def test_calculate_hand_value_4(self):\n blackjackGame = BlackjackGame()\n hand = ['JS', 'QS', '4S', 'AS']\n self.assertEqual(blackjackGame.calculate_hand_value(hand), 25)\n\n def test_calculate_hand_value_5(self):\n blackjackGame = BlackjackGame()\n hand = ['JS', 'QS', 'AS', 'AS', 'AS']\n self.assertEqual(blackjackGame.calculate_hand_value(hand), 23)\n\n def test_calculate_hand_value_6(self):\n blackjackGame = BlackjackGame()\n hand = ['JS', 'QS', 'BS', 'CS']\n self.assertEqual(blackjackGame.calculate_hand_value(hand), 20)", "solution_code": "def calculate_hand_value(self, hand):\n value = 0\n num_aces = 0\n for card in hand:\n rank = card[:-1]\n if rank.isdigit():\n value += int(rank)\n elif rank in ['J', 'Q', 'K']:\n value += 10\n elif rank == 'A':\n value += 11\n num_aces += 1\n while value > 21 and num_aces > 0:\n value -= 10\n num_aces -= 1\n return value", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "check_winner", "method_description": "def check_winner(self, player_hand, dealer_hand):\n \"\"\"\n Determines the winner of a game by comparing the hand values of the player and dealer.\n rule:\n If both players have hand values that are equal to or less than 21, the winner is the one whose hand value is closer to 21.\n Otherwise, the winner is the one with the lower hand value.\n :param player_hand: list\n :param dealer_hand: list\n :return: the result of the game, only two certain str: 'Dealer wins' or 'Player wins'\n >>> black_jack_game.check_winner(['QD', '9D', 'JC', 'QH', 'AS'], ['QD', '9D', 'JC', 'QH', '2S'])\n 'Player wins'\n \"\"\"", "test_class": "BlackjackGameTestCheckWinner", "test_code": "class BlackjackGameTestCheckWinner(unittest.TestCase):\n def setUp(self):\n self.blackjackGame = BlackjackGame()\n\n # player > 21 but dealer not, dealer wins.\n def test_check_winner_1(self):\n player_hand = ['2S', 'JS', 'QS']\n dealer_hand = ['7S', '9S']\n self.assertEqual(self.blackjackGame.check_winner(player_hand, dealer_hand), 'Dealer wins')\n\n # dealer > 21 but player not, player wins.\n def test_check_winner_2(self):\n player_hand = ['2S', '4S', '5S']\n dealer_hand = ['2S', 'JS', 'QS']\n self.assertEqual(self.blackjackGame.check_winner(player_hand, dealer_hand), 'Player wins')\n\n # both > 21 but dealer smaller, dealer wins.\n def test_check_winner_3(self):\n player_hand = ['3S', 'JS', 'QS']\n dealer_hand = ['2S', 'JS', 'QS']\n self.assertEqual(self.blackjackGame.check_winner(player_hand, dealer_hand), 'Dealer wins')\n\n # both > 21 but player smaller, player wins.\n def test_check_winner_4(self):\n player_hand = ['2S', 'JS', 'QS']\n dealer_hand = ['3S', 'JS', 'QS']\n self.assertEqual(self.blackjackGame.check_winner(player_hand, dealer_hand), 'Player wins')\n\n # both < 21 but dealer is bigger, dealer wins.\n def test_check_winner_5(self):\n player_hand = ['2S', '3S', '5S']\n dealer_hand = ['AS', 'JS']\n self.assertEqual(self.blackjackGame.check_winner(player_hand, dealer_hand), 'Dealer wins')\n\n # both < 21 but player is bigger, player wins.\n def test_check_winner_6(self):\n player_hand = ['AS', 'JS']\n dealer_hand = ['2S', '3S', '5S']\n self.assertEqual(self.blackjackGame.check_winner(player_hand, dealer_hand), 'Player wins')", "solution_code": "def check_winner(self, player_hand, dealer_hand):\n player_value = self.calculate_hand_value(player_hand)\n dealer_value = self.calculate_hand_value(dealer_hand)\n if player_value > 21 and dealer_value > 21:\n if player_value <= dealer_value:\n return 'Player wins'\n else:\n return 'Dealer wins'\n elif player_value > 21:\n return 'Dealer wins'\n elif dealer_value > 21:\n return 'Player wins'\n else:\n if player_value <= dealer_value:\n return 'Dealer wins'\n else:\n return 'Player wins'", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "calculate_hand_value" ] } } ]

[ "BlackjackGameTestCreateDeck", "BlackjackGameTestCalculateHandValue", "BlackjackGameTestCheckWinner", "BlackjackGameTestMain" ]

[ "self.dealer_hand", "self.deck", "self.player_hand" ]

[]

[ { "method_name": "add_book", "method_description": "def add_book(self, title, quantity=1):\n \"\"\"\n Add one or several books to inventory which is sorted by book title.\n :param title: str, the book title\n :param quantity: int, default value is 1.\n \"\"\"", "test_class": "BookManagementTestAddBook", "test_code": "class BookManagementTestAddBook(unittest.TestCase):\n def test_add_book_1(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\")\n self.assertEqual({\"book1\": 1}, bookManagement.inventory)\n\n def test_add_book_2(self):\n bookManagement = BookManagement()\n self.assertEqual({}, bookManagement.inventory)\n\n def test_add_book_3(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\")\n bookManagement.add_book(\"book1\", 2)\n self.assertEqual({\"book1\": 3}, bookManagement.inventory)\n\n def test_add_book_4(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n self.assertEqual({\"book1\": 2}, bookManagement.inventory)\n\n def test_add_book_5(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book1\")\n self.assertEqual({\"book1\": 3}, bookManagement.inventory)", "solution_code": "def add_book(self, title, quantity=1):\n if title in self.inventory:\n self.inventory[title] += quantity\n else:\n self.inventory[title] = quantity", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } }, { "method_name": "remove_book", "method_description": "def remove_book(self, title, quantity):\n \"\"\"\n Remove one or several books from inventory which is sorted by book title.\n Raise false while get invalid input.\n :param title: str, the book title\n :param quantity: int\n \"\"\"", "test_class": "BookManagementTestRemoveBook", "test_code": "class BookManagementTestRemoveBook(unittest.TestCase):\n def setUp(self) -> None:\n self.bookManagement = BookManagement()\n self.bookManagement.add_book(\"book1\", 2)\n self.bookManagement.add_book(\"book2\")\n\n # remove all this title books\n def test_remove_book_1(self):\n self.bookManagement.remove_book(\"book1\", 2)\n self.assertEqual(self.bookManagement.inventory, {\"book2\": 1})\n\n # remove part\n def test_remove_book_2(self):\n self.bookManagement.remove_book(\"book1\", 1)\n self.assertEqual(self.bookManagement.inventory, {\"book1\": 1, \"book2\": 1})\n\n # remove the title that doesn't exist\n def test_remove_book_3(self):\n with self.assertRaises(Exception):\n self.bookManagement.remove_book(\"book3\", 1)\n\n # invalid quantity\n def test_remove_book_4(self):\n with self.assertRaises(Exception):\n self.bookManagement.remove_book(\"book2\", 2)\n\n def test_remove_book_5(self):\n with self.assertRaises(Exception):\n self.bookManagement.remove_book(\"book2\", 5)", "solution_code": "def remove_book(self, title, quantity):\n if title not in self.inventory or self.inventory[title] < quantity:\n raise False\n self.inventory[title] -= quantity\n if self.inventory[title] == 0:\n del (self.inventory[title])", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } }, { "method_name": "view_inventory", "method_description": "def view_inventory(self):\n \"\"\"\n Get the inventory of the Book Management.\n :return self.inventory: dictionary, {title(str): quantity(int), ...}\n >>> bookManagement = BookManagement()\n >>> bookManagement.add_book(\"book1\", 1)\n >>> bookManagement.add_book(\"book2\", 1)\n >>> bookManagement.view_inventory()\n {'book1': 1, 'book2': 1}\n \"\"\"", "test_class": "BookManagementTestViewInventory", "test_code": "class BookManagementTestViewInventory(unittest.TestCase):\n def test_view_inventory_1(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\")\n expected = {\"book1\": 2, \"book2\": 1}\n self.assertEqual(expected, bookManagement.inventory)\n\n def test_view_inventory_2(self):\n bookManagement = BookManagement()\n expected = {}\n self.assertEqual(expected, bookManagement.inventory)\n\n def test_view_inventory_3(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\")\n expected = {\"book1\": 2, \"book2\": 1}\n self.assertEqual(expected, bookManagement.inventory)\n\n def test_view_inventory_4(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\")\n bookManagement.remove_book(\"book1\", 2)\n expected = {\"book2\": 1}\n self.assertEqual(expected, bookManagement.inventory)\n\n def test_view_inventory_5(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\", 1)\n bookManagement.remove_book(\"book1\", 2)\n bookManagement.remove_book(\"book2\",1)\n expected = {}\n self.assertEqual(expected, bookManagement.inventory)", "solution_code": "def view_inventory(self):\n return self.inventory", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } }, { "method_name": "view_book_quantity", "method_description": "def view_book_quantity(self, title):\n \"\"\"\n Get the quantity of a book.\n :param title: str, the title of the book.\n :return quantity: the quantity of this book title. return 0 when the title does not exist in self.invenroty\n >>> bookManagement = BookManagement()\n >>> bookManagement.add_book(\"book1\", 1)\n >>> bookManagement.view_book_quantity(\"book3\")\n 0\n \"\"\"", "test_class": "BookManagementTestViewBookQuantity", "test_code": "class BookManagementTestViewBookQuantity(unittest.TestCase):\n def test_view_book_quantity_1(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n self.assertEqual(2, bookManagement.view_book_quantity(\"book1\"))\n\n def test_view_book_quantity_2(self):\n bookManagement = BookManagement()\n self.assertEqual(0, bookManagement.view_book_quantity(\"book1\"))\n\n def test_view_book_quantity_3(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n self.assertEqual(2, bookManagement.view_book_quantity(\"book1\"))\n\n def test_view_book_quantity_4(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.remove_book(\"book1\", 2)\n self.assertEqual(0, bookManagement.view_book_quantity(\"book1\"))\n\n def test_view_book_quantity_5(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 3)\n bookManagement.remove_book(\"book1\", 2)\n self.assertEqual(1, bookManagement.view_book_quantity(\"book1\"))", "solution_code": "def view_book_quantity(self, title):\n if title not in self.inventory:\n return 0\n return self.inventory[title]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } } ]

[ "BookManagementTestAddBook", "BookManagementTestRemoveBook", "BookManagementTestViewInventory", "BookManagementTestViewBookQuantity", "BookManagementTestMain" ]

[ "self.inventory" ]

[ "import sqlite3" ]

[ { "method_name": "create_table", "method_description": "def create_table(self):\n \"\"\"\n Creates the book table in the database if it does not already exist.\n >>> book_db = BookManagementDB(\"test.db\")\n >>> book_db.create_table()\n \"\"\"", "test_class": "BookManagementDBTestCreateTable", "test_code": "class BookManagementDBTestCreateTable(unittest.TestCase):\n def setUp(self):\n self.db_name = \"test.db\"\n self.db = BookManagementDB(self.db_name)\n self.connection = sqlite3.connect(self.db_name)\n self.cursor = self.connection.cursor()\n\n def test_create_table_1(self):\n # Check if the table exists\n self.cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table' AND name='books'\")\n result = self.cursor.fetchone()\n self.assertIsNotNone(result)\n\n def test_create_table_2(self):\n self.db.create_table()\n # Check if the table has the correct columns\n self.cursor.execute(\"PRAGMA table_info(books)\")\n columns = self.cursor.fetchall()\n column_names = [column[1] for column in columns]\n expected_column_names = ['id', 'title', 'author', 'available']\n self.assertEqual(column_names, expected_column_names)\n\n def tearDown(self):\n self.db.connection.close()\n self.connection.close()\n # remove the test database file\n os.remove(self.db_name)", "solution_code": "def create_table(self):\n self.cursor.execute('''\n CREATE TABLE IF NOT EXISTS books (\n id INTEGER PRIMARY KEY,\n title TEXT,\n author TEXT,\n available INTEGER\n )\n ''')\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "add_book", "method_description": "def add_book(self, title, author):\n \"\"\"\n Adds a book to the database with the specified title and author, \n setting its availability to 1 as free to borrow.\n :param title: str, book title\n :param author: str, author name\n >>> book_db = BookManagementDB(\"test.db\")\n >>> book_db.create_table()\n >>> book_db.add_book('book1', 'author')\n \"\"\"", "test_class": "BookManagementDBTestAddBook", "test_code": "class BookManagementDBTestAddBook(unittest.TestCase):\n def setUp(self):\n self.db_name = \"test.db\"\n self.db = BookManagementDB(self.db_name)\n self.connection = sqlite3.connect(self.db_name)\n self.cursor = self.connection.cursor()\n\n def test_add_book(self):\n title = \"Introduction to Python\"\n author = \"John Smith\"\n self.db.add_book(title, author)\n\n # Check if the book was added correctly\n self.cursor.execute(\"SELECT title, author, available FROM books WHERE id=1\")\n result = self.cursor.fetchone()\n self.assertIsNotNone(result)\n self.assertEqual(result[0], title)\n self.assertEqual(result[1], author)\n self.assertEqual(result[2], 1)\n\n def tearDown(self):\n self.db.connection.close()\n self.connection.close()\n # remove the test database file\n os.remove(self.db_name)", "solution_code": "def add_book(self, title, author):\n self.cursor.execute('''\n INSERT INTO books (title, author, available)\n VALUES (?, ?, 1)\n ''', (title, author))\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "remove_book", "method_description": "def remove_book(self, book_id):\n \"\"\"\n Removes a book from the database based on the given book ID.\n :param book_id: int\n >>> book_db = BookManagementDB(\"test.db\")\n >>> book_db.remove_book(1)\n \"\"\"", "test_class": "BookManagementDBTestRemoveBook", "test_code": "class BookManagementDBTestRemoveBook(unittest.TestCase):\n def setUp(self):\n self.db_name = \"test.db\"\n self.db = BookManagementDB(self.db_name)\n self.connection = sqlite3.connect(self.db_name)\n self.cursor = self.connection.cursor()\n # Add a book for testing removal\n self.db.add_book(\"Book to Remove\", \"John Doe\")\n\n def test_remove_book(self):\n self.db.remove_book(1)\n\n # Check if the book was removed correctly\n self.cursor.execute(\"SELECT * FROM books WHERE id=1\")\n result = self.cursor.fetchone()\n self.assertIsNone(result)\n\n def tearDown(self):\n self.db.connection.close()\n self.connection.close()\n # remove the test database file\n os.remove(self.db_name)", "solution_code": "def remove_book(self, book_id):\n self.cursor.execute('''\n DELETE FROM books WHERE id = ?\n ''', (book_id,))\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "borrow_book", "method_description": "def borrow_book(self, book_id):\n \"\"\"\n Marks a book as borrowed in the database based on the given book ID.\n :param book_id: int\n >>> book_db = BookManagementDB(\"test.db\")\n >>> book_db.borrow_book(1)\n \"\"\"", "test_class": "BookManagementDBTestBorrowBook", "test_code": "class BookManagementDBTestBorrowBook(unittest.TestCase):\n def setUp(self):\n self.db_name = \"test.db\"\n self.db = BookManagementDB(self.db_name)\n self.connection = sqlite3.connect(self.db_name)\n self.cursor = self.connection.cursor()\n # Add a book for testing borrowing\n self.db.add_book(\"Book to Borrow\", \"Jane Smith\")\n\n def test_borrow_book(self):\n self.db.borrow_book(1)\n\n # Check if the book was marked as unavailable\n self.cursor.execute(\"SELECT available FROM books WHERE id=1\")\n result = self.cursor.fetchone()\n self.assertEqual(result[0], 0)\n\n def tearDown(self):\n self.db.connection.close()\n self.connection.close()\n # remove the test database file\n os.remove(self.db_name)", "solution_code": "def borrow_book(self, book_id):\n self.cursor.execute('''\n UPDATE books SET available = 0 WHERE id = ?\n ''', (book_id,))\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "return_book", "method_description": "def return_book(self, book_id):\n \"\"\"\n Marks a book as returned in the database based on the given book ID.\n :param book_id: int\n >>> book_db = BookManagementDB(\"test.db\")\n >>> book_db.return_book(1)\n \"\"\"", "test_class": "BookManagementDBTestReturnBook", "test_code": "class BookManagementDBTestReturnBook(unittest.TestCase):\n def setUp(self):\n self.db_name = \"test.db\"\n self.db = BookManagementDB(self.db_name)\n self.connection = sqlite3.connect(self.db_name)\n self.cursor = self.connection.cursor()\n # Add a book for testing returning\n self.db.add_book(\"Book to Return\", \"James Smith\")\n self.db.borrow_book(1) # Mark the book as borrowed\n\n def test_return_book(self):\n self.db.return_book(1)\n\n # Check if the book was marked as available again\n self.cursor.execute(\"SELECT available FROM books WHERE id=1\")\n result = self.cursor.fetchone()\n self.assertEqual(result[0], 1)\n\n def tearDown(self):\n self.db.connection.close()\n self.connection.close()\n # remove the test database file\n os.remove(self.db_name)", "solution_code": "def return_book(self, book_id):\n self.cursor.execute('''\n UPDATE books SET available = 1 WHERE id = ?\n ''', (book_id,))\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "search_books", "method_description": "def search_books(self):\n \"\"\"\n Retrieves all books from the database and returns their information.\n :return books: list[tuple], the information of all books in database\n >>> book_db.search_books()\n [(1, 'book1', 'author', 1)]\n \"\"\"", "test_class": "BookManagementDBTestSearchBooks", "test_code": "class BookManagementDBTestSearchBooks(unittest.TestCase):\n def setUp(self):\n self.db_name = \"test.db\"\n self.db = BookManagementDB(self.db_name)\n self.connection = sqlite3.connect(self.db_name)\n self.cursor = self.connection.cursor()\n # Add some books for testing search\n self.db.add_book(\"Book 1\", \"Author 1\")\n self.db.add_book(\"Book 2\", \"Author 2\")\n self.db.add_book(\"Book 3\", \"Author 3\")\n\n def test_search_books(self):\n books = self.db.search_books()\n\n # Ensure that all books were retrieved\n self.assertEqual(len(books), 3)\n\n # Ensure that the correct book information is retrieved\n self.assertEqual(books[0][1], \"Book 1\")\n self.assertEqual(books[1][2], \"Author 2\")\n self.assertEqual(books[2][3], 1)\n\n def tearDown(self):\n self.db.connection.close()\n self.connection.close()\n # remove the test database file\n os.remove(self.db_name)", "solution_code": "def search_books(self):\n self.cursor.execute('''\n SELECT * FROM books\n ''')\n books = self.cursor.fetchall()\n return books", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.cursor" ], "method_dependencies": [] } } ]

[ "BookManagementDBTestCreateTable", "BookManagementDBTestAddBook", "BookManagementDBTestRemoveBook", "BookManagementDBTestBorrowBook", "BookManagementDBTestReturnBook", "BookManagementDBTestSearchBooks" ]

[ "self.connection", "self.cursor" ]

[]

[ { "method_name": "match_in_pattern", "method_description": "def match_in_pattern(self, char):\n \"\"\"\n Finds the rightmost occurrence of a character in the pattern.\n :param char: The character to be searched for, str.\n :return: The index of the rightmost occurrence of the character in the pattern, int.\n >>> boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n >>> boyerMooreSearch.match_in_pattern(\"A\")\n 0\n\n \"\"\"", "test_class": "BoyerMooreSearchTestMatchInPattern", "test_code": "class BoyerMooreSearchTestMatchInPattern(unittest.TestCase):\n def test_match_in_pattern(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"A\"), 0)\n\n def test_match_in_pattern_2(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABAB\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"B\"), 3)\n\n def test_match_in_pattern_3(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABCABC\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"C\"), 5)\n\n def test_match_in_pattern_4(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABCABC\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"D\"), -1)\n\n def test_match_in_pattern_5(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABCABC\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"E\"), -1)", "solution_code": "def match_in_pattern(self, char):\n for i in range(self.patLen - 1, -1, -1):\n if char == self.pattern[i]:\n return i\n return -1", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.patLen", "self.pattern" ], "method_dependencies": [] } }, { "method_name": "mismatch_in_text", "method_description": "def mismatch_in_text(self, currentPos):\n \"\"\"\n Determines the position of the first dismatch between the pattern and the text.\n :param currentPos: The current position in the text, int.\n :return: The position of the first dismatch between the pattern and the text, int,otherwise -1.\n >>> boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABC\")\n >>> boyerMooreSearch.mismatch_in_text(0)\n 2\n\n \"\"\"", "test_class": "BoyerMooreSearchTestMismatchInText", "test_code": "class BoyerMooreSearchTestMismatchInText(unittest.TestCase):\n def test_mismatch_in_text(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), -1)\n\n def test_mismatch_in_text_2(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABC\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), 2)\n\n def test_mismatch_in_text_3(self):\n boyerMooreSearch = BoyerMooreSearch(\"AAAA\", \"ABC\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), 2)\n\n def test_mismatch_in_text_4(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), -1)\n\n def test_mismatch_in_text_5(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABC\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(3), 5)", "solution_code": "def mismatch_in_text(self, currentPos):\n for i in range(self.patLen - 1, -1, -1):\n if self.pattern[i] != self.text[currentPos + i]:\n return currentPos + i\n return -1", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.patLen", "self.pattern", "self.text" ], "method_dependencies": [] } }, { "method_name": "bad_character_heuristic", "method_description": "def bad_character_heuristic(self):\n \"\"\"\n Finds all occurrences of the pattern in the text.\n :return: A list of all positions of the pattern in the text, list.\n >>> boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n >>> boyerMooreSearch.bad_character_heuristic()\n [0, 3]\n\n \"\"\"", "test_class": "BoyerMooreSearchTestBadCharacterHeuristic", "test_code": "class BoyerMooreSearchTestBadCharacterHeuristic(unittest.TestCase):\n def test_bad_character_heuristic(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 3])\n\n def test_bad_character_heuristic_2(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABC\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [])\n\n def test_bad_character_heuristic_3(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 1, 2, 3, 4, 5, 6])\n\n def test_bad_character_heuristic_4(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABACABA\", \"ABA\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 4])\n\n def test_bad_character_heuristic_5(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABACABA\", \"ABAC\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0])", "solution_code": "def bad_character_heuristic(self):\n positions = []\n for i in range(self.textLen - self.patLen + 1):\n mismatch_index = self.mismatch_in_text(i)\n if mismatch_index == -1:\n positions.append(i)\n else:\n match_index = self.match_in_pattern(self.text[mismatch_index])\n i = (mismatch_index - match_index)\n return positions", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.patLen", "self.text", "self.textLen" ], "method_dependencies": [ "match_in_pattern", "mismatch_in_text" ] } } ]

[ "BoyerMooreSearchTestMatchInPattern", "BoyerMooreSearchTestMismatchInText", "BoyerMooreSearchTestBadCharacterHeuristic", "BoyerMooreSearchTestMain" ]

[ "self.patLen", "self.pattern", "self.text", "self.textLen" ]

[]

[ { "method_name": "calculate", "method_description": "def calculate(self, expression):\n \"\"\"\n Calculate the value of a given expression\n :param expression: string, given expression\n :return:If successful, returns the value of the expression; otherwise, returns None\n >>> calculator = Calculator()\n >>> calculator.calculate('1+2-3')\n 0.0\n \"\"\"", "test_class": "CalculatorTestCalculate", "test_code": "class CalculatorTestCalculate(unittest.TestCase):\n def test_calculate_1(self):\n calculator = Calculator()\n res = calculator.calculate('1+2')\n self.assertEqual(res, 3)\n\n def test_calculate_2(self):\n calculator = Calculator()\n res = calculator.calculate('1+2*3')\n self.assertEqual(res, 7)\n\n def test_calculate_3(self):\n calculator = Calculator()\n res = calculator.calculate('1+2*3+4')\n self.assertEqual(res, 11)\n\n def test_calculate_4(self):\n calculator = Calculator()\n res = calculator.calculate('1+2^3*2+4*5')\n self.assertEqual(res, 37)\n\n def test_calculate_5(self):\n calculator = Calculator()\n res = calculator.calculate('1+2+3')\n self.assertEqual(res, 6)\n\n def test_calculate_6(self):\n calculator = Calculator()\n res = calculator.calculate('(1+2)+3')\n self.assertEqual(res, 6)\n\n def test_calculate_7(self):\n calculator = Calculator()\n res = calculator.calculate('')\n self.assertEqual(res, None)\n\n def test_calculate_8(self):\n calculator = Calculator()\n res = calculator.calculate('1+2?')\n self.assertEqual(res, 3)", "solution_code": "def calculate(self, expression):\n operand_stack = []\n operator_stack = []\n num_buffer = ''\n\n for char in expression:\n if char.isdigit() or char == '.':\n num_buffer += char\n else:\n if num_buffer:\n operand_stack.append(float(num_buffer))\n num_buffer = ''\n\n if char in '+-*/^':\n while (\n operator_stack and\n operator_stack[-1] != '(' and\n self.precedence(operator_stack[-1]) >= self.precedence(char)\n ):\n operand_stack, operator_stack = self.apply_operator(operand_stack, operator_stack)\n\n operator_stack.append(char)\n elif char == '(':\n operator_stack.append(char)\n elif char == ')':\n while operator_stack and operator_stack[-1] != '(':\n operand_stack, operator_stack = self.apply_operator(operand_stack, operator_stack)\n\n operator_stack.pop()\n\n if num_buffer:\n operand_stack.append(float(num_buffer))\n\n while operator_stack:\n operand_stack, operator_stack = self.apply_operator(operand_stack, operator_stack)\n\n return operand_stack[-1] if operand_stack else None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "precedence", "apply_operator" ] } }, { "method_name": "precedence", "method_description": "def precedence(self, operator):\n \"\"\"\n Returns the priority of the specified operator, where the higher the priority, the greater the assignment. The priority of '^' is greater than '/' and '*', and the priority of '/' and '*' is greater than '+' and '-'\n :param operator: string, given operator\n :return: int, the priority of the given operator, otherwise return 0\n >>> calculator = Calculator()\n >>> calculator.precedence('+')\n 1\n >>> calculator.precedence('^')\n 3\n \"\"\"", "test_class": "CalculatorTestPrecedence", "test_code": "class CalculatorTestPrecedence(unittest.TestCase):\n def test_precedence_1(self):\n calculator = Calculator()\n res1 = calculator.precedence('+')\n res2 = calculator.precedence('-')\n self.assertEqual(res1, res2)\n\n def test_precedence_2(self):\n calculator = Calculator()\n res1 = calculator.precedence('*')\n res2 = calculator.precedence('/')\n self.assertEqual(res1, res2)\n\n def test_precedence_3(self):\n calculator = Calculator()\n res1 = calculator.precedence('+')\n res2 = calculator.precedence('/')\n self.assertNotEqual(res1, res2)\n\n def test_precedence_4(self):\n calculator = Calculator()\n res1 = calculator.precedence('+')\n res2 = calculator.precedence('/')\n self.assertNotEqual(res1, res2)\n\n def test_precedence_5(self):\n calculator = Calculator()\n res1 = calculator.precedence('*')\n res2 = calculator.precedence('-')\n self.assertNotEqual(res1, res2)", "solution_code": "def precedence(self, operator):\n precedences = {\n '+': 1,\n '-': 1,\n '*': 2,\n '/': 2,\n '^': 3\n }\n return precedences.get(operator, 0)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "apply_operator", "method_description": "def apply_operator(self, operand_stack, operator_stack):\n \"\"\"\n Use the operator at the top of the operator stack to perform the operation on the two numbers at the top of the operator stack, and store the results at the top of the operator stack\n :param operand_stack:list\n :param operator_stack:list\n :return: the updated operand_stack and operator_stack\n >>> calculator = Calculator()\n >>> calculator.apply_operator([1, 2, 3], ['+', '-'])\n ([1, -1], ['-'])\n \"\"\"", "test_class": "CalculatorTestApplyOperator", "test_code": "class CalculatorTestApplyOperator(unittest.TestCase):\n def test_apply_operator_1(self):\n calculator = Calculator()\n operand_stack = [1, 2, 3]\n operator_stack = ['+', '-']\n calculator.apply_operator(operand_stack, operator_stack)\n self.assertEqual(operand_stack, [1, -1])\n self.assertEqual(operator_stack, ['+'])\n\n def test_apply_operator_2(self):\n calculator = Calculator()\n operand_stack = [1, 2, 3]\n operator_stack = ['+', '*']\n calculator.apply_operator(operand_stack, operator_stack)\n self.assertEqual(operand_stack, [1, 6])\n self.assertEqual(operator_stack, ['+'])\n\n def test_apply_operator_3(self):\n calculator = Calculator()\n operand_stack = [6, 3, 3]\n operator_stack = ['+', '/']\n calculator.apply_operator(operand_stack, operator_stack)\n self.assertEqual(operand_stack, [6, 1])\n self.assertEqual(operator_stack, ['+'])\n\n def test_apply_operator_4(self):\n calculator = Calculator()\n operand_stack = [1, 2, 3]\n operator_stack = ['+', '^']\n calculator.apply_operator(operand_stack, operator_stack)\n self.assertEqual(operand_stack, [1, 8])\n self.assertEqual(operator_stack, ['+'])\n\n def test_apply_operator_5(self):\n calculator = Calculator()\n operand_stack = [1, 2, 3]\n operator_stack = ['+', '+']\n calculator.apply_operator(operand_stack, operator_stack)\n self.assertEqual(operand_stack, [1, 5])\n self.assertEqual(operator_stack, ['+'])", "solution_code": "def apply_operator(self, operand_stack, operator_stack):\n operator = operator_stack.pop()\n if operator == '^':\n operand2 = operand_stack.pop()\n operand1 = operand_stack.pop()\n result = self.operators[operator](operand1, operand2)\n operand_stack.append(result)\n else:\n operand2 = operand_stack.pop()\n operand1 = operand_stack.pop()\n result = self.operators[operator](operand1, operand2)\n operand_stack.append(result)\n return operand_stack, operator_stack", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.operators" ], "method_dependencies": [] } } ]

[ "CalculatorTestCalculate", "CalculatorTestPrecedence", "CalculatorTestApplyOperator", "CalculatorTest" ]

[ "self.operators" ]

[ "from datetime import datetime, timedelta" ]

[ { "method_name": "add_event", "method_description": "def add_event(self, event):\n \"\"\"\n Add an event to the calendar.\n :param event: The event to be added to the calendar,dict.\n >>> calendar = CalendarUtil()\n >>> calendar.add_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0), 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'})\n >>> calendar.events\n [{'date': datetime.datetime(2023, 1, 1, 0, 0), 'start_time': datetime.datetime(2023, 1, 1, 0, 0), 'end_time': datetime.datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n\n \"\"\"", "test_class": "CalendarTestAddEvent", "test_code": "class CalendarTestAddEvent(unittest.TestCase):\n def test_add_event(self):\n calendar = CalendarUtil()\n calendar.add_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}])\n\n def test_add_event_2(self):\n calendar = CalendarUtil()\n calendar.add_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'})\n calendar.add_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'},\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}])\n\n def test_add_event_3(self):\n calendar = CalendarUtil()\n calendar.add_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'}])\n\n def test_add_event_4(self):\n calendar = CalendarUtil()\n calendar.add_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 22, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 22, 0), 'description': 'New Year'}])\n\n def test_add_event_5(self):\n calendar = CalendarUtil()\n calendar.add_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 20, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 20, 0), 'description': 'New Year'}])", "solution_code": "def add_event(self, event):\n self.events.append(event)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.events" ], "method_dependencies": [] } }, { "method_name": "remove_event", "method_description": "def remove_event(self, event):\n \"\"\"\n Remove an event from the calendar.\n :param event: The event to be removed from the calendar,dict.\n >>> calendar = CalendarUtil()\n >>> calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0), 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n >>> calendar.remove_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0), 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'})\n >>> calendar.events\n []\n\n \"\"\"", "test_class": "CalendarTestRemoveEvent", "test_code": "class CalendarTestRemoveEvent(unittest.TestCase):\n def test_remove_event(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n calendar.remove_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [])\n\n def test_remove_event_2(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'},\n {'date': datetime(2023, 1, 2, 0, 0), 'start_time': datetime(2023, 1, 2, 0, 0),\n 'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year'}]\n calendar.remove_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 2, 0, 0), 'start_time': datetime(2023, 1, 2, 0, 0),\n 'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year'}])\n\n def test_remove_event_3(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'},\n {'date': datetime(2023, 1, 2, 0, 0), 'start_time': datetime(2023, 1, 2, 0, 0),\n 'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year'}]\n calendar.remove_event({'date': datetime(2023, 1, 2, 0, 0), 'start_time': datetime(2023, 1, 2, 0, 0),\n 'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}])\n\n def test_remove_event_4(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'},\n {'date': datetime(2023, 1, 2, 0, 0), 'start_time': datetime(2023, 1, 2, 0, 0),\n 'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year'}]\n calendar.remove_event({'date': datetime(2023, 1, 2, 0, 0), 'start_time': datetime(2023, 1, 2, 0, 0),\n 'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'}])\n\n def test_remove_event_5(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 22, 0), 'description': 'New Year'},\n {'date': datetime(2023, 1, 2, 0, 0), 'start_time': datetime(2023, 1, 2, 0, 0),\n 'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year'}]\n calendar.remove_event({'date': datetime(2023, 1, 2, 0, 0), 'start_time': datetime(2023, 1, 2, 0, 0),\n 'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 22, 0), 'description': 'New Year'}])\n\n def test_remove_event_6(self):\n calendar = CalendarUtil()\n calendar.events = []\n calendar.remove_event({'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'})\n self.assertEqual(calendar.events, [])", "solution_code": "def remove_event(self, event):\n if event in self.events:\n self.events.remove(event)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.events" ], "method_dependencies": [] } }, { "method_name": "get_events", "method_description": "def get_events(self, date):\n \"\"\"\n Get all events on a given date.\n :param date: The date to get events for,datetime.\n :return: A list of events on the given date,list.\n >>> calendar = CalendarUtil()\n >>> calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0), 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n >>> calendar.get_events(datetime(2023, 1, 1, 0, 0))\n [{'date': datetime.datetime(2023, 1, 1, 0, 0), 'start_time': datetime.datetime(2023, 1, 1, 0, 0), 'end_time': datetime.datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n\n \"\"\"", "test_class": "CalendarTestGetEvents", "test_code": "class CalendarTestGetEvents(unittest.TestCase):\n def test_get_events(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.get_events(datetime(2023, 1, 1)), [\n {'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}])\n\n def test_get_events_2(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.get_events(datetime(2023, 1, 2)), [])", "solution_code": "def get_events(self, date):\n events_on_date = []\n for event in self.events:\n if event['date'].date() == date.date():\n events_on_date.append(event)\n return events_on_date", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.events" ], "method_dependencies": [] } }, { "method_name": "is_available", "method_description": "def is_available(self, start_time, end_time):\n \"\"\"\n Check if the calendar is available for a given time slot.\n :param start_time: The start time of the time slot,datetime.\n :param end_time: The end time of the time slot,datetime.\n :return: True if the calendar is available for the given time slot, False otherwise,bool.\n >>> calendar = CalendarUtil()\n >>> calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0), 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n >>> calendar.is_available(datetime(2023, 1, 1, 0, 0), datetime(2023, 1, 1, 1, 0))\n False\n\n \"\"\"", "test_class": "CalendarTestIsAvailable", "test_code": "class CalendarTestIsAvailable(unittest.TestCase):\n def test_is_available(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.is_available(datetime(2023, 1, 1, 0, 0), datetime(2023, 1, 1, 1, 0)), False)\n\n def test_is_available_2(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.is_available(datetime(2023, 1, 1, 1, 0), datetime(2023, 1, 1, 2, 0)), True)\n\n def test_is_available_3(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.is_available(datetime(2023, 1, 1, 0, 0), datetime(2023, 1, 1, 0, 30)), False)\n\n def test_is_available_4(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.is_available(datetime(2023, 1, 1, 0, 30), datetime(2023, 1, 1, 1, 0)), False)\n\n def test_is_available_5(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 1, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.is_available(datetime(2023, 1, 1, 1, 0), datetime(2023, 1, 1, 1, 30)), True)", "solution_code": "def is_available(self, start_time, end_time):\n for event in self.events:\n if start_time < event['end_time'] and end_time > event['start_time']:\n return False\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.events" ], "method_dependencies": [] } }, { "method_name": "get_available_slots", "method_description": "def get_available_slots(self, date):\n \"\"\"\n Get all available time slots on a given date.\n :param date: The date to get available time slots for,datetime.\n :return: A list of available time slots on the given date,list.\n >>> calendar = CalendarUtil()\n >>> calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0), 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'}]\n >>> calendar.get_available_slots(datetime(2023, 1, 1))\n [(datetime.datetime(2023, 1, 1, 23, 0), datetime.datetime(2023, 1, 2, 0, 0))]\n\n \"\"\"", "test_class": "CalendarTestGetAvailableSlots", "test_code": "class CalendarTestGetAvailableSlots(unittest.TestCase):\n def test_get_available_slots(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.get_available_slots(datetime(2023, 1, 1)),\n [(datetime(2023, 1, 1, 23, 0), datetime(2023, 1, 2, 0, 0))])\n\n def test_get_available_slots_2(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 1, 0),\n 'end_time': datetime(2023, 1, 1, 2, 0), 'description': 'New Year'}]\n self.assertEqual(len(calendar.get_available_slots(datetime(2023, 1, 1))), 23)\n\n def test_get_available_slots_3(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 2, 1, 0),\n 'end_time': datetime(2023, 1, 2, 2, 0), 'description': 'New Year'}]\n self.assertEqual(len(calendar.get_available_slots(datetime(2023, 1, 1))), 24)\n\n def test_get_available_slots_4(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 2, 1, 0),\n 'end_time': datetime(2023, 1, 2, 2, 0), 'description': 'New Year'}]\n self.assertEqual(len(calendar.get_available_slots(datetime(2023, 1, 1))), 24)\n\n def test_get_available_slots_5(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 2, 1, 0),\n 'end_time': datetime(2023, 1, 2, 2, 0), 'description': 'New Year'}]\n self.assertEqual(len(calendar.get_available_slots(datetime(2023, 1, 1))), 24)", "solution_code": "def get_available_slots(self, date):\n available_slots = []\n start_time = datetime(date.year, date.month, date.day, 0, 0)\n end_time = datetime(date.year, date.month, date.day, 23, 59)\n\n while start_time < end_time:\n slot_end_time = start_time + timedelta(minutes=60)\n if self.is_available(start_time, slot_end_time):\n available_slots.append((start_time, slot_end_time))\n start_time += timedelta(minutes=60)\n\n\n return available_slots", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "is_available" ] } }, { "method_name": "get_upcoming_events", "method_description": "def get_upcoming_events(self, num_events):\n \"\"\"\n Get the next n upcoming events from a given date.\n :param date: The date to get upcoming events from,datetime.\n :param n: The number of upcoming events to get,int.\n :return: A list of the next n upcoming events from the given date,list.\n >>> calendar = CalendarUtil()\n >>> calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0), 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'},{'date': datetime(2023, 1, 2, 0, 0),'end_time': datetime(2023, 1, 2, 1, 0), 'description': 'New Year 2'}]\n >>> calendar.get_upcoming_events(1)\n [{'date': datetime.datetime(2023, 1, 1, 0, 0), 'start_time': datetime.datetime(2023, 1, 1, 0, 0), 'end_time': datetime.datetime(2023, 1, 1, 23, 0), 'description': 'New Year'}, {'date': datetime.datetime(2023, 1, 2, 0, 0), 'end_time': datetime.datetime(2023, 1, 2, 1, 0), 'description': 'New Year 2'}]\n\n \"\"\"", "test_class": "CalendarTestGetUpcomingEvents", "test_code": "class CalendarTestGetUpcomingEvents(unittest.TestCase):\n def test_get_upcoming_events(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.get_upcoming_events(1), [])\n\n def test_get_upcoming_events_2(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 1, 0),\n 'end_time': datetime(2023, 1, 1, 2, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.get_upcoming_events(1), [])\n\n def test_get_upcoming_events_3(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 2, 1, 0),\n 'end_time': datetime(2023, 1, 2, 2, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.get_upcoming_events(1), [])\n\n def test_get_upcoming_events_4(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 2, 1, 0),\n 'end_time': datetime(2023, 1, 2, 2, 0), 'description': 'New Year'}]\n self.assertEqual(calendar.get_upcoming_events(2), [])\n\n def test_get_upcoming_events_5(self):\n calendar = CalendarUtil()\n calendar.events = [{'date': datetime(2023, 1, 1, 0, 0), 'start_time': datetime(2023, 1, 1, 0, 0),\n 'end_time': datetime(2023, 1, 1, 23, 0), 'description': 'New Year'},\n {'date': datetime(2024, 1, 2, 0, 0), 'start_time': datetime(2024, 1, 2, 1, 0),\n 'end_time': datetime(2024, 1, 2, 2, 0),\n 'description': 'New Year 2'}]\n self.assertEqual(calendar.get_upcoming_events(1), [\n {'date': datetime(2024, 1, 2, 0, 0), 'start_time': datetime(2024, 1, 2, 1, 0),\n 'end_time': datetime(2024, 1, 2, 2, 0), 'description': 'New Year 2'}])", "solution_code": "def get_upcoming_events(self, num_events):\n now = datetime.now()\n upcoming_events = []\n for event in self.events:\n if event['start_time'] >= now:\n upcoming_events.append(event)\n if len(upcoming_events) == num_events:\n break\n return upcoming_events", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.events" ], "method_dependencies": [] } } ]

[ "CalendarTestAddEvent", "CalendarTestRemoveEvent", "CalendarTestGetEvents", "CalendarTestIsAvailable", "CalendarTestGetAvailableSlots", "CalendarTestGetUpcomingEvents", "CalendarTestMain" ]

[ "self.events" ]

[]

[ { "method_name": "__getitem__", "method_description": "def __getitem__(self, key):\n \"\"\"\n Return the value corresponding to the key\n :param key:str\n :return:str,the value corresponding to the key\n >>> camelize_map = CamelCaseMap()\n >>> camelize_map['first_name'] = 'John'\n >>> camelize_map.__getitem__('first_name')\n 'John'\n \"\"\"", "test_class": "CamelCaseMapTestGetitem", "test_code": "class CamelCaseMapTestGetitem(unittest.TestCase):\n def test_getitem_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__getitem__('first_name'), 'John')\n\n def test_getitem_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['last_name'] = 'Doe'\n self.assertEqual(camelize_map.__getitem__('last_name'), 'Doe')\n\n def test_getitem_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['age'] = 30\n self.assertEqual(camelize_map.__getitem__('age'), 30)\n\n def test_getitem_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__getitem__('first_Name'), 'John')\n\n def test_getitem_5(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__getitem__('firstName'), 'John')", "solution_code": "def __getitem__(self, key):\n return self._data[self._convert_key(key)]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self._data" ], "method_dependencies": [ "_convert_key" ] } }, { "method_name": "__setitem__", "method_description": "def __setitem__(self, key, value):\n \"\"\"\n Set the value corresponding to the key to the specified value\n :param key:str\n :param value:str, the specified value\n :return:None\n >>> camelize_map = CamelCaseMap()\n >>> camelize_map['first_name'] = 'John'\n >>> camelize_map.__setitem__('first_name', 'new name')\n camelize_map['first_name'] = 'new name'\n \"\"\"", "test_class": "CamelCaseMapTestSetitem", "test_code": "class CamelCaseMapTestSetitem(unittest.TestCase):\n def test_setitem_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_name', 'newname')\n self.assertEqual(camelize_map['first_name'], 'newname')\n\n def test_setitem_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_name', 'John')\n self.assertEqual(camelize_map['first_name'], 'John')\n\n def test_setitem_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_Name', 'newname')\n self.assertEqual(camelize_map['first_name'], 'newname')\n\n def test_setitem_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('firstName', 'newname')\n self.assertEqual(camelize_map['first_name'], 'newname')\n\n def test_setitem_5(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_name', '')\n self.assertEqual(camelize_map['first_name'], '')", "solution_code": "def __setitem__(self, key, value):\n self._data[self._convert_key(key)] = value", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self._data" ], "method_dependencies": [ "_convert_key" ] } }, { "method_name": "__delitem__", "method_description": "def __delitem__(self, key):\n \"\"\"\n Delete the value corresponding to the key\n :param key:str\n :return:None\n >>> camelize_map = CamelCaseMap()\n >>> camelize_map['first_name'] = 'John'\n >>> camelize_map.__delitem__('first_name')\n >>> flag = 'first_name' in camelize_map\n flag = False\n \"\"\"", "test_class": "CamelCaseMapTestDelitem", "test_code": "class CamelCaseMapTestDelitem(unittest.TestCase):\n def test_delitem_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map['last_name'] = 'Doe'\n camelize_map.__delitem__('first_name')\n self.assertEqual(camelize_map['last_name'], 'Doe')\n\n def test_delitem_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__delitem__('first_name')\n self.assertEqual('first_name' in camelize_map, False)\n\n def test_delitem_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__delitem__('first_Name')\n self.assertEqual('first_name' in camelize_map, False)\n\n def test_delitem_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__delitem__('firstName')\n self.assertEqual('first_name' in camelize_map, False)\n\n def test_delitem_5(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = ''\n camelize_map.__delitem__('first_name')\n self.assertEqual('first_name' in camelize_map, False)", "solution_code": "def __delitem__(self, key):\n del self._data[self._convert_key(key)]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self._data" ], "method_dependencies": [ "_convert_key" ] } }, { "method_name": "__iter__", "method_description": "def __iter__(self):\n \"\"\"\n Returning Iterateable Objects with Own Data\n :return:Iterator\n >>> camelize_map = CamelCaseMap()\n >>> camelize_map['first_name'] = 'John'\n >>> camelize_map['last_name'] = 'Doe'\n >>> camelize_map['age'] = 30\n >>> camelize_map.__iter__()\n <dict_keyiterator object at 0x0000026739977C20>\n \"\"\"", "test_class": "CamelCaseMapTestIter", "test_code": "class CamelCaseMapTestIter(unittest.TestCase):\n def test_iter_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map['last_name'] = 'Doe'\n camelize_map['age'] = 30\n lst = ['firstName', 'lastName', 'age']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n def test_iter_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['firstname'] = 'John'\n camelize_map['lastname'] = 'Doe'\n camelize_map['age'] = 30\n lst = ['firstname', 'lastname', 'age']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n def test_iter_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_Name'] = 'John'\n camelize_map['last_Name'] = 'Doe'\n camelize_map['age'] = 30\n lst = ['firstName', 'lastName', 'age']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n def test_iter_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_Name'] = 'John'\n camelize_map['last_Name'] = 'Doe'\n lst = ['firstName', 'lastName']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n def test_iter_5(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_Name'] = 'John'\n lst = ['firstName']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1", "solution_code": "def __iter__(self):\n return iter(self._data)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self._data" ], "method_dependencies": [] } }, { "method_name": "__len__", "method_description": "def __len__(self):\n \"\"\"\n Returns the length of the own data\n :return:int, length of data\n >>> camelize_map = CamelCaseMap()\n >>> camelize_map['first_name'] = 'John'\n >>> camelize_map['last_name'] = 'Doe'\n >>> camelize_map['age'] = 30\n >>> camelize_map.__len__()\n 3\n \"\"\"", "test_class": "CamelCaseMapTestLen", "test_code": "class CamelCaseMapTestLen(unittest.TestCase):\n def test_len_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__len__(), 1)\n\n def test_len_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['last_name'] = 'Doe'\n self.assertEqual(camelize_map.__len__(), 1)\n\n def test_len_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['age'] = 30\n self.assertEqual(camelize_map.__len__(), 1)\n\n def test_len_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map['last_Name'] = 'Doe'\n camelize_map['age'] = 30\n self.assertEqual(camelize_map.__len__(), 3)\n\n def test_len_5(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map.__len__(), 0)", "solution_code": "def __len__(self):\n return len(self._data)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self._data" ], "method_dependencies": [] } }, { "method_name": "_convert_key", "method_description": "def _convert_key(self, key):\n \"\"\"\n convert key string into camel case\n :param key:str\n :return:str, converted key string\n >>> camelize_map = CamelCaseMap()\n >>> camelize_map._convert_key('first_name')\n 'firstName'\n \"\"\"", "test_class": "CamelCaseMapTestConvertKey", "test_code": "class CamelCaseMapTestConvertKey(unittest.TestCase):\n def test_convert_key_1(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('aaa_bbb'), 'aaaBbb')\n\n def test_convert_key_2(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('first_name'), 'firstName')\n\n def test_convert_key_3(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('last_name'), 'lastName')\n\n def test_convert_key_4(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('ccc_ddd'), 'cccDdd')\n\n def test_convert_key_5(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('eee_fff'), 'eeeFff')\n\n def test_convert_key_6(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key(1234), 1234)", "solution_code": "def _convert_key(self, key):\n if isinstance(key, str):\n return self._to_camel_case(key)\n return key", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "_to_camel_case" ] } }, { "method_name": "_to_camel_case", "method_description": "@staticmethod\n def _to_camel_case(key):\n \"\"\"\n convert key string into camel case\n :param key:str\n :return:str, converted key string\n >>> camelize_map = CamelCaseMap()\n >>> camelize_map._to_camel_case('first_name')\n 'firstName'\n \"\"\"", "test_class": "CamelCaseMapTestToCamelCase", "test_code": "class CamelCaseMapTestToCamelCase(unittest.TestCase):\n def test_to_camel_case_1(self):\n self.assertEqual(CamelCaseMap._to_camel_case('aaa_bbb'), 'aaaBbb')\n\n def test_to_camel_case_2(self):\n self.assertEqual(CamelCaseMap._to_camel_case('first_name'), 'firstName')\n\n def test_to_camel_case_3(self):\n self.assertEqual(CamelCaseMap._to_camel_case('last_name'), 'lastName')\n\n def test_to_camel_case_4(self):\n self.assertEqual(CamelCaseMap._to_camel_case('ccc_ddd'), 'cccDdd')\n\n def test_to_camel_case_5(self):\n self.assertEqual(CamelCaseMap._to_camel_case('eee_fff'), 'eeeFff')", "solution_code": "@staticmethod\n def _to_camel_case(key):\n parts = key.split('_')\n return parts[0] + ''.join(part.title() for part in parts[1:])", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "CamelCaseMapTestGetitem", "CamelCaseMapTestSetitem", "CamelCaseMapTestDelitem", "CamelCaseMapTestIter", "CamelCaseMapTestLen", "CamelCaseMapTestConvertKey", "CamelCaseMapTestToCamelCase", "CamelCaseMapTest" ]

[ "self._data" ]

[]

[ { "method_name": "generate_primes", "method_description": "def generate_primes(self):\n \"\"\"\n Generate prime numbers up to the specified limit using the Chandrasekhar sieve algorithm.\n :return: list, a list of prime numbers\n >>> cs = ChandrasekharSieve(20)\n >>> cs.generate_primes()\n [2, 3, 5, 7, 11, 13, 17, 19]\n\n \"\"\"", "test_class": "ChandrasekharSieveTestGeneratePrimes", "test_code": "class ChandrasekharSieveTestGeneratePrimes(unittest.TestCase):\n def test_generate_primes_1(self):\n cs = ChandrasekharSieve(20)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\n\n def test_generate_primes_2(self):\n cs = ChandrasekharSieve(18)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17])\n\n def test_generate_primes_3(self):\n cs = ChandrasekharSieve(15)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13])\n\n def test_generate_primes_4(self):\n cs = ChandrasekharSieve(10)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7])\n\n def test_generate_primes_5(self):\n cs = ChandrasekharSieve(1)\n res = cs.generate_primes()\n self.assertEqual(res, [])", "solution_code": "def generate_primes(self):\n if self.n < 2:\n return []\n\n sieve = [True] * (self.n + 1)\n sieve[0] = sieve[1] = False\n\n p = 2\n while p * p <= self.n:\n if sieve[p]:\n for i in range(p * p, self.n + 1, p):\n sieve[i] = False\n p += 1\n\n primes = []\n for i in range(2, self.n + 1):\n if sieve[i]:\n primes.append(i)\n\n return primes", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.n" ], "method_dependencies": [] } }, { "method_name": "get_primes", "method_description": "def get_primes(self):\n \"\"\"\n Get the list of generated prime numbers.\n :return: list, a list of prime numbers\n >>> cs = ChandrasekharSieve(20)\n >>> cs.get_primes()\n [2, 3, 5, 7, 11, 13, 17, 19]\n\n \"\"\"", "test_class": "ChandrasekharSieveTestGetPrimes", "test_code": "class ChandrasekharSieveTestGetPrimes(unittest.TestCase):\n def test_get_primes_1(self):\n cs = ChandrasekharSieve(20)\n cs.generate_primes()\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\n\n def test_get_primes_2(self):\n cs = ChandrasekharSieve(18)\n cs.generate_primes()\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17])\n\n def test_get_primes_3(self):\n cs = ChandrasekharSieve(15)\n cs.generate_primes()\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13])\n\n def test_get_primes_4(self):\n cs = ChandrasekharSieve(10)\n cs.generate_primes()\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7])\n\n def test_get_primes_5(self):\n cs = ChandrasekharSieve(1)\n res = cs.get_primes()\n self.assertEqual(res, [])", "solution_code": "def get_primes(self):\n return self.primes", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.primes" ], "method_dependencies": [] } } ]

[ "ChandrasekharSieveTestGeneratePrimes", "ChandrasekharSieveTestGetPrimes", "ChandrasekharSieveTest" ]

[ "self.n", "self.primes" ]

[ "from datetime import datetime" ]

[ { "method_name": "add_user", "method_description": "def add_user(self, username):\n \"\"\"\n Add a new user to the Chat.\n :param username: The user's name, str.\n :return: If the user is already in the Chat, returns False, otherwise, returns True.\n >>> chat = Chat()\n >>> chat.add_user('John')\n True\n self.users = {'John': []}\n >>> chat.add_user('John')\n False\n\n \"\"\"", "test_class": "ChatTestAddUser", "test_code": "class ChatTestAddUser(unittest.TestCase):\n def test_add_user(self):\n chat = Chat()\n self.assertEqual(chat.add_user('John'), True)\n self.assertEqual(chat.users, {'John': []})\n def test_add_user_2(self):\n chat = Chat()\n chat.users = {'John': []}\n self.assertEqual(chat.add_user('John'), False)\n self.assertEqual(chat.users, {'John': []})\n\n def test_add_user_3(self):\n chat = Chat()\n chat.users = {'John': []}\n self.assertEqual(chat.add_user('Mary'), True)\n self.assertEqual(chat.users, {'John': [], 'Mary': []})\n\n def test_add_user_4(self):\n chat = Chat()\n chat.users = {'John': []}\n self.assertEqual(chat.add_user('Mary'), True)\n self.assertEqual(chat.users, {'John': [], 'Mary': []})\n\n def test_add_user_5(self):\n chat = Chat()\n self.assertEqual(chat.add_user('John'), True)\n self.assertEqual(chat.add_user('Mary'), True)\n self.assertEqual(chat.users, {'John': [], 'Mary': []})", "solution_code": "def add_user(self, username):\n if username in self.users:\n return False\n else:\n self.users[username] = []\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.users" ], "method_dependencies": [] } }, { "method_name": "remove_user", "method_description": "def remove_user(self, username):\n \"\"\"\n Remove a user from the Chat.\n :param username: The user's name, str.\n :return: If the user is already in the Chat, returns True, otherwise, returns False.\n >>> chat = Chat()\n >>> chat.users = {'John': []}\n >>> chat.remove_user('John')\n True\n >>> chat.remove_user('John')\n False\n\n \"\"\"", "test_class": "ChatTestRemoveUser", "test_code": "class ChatTestRemoveUser(unittest.TestCase):\n def test_remove_user(self):\n chat = Chat()\n chat.users = {'John': []}\n self.assertEqual(chat.remove_user('John'), True)\n self.assertEqual(chat.users, {})\n def test_remove_user_2(self):\n chat = Chat()\n self.assertEqual(chat.remove_user('John'), False)\n self.assertEqual(chat.users, {})\n\n def test_remove_user_3(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.remove_user('John'), True)\n self.assertEqual(chat.users, {'Mary': []})\n\n def test_remove_user_4(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.remove_user('Mary'), True)\n self.assertEqual(chat.remove_user('John'), True)\n self.assertEqual(chat.users, {})\n\n def test_remove_user_5(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.remove_user('Amy'), False)\n self.assertEqual(chat.users, {'John': [], 'Mary': []})", "solution_code": "def remove_user(self, username):\n if username in self.users:\n del self.users[username]\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.users" ], "method_dependencies": [] } }, { "method_name": "send_message", "method_description": "def send_message(self, sender, receiver, message):\n \"\"\"\n Send a message from a user to another user.\n :param sender: The sender's name, str.\n :param receiver: The receiver's name, str.\n :param message: The message, str.\n :return: If the sender or the receiver is not in the Chat, returns False, otherwise, returns True.\n >>> chat = Chat()\n >>> chat.users = {'John': [], 'Mary': []}\n >>> chat.send_message('John', 'Mary', 'Hello')\n True\n >>> chat.send_message('John', 'Tom', 'Hello')\n False\n\n \"\"\"", "test_class": "ChatTestSendMessage", "test_code": "class ChatTestSendMessage(unittest.TestCase):\n def test_send_message(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.assertEqual(chat.send_message('John', 'Mary', 'Hello'), True)\n self.assertEqual(chat.users, {'John': [{'sender': 'John', 'receiver': 'Mary', 'message': 'Hello', 'timestamp': timestamp}], 'Mary': [{'sender': 'John', 'receiver': 'Mary', 'message': 'Hello', 'timestamp': timestamp}]})\n\n def test_send_message_2(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.send_message('John', 'Tom', 'Hello'), False)\n self.assertEqual(chat.users, {'John': [], 'Mary': []})\n\n def test_send_message_3(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.send_message('Amy', 'Mary', 'Hello'), False)\n self.assertEqual(chat.users, {'John': [], 'Mary': []})\n\n def test_send_message_4(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.send_message('Amy', 'Tom', 'Hello'), False)\n self.assertEqual(chat.users, {'John': [], 'Mary': []})\n\n def test_send_message_5(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.send_message('Amy', 'Amy', 'Hello'), False)\n self.assertEqual(chat.users, {'John': [], 'Mary': []})", "solution_code": "def send_message(self, sender, receiver, message):\n if sender not in self.users or receiver not in self.users:\n return False\n\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n message_info = {\n 'sender': sender,\n 'receiver': receiver,\n 'message': message,\n 'timestamp': timestamp\n }\n self.users[sender].append(message_info)\n self.users[receiver].append(message_info)\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime" ], "field_dependencies": [ "self.users" ], "method_dependencies": [] } }, { "method_name": "get_messages", "method_description": "def get_messages(self, username):\n \"\"\"\n Get all the messages of a user from the Chat.\n :param username: The user's name, str.\n :return: A list of messages, each message is a dictionary with keys 'sender', 'receiver', 'message', 'timestamp'.\n >>> chat = Chat()\n >>> chat.users = {'John': [{'sender': 'John', 'receiver': 'Mary', 'message': 'Hello', 'timestamp': '2023-01-01 00:00:00'}]}\n >>> chat.get_messages('John')\n [{'sender': 'John', 'receiver': 'Mary', 'message': 'Hello', 'timestamp': '2023-01-01 00:00:00'}]\n >>> chat.get_messages('Mary')\n []\n\n \"\"\"", "test_class": "ChatTestGetMessages", "test_code": "class ChatTestGetMessages(unittest.TestCase):\n def test_get_messages(self):\n chat = Chat()\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n chat.users = {'John': [{'sender': 'John', 'receiver': 'Mary', 'message': 'Hello', 'timestamp': timestamp}]}\n self.assertEqual(chat.get_messages('John'), [{'sender': 'John', 'receiver': 'Mary', 'message': 'Hello', 'timestamp': timestamp}])\n\n def test_get_messages_2(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.get_messages('John'), [])\n\n def test_get_messages_3(self):\n chat = Chat()\n chat.users = {'John': [], 'Mary': []}\n self.assertEqual(chat.get_messages('Amy'), [])\n\n def test_get_messages_4(self):\n chat = Chat()\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n chat.users = {'John': [{'sender': 'John', 'receiver': 'Mary', 'message': 'Hello', 'timestamp': timestamp}]}\n self.assertEqual(chat.get_messages('Mary'), [])\n\n def test_get_messages_5(self):\n chat = Chat()\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n chat.users = {'John': [{'sender': 'John', 'receiver': 'Mary', 'message': 'Hello', 'timestamp': timestamp}]}\n self.assertEqual(chat.get_messages('Amy'), [])", "solution_code": "def get_messages(self, username):\n if username not in self.users:\n return []\n return self.users[username]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.users" ], "method_dependencies": [] } } ]

[ "ChatTestAddUser", "ChatTestRemoveUser", "ChatTestSendMessage", "ChatTestGetMessages", "ChatTestMain" ]

[ "self.users" ]

[ "from datetime import datetime" ]

[ { "method_name": "add_course", "method_description": "def add_course(self, course):\n \"\"\"\n Add course to self.courses list if the course wasn't in it.\n :param course: dict, information of the course, including 'start_time', 'end_time' and 'name'\n >>> classroom = Classroom(1)\n >>> classroom.add_course({'name': 'math', 'start_time': '8:00', 'end_time': '9:40'})\n \"\"\"", "test_class": "ClassroomTestAddCourse", "test_code": "class ClassroomTestAddCourse(unittest.TestCase):\n def test_add_course_1(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_2(self):\n classroom = Classroom(1)\n course = {'name': 'Chinese', 'start_time': '10:00', 'end_time': '11:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_3(self):\n classroom = Classroom(1)\n course = {'name': 'English', 'start_time': '11:00', 'end_time': '12:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_4(self):\n classroom = Classroom(1)\n course = {'name': 'Art', 'start_time': '14:00', 'end_time': '15:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_5(self):\n classroom = Classroom(1)\n course = {'name': 'P.E.', 'start_time': '15:00', 'end_time': '16:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_6(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)", "solution_code": "def add_course(self, course):\n\n if course not in self.courses:\n self.courses.append(course)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.courses" ], "method_dependencies": [] } }, { "method_name": "remove_course", "method_description": "def remove_course(self, course):\n \"\"\"\n Remove course from self.courses list if the course was in it.\n :param course: dict, information of the course, including 'start_time', 'end_time' and 'name'\n >>> classroom = Classroom(1)\n >>> classroom.add_course({'name': 'math', 'start_time': '8:00', 'end_time': '9:40'})\n >>> classroom.add_course({'name': 'math', 'start_time': '8:00', 'end_time': '9:40'})\n \"\"\"", "test_class": "ClassroomTestRemoveCourse", "test_code": "class ClassroomTestRemoveCourse(unittest.TestCase):\n def test_remove_course_1(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_2(self):\n classroom = Classroom(1)\n course = {'name': 'Chinese', 'start_time': '10:00', 'end_time': '11:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_3(self):\n classroom = Classroom(1)\n course = {'name': 'English', 'start_time': '11:00', 'end_time': '12:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_4(self):\n classroom = Classroom(1)\n course = {'name': 'Art', 'start_time': '14:00', 'end_time': '15:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_5(self):\n classroom = Classroom(1)\n course = {'name': 'P.E.', 'start_time': '15:00', 'end_time': '16:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_6(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)", "solution_code": "def remove_course(self, course):\n if course in self.courses:\n self.courses.remove(course)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.courses" ], "method_dependencies": [] } }, { "method_name": "is_free_at", "method_description": "def is_free_at(self, check_time):\n \"\"\"\n change the time format as '%H:%M' and check the time is free or not in the classroom.\n :param check_time: str, the time need to be checked\n :return: True if the check_time does not conflict with every course time, or False otherwise.\n >>> classroom = Classroom(1)\n >>> classroom.add_course({'name': 'math', 'start_time': '8:00', 'end_time': '9:40'})\n >>> classroom.is_free_at('10:00')\n True\n >>> classroom.is_free_at('9:00')\n False\n \"\"\"", "test_class": "ClassroomTestIsFreeAt", "test_code": "class ClassroomTestIsFreeAt(unittest.TestCase):\n def test_is_free_at_1(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '11:00'\n result = classroom.is_free_at(check_time)\n self.assertTrue(result)\n\n def test_is_free_at_2(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '09:30'\n result = classroom.is_free_at(check_time)\n self.assertFalse(result)\n\n def test_is_free_at_3(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '12:00'\n result = classroom.is_free_at(check_time)\n self.assertTrue(result)\n\n def test_is_free_at_4(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '14:00'\n result = classroom.is_free_at(check_time)\n self.assertTrue(result)\n\n def test_is_free_at_5(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '09:40'\n result = classroom.is_free_at(check_time)\n self.assertFalse(result)", "solution_code": "def is_free_at(self, check_time):\n check_time = datetime.strptime(check_time, '%H:%M')\n\n for course in self.courses:\n if datetime.strptime(course['start_time'], '%H:%M') <= check_time <= datetime.strptime(course['end_time'],\n '%H:%M'):\n return False\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime" ], "field_dependencies": [ "self.courses" ], "method_dependencies": [] } }, { "method_name": "check_course_conflict", "method_description": "def check_course_conflict(self, new_course):\n \"\"\"\n Before adding a new course, check if the new course time conflicts with any other course.\n :param new_course: dict, information of the course, including 'start_time', 'end_time' and 'name'\n :return: False if the new course time conflicts(including two courses have the same boundary time) with other courses, or True otherwise.\n >>> classroom = Classroom(1)\n >>> classroom.add_course({'name': 'math', 'start_time': '8:00', 'end_time': '9:40'})\n >>> classroom.check_course_conflict({'name': 'SE', 'start_time': '9:40', 'end_time': '10:40'})\n False\n \"\"\"", "test_class": "ClassroomTestCheckCourseConflict", "test_code": "class ClassroomTestCheckCourseConflict(unittest.TestCase):\n def test_check_course_conflict_1(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '10:30', 'end_time': '11:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertTrue(result)\n\n def test_check_course_conflict_2(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '09:30', 'end_time': '10:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)\n\n # have the same boundary time\n # existing_course['end_time'] == new_course['start_time']\n def test_check_course_conflict_3(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '10:00', 'end_time': '11:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)\n\n def test_check_course_conflict_4(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '09:40', 'end_time': '10:40'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)\n\n def test_check_course_conflict_5(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '14:30', 'end_time': '15:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertTrue(result)\n\n def test_check_course_conflict_6(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '8:30', 'end_time': '9:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)", "solution_code": "def check_course_conflict(self, new_course):\n new_start_time = datetime.strptime(new_course['start_time'], '%H:%M')\n new_end_time = datetime.strptime(new_course['end_time'], '%H:%M')\n\n flag = True\n for course in self.courses:\n start_time = datetime.strptime(course['start_time'], '%H:%M')\n end_time = datetime.strptime(course['end_time'], '%H:%M')\n if start_time <= new_start_time and end_time >= new_start_time:\n flag = False\n if start_time <= new_end_time and end_time >= new_end_time:\n flag = False\n return flag", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime" ], "field_dependencies": [ "self.courses" ], "method_dependencies": [] } } ]

[ "ClassroomTestAddCourse", "ClassroomTestRemoveCourse", "ClassroomTestIsFreeAt", "ClassroomTestCheckCourseConflict", "ClassroomTestMain" ]

[ "self.courses", "self.id" ]

[]

[ { "method_name": "register_student", "method_description": "def register_student(self, student):\n \"\"\"\n register a student to the system, add the student to the students list, if the student is already registered, return 0, else return 1\n \"\"\"", "test_class": "ClassRegistrationSystemTestRegisterStudent", "test_code": "class ClassRegistrationSystemTestRegisterStudent(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_register_student(self):\n student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\n self.assertEqual(self.registration_system.register_student(student1), 1)\n\n def test_register_student2(self):\n student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\n self.registration_system.register_student(student1)\n self.assertEqual(self.registration_system.register_student(student1), 0)\n\n def test_register_student3(self):\n student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\n student2 = {\"name\": \"Alice\", \"major\": \"Mathematics\"}\n self.assertEqual(self.registration_system.register_student(student1), 1)\n self.assertEqual(self.registration_system.register_student(student2), 1)\n self.assertEqual(self.registration_system.register_student(student2), 0)", "solution_code": "def register_student(self, student):\n if student in self.students:\n return 0\n else:\n self.students.append(student)\n return 1", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [] } }, { "method_name": "register_class", "method_description": "def register_class(self, student_name, class_name):\n \"\"\"\n register a class to the student.\n :param student_name: str\n :param class_name: str\n :return a list of class names that the student has registered\n >>> registration_system = ClassRegistrationSystem()\n >>> registration_system.register_class(student_name=\"John\", class_name=\"CS101\")\n >>> registration_system.register_class(student_name=\"John\", class_name=\"CS102\")\n [\"CS101\", \"CS102\"]", "test_class": "ClassRegistrationSystemTestRegisterClass", "test_code": "class ClassRegistrationSystemTestRegisterClass(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_register_class(self):\n self.assertEqual(self.registration_system.register_class(student_name=\"John\", class_name=\"CS101\"), [\"CS101\"])\n\n def test_register_class2(self):\n self.registration_system.register_class(student_name=\"John\", class_name=\"CS101\")\n self.registration_system.register_class(student_name=\"John\", class_name=\"CS102\")\n self.assertEqual(self.registration_system.register_class(student_name=\"John\", class_name=\"CS103\"), [\"CS101\", \"CS102\", \"CS103\"])\n\n def test_register_class3(self):\n self.registration_system.register_class(student_name=\"John\", class_name=\"CS101\")\n self.registration_system.register_class(student_name=\"Tom\", class_name=\"CS102\")\n self.assertEqual(self.registration_system.register_class(student_name=\"John\", class_name=\"CS103\"), [\"CS101\", \"CS103\"])", "solution_code": "def register_class(self, student_name, class_name):\n if student_name in self.students_registration_classes:\n self.students_registration_classes[student_name].append(class_name)\n else:\n self.students_registration_classes[student_name] = [class_name]\n return self.students_registration_classes[student_name]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students", "self.students_registration_classes" ], "method_dependencies": [] } }, { "method_name": "get_students_by_major", "method_description": "def get_students_by_major(self, major):\n \"\"\"\n get all students in the major\n :param major: str\n :return a list of student name\n >>> registration_system = ClassRegistrationSystem()\n >>> student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\n >>> registration_system.register_student(student1)\n >>> registration_system.get_students_by_major(\"Computer Science\")\n [\"John\"]\n \"\"\"", "test_class": "ClassRegistrationSystemTestGetStudent", "test_code": "class ClassRegistrationSystemTestGetStudent(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_get_students_by_major(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"}]\n\n cs_students = self.registration_system.get_students_by_major(\"Computer Science\")\n\n self.assertEqual(cs_students, [\"John\", \"Bob\"])\n\n def test_get_students_by_major2(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"}]\n\n cs_students = self.registration_system.get_students_by_major(\"Computer Science\")\n math_students = self.registration_system.get_students_by_major(\"Mathematics\")\n\n self.assertEqual(cs_students, [\"John\", \"Bob\"])\n self.assertEqual(math_students, [])\n\n def test_get_students_by_major3(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Mathematics\"}]\n\n cs_students = self.registration_system.get_students_by_major(\"Computer Science\")\n math_students = self.registration_system.get_students_by_major(\"Mathematics\")\n\n self.assertEqual(cs_students, [\"John\", \"Bob\"])\n self.assertEqual(math_students, [\"Alice\"])\n\n def test_get_students_by_major4(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Mathematics\"},\n {\"name\": \"Tom\", \"major\": \"Mathematics\"},\n {\"name\": \"Jerry\", \"major\": \"Mathematics\"}]\n\n cs_students = self.registration_system.get_students_by_major(\"Computer Science\")\n math_students = self.registration_system.get_students_by_major(\"Mathematics\")\n self.assertEqual(cs_students, [\"John\", \"Bob\"])\n self.assertEqual(math_students, [\"Alice\", \"Tom\", \"Jerry\"])", "solution_code": "def get_students_by_major(self, major):\n student_list = []\n for student in self.students:\n if student[\"major\"] == major:\n student_list.append(student[\"name\"])\n return student_list", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [] } }, { "method_name": "get_all_major", "method_description": "def get_all_major(self):\n \"\"\"\n get all majors in the system\n :return a list of majors\n >>> registration_system = ClassRegistrationSystem()\n >>> registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"}],\n >>> registration_system.get_all_major(student1)\n [\"Computer Science\"]\n \"\"\"", "test_class": "ClassRegistrationSystemTestGetMajor", "test_code": "class ClassRegistrationSystemTestGetMajor(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_get_all_major(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"}]\n\n majors = self.registration_system.get_all_major()\n\n self.assertEqual(majors, [\"Computer Science\"])\n\n def test_get_all_major2(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Mathematics\"}]\n\n majors = self.registration_system.get_all_major()\n\n self.assertEqual(majors, [\"Computer Science\", \"Mathematics\"])\n\n def test_get_all_major3(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Mathematics\"},\n {\"name\": \"Tom\", \"major\": \"Mathematics\"},\n {\"name\": \"Jerry\", \"major\": \"Physics\"}]\n\n majors = self.registration_system.get_all_major()\n\n self.assertEqual(majors, [\"Computer Science\", \"Mathematics\", \"Physics\"])", "solution_code": "def get_all_major(self):\n major_list = []\n for student in self.students:\n if student[\"major\"] not in major_list:\n major_list.append(student[\"major\"])\n return major_list", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students" ], "method_dependencies": [] } }, { "method_name": "get_most_popular_class_in_major", "method_description": "def get_most_popular_class_in_major(self, major):\n \"\"\"\n get the class with the highest enrollment in the major.\n :return a string of the most popular class in this major\n >>> registration_system = ClassRegistrationSystem()\n >>> registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Computer Science\"}]\n >>> registration_system.students_registration_classes = {\"John\": [\"Algorithms\", \"Data Structures\"],\n \"Bob\": [\"Operating Systems\", \"Data Structures\", \"Algorithms\"]}\n >>> registration_system.get_most_popular_class_in_major(\"Computer Science\")\n \"Data Structures\"\n \"\"\"", "test_class": "ClassRegistrationSystemTestPopularClass", "test_code": "class ClassRegistrationSystemTestPopularClass(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_get_most_popular_class_in_major(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Computer Science\"}]\n\n self.registration_system.students_registration_classes = {\"John\": [\"Algorithms\", \"Data Structures\"],\n \"Bob\": [\"Operating Systems\", \"Data Structures\", \"Algorithms\"],\n \"Alice\": [\"Data Structures\", \"Operating Systems\", \"Calculus\"]}\n\n cs_most_popular_class = self.registration_system.get_most_popular_class_in_major(\"Computer Science\")\n\n self.assertEqual(cs_most_popular_class, \"Data Structures\")\n\n def test_get_most_popular_class_in_major2(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Computer Science\"},\n {\"name\": \"Tom\", \"major\": \"Mathematics\"},\n {\"name\": \"Jerry\", \"major\": \"Mathematics\"}]\n\n self.registration_system.students_registration_classes = {\"John\": [\"Algorithms\", \"Data Structures\"],\n \"Bob\": [\"Data Structures\", \"Algorithms\",\n \"Operating Systems\"],\n \"Alice\": [\"Data Structures\", \"Operating Systems\",\n \"Calculus\"],\n \"Tom\": [\"Calculus\", \"Linear Algebra\"],\n \"Jerry\": [\"Linear Algebra\", \"Statistics\"]}\n\n cs_most_popular_class = self.registration_system.get_most_popular_class_in_major(\"Computer Science\")\n math_most_popular_class = self.registration_system.get_most_popular_class_in_major(\"Mathematics\")\n self.assertEqual(cs_most_popular_class, \"Data Structures\")\n self.assertEqual(math_most_popular_class, \"Linear Algebra\")", "solution_code": "def get_most_popular_class_in_major(self, major):\n class_list = []\n for student in self.students:\n if student[\"major\"] == major:\n class_list += self.students_registration_classes[student[\"name\"]]\n most_popular_class = max(set(class_list), key=class_list.count)\n return most_popular_class", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.students", "self.students_registration_classes" ], "method_dependencies": [] } } ]

[ "ClassRegistrationSystemTestRegisterStudent", "ClassRegistrationSystemTestRegisterClass", "ClassRegistrationSystemTestGetStudent", "ClassRegistrationSystemTestGetMajor", "ClassRegistrationSystemTestPopularClass", "ClassRegistrationSystemTest" ]

[ "self.students", "self.students_registration_classes" ]

[ "import math", "from typing import List" ]

[ { "method_name": "count", "method_description": "def count(n: int, m: int) -> int:\n \"\"\"\n Calculate the number of combinations for a specific count.\n :param n: The total number of elements,int.\n :param m: The number of elements in each combination,int.\n :return: The number of combinations,int.\n >>> CombinationCalculator.count(4, 2)\n 6\n \"\"\"", "test_class": "CombinationCalculatorTestCount", "test_code": "class CombinationCalculatorTestCount(unittest.TestCase):\n def test_count(self):\n self.assertEqual(CombinationCalculator.count(4, 2), 6)\n def test_count_2(self):\n self.assertEqual(CombinationCalculator.count(5, 3), 10)\n\n def test_count_3(self):\n self.assertEqual(CombinationCalculator.count(6, 6), 1)\n\n def test_count_4(self):\n self.assertEqual(CombinationCalculator.count(6, 0), 1)\n\n def test_count_5(self):\n self.assertEqual(CombinationCalculator.count(6, 3), 20)", "solution_code": "def count(n: int, m: int) -> int:\n if m == 0 or n == m:\n return 1\n return math.factorial(n) // (math.factorial(n - m) * math.factorial(m))", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "count_all", "method_description": "@staticmethod\n def count_all(n: int) -> int:\n \"\"\"\n Calculate the number of all possible combinations.\n :param n: The total number of elements,int.\n :return: The number of all possible combinations,int,if the number of combinations is greater than 2^63-1,return float(\"inf\").\n >>> CombinationCalculator.count_all(4)\n 15\n \"\"\"", "test_class": "CombinationCalculatorTestCountAll", "test_code": "class CombinationCalculatorTestCountAll(unittest.TestCase):\n def test_count_all(self):\n self.assertEqual(CombinationCalculator.count_all(4), 15)\n\n def test_count_all_2(self):\n self.assertEqual(CombinationCalculator.count_all(-1), False)\n\n def test_count_all_3(self):\n self.assertEqual(CombinationCalculator.count_all(65), False)\n\n def test_count_all_4(self):\n self.assertEqual(CombinationCalculator.count_all(0), 0)\n\n def test_count_all_5(self):\n self.assertEqual(CombinationCalculator.count_all(63), float(\"inf\"))", "solution_code": "@staticmethod\n def count_all(n: int) -> int:\n if n < 0 or n > 63:\n return False\n return (1 << n) - 1 if n != 63 else float(\"inf\")", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "select", "method_description": "def select(self, m: int) -> List[List[str]]:\n \"\"\"\n Generate combinations with a specified number of elements.\n :param m: The number of elements in each combination,int.\n :return: A list of combinations,List[List[str]].\n >>> calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n >>> calc.select(2)\n [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']]\n\n \"\"\"", "test_class": "CombinationCalculatorTestSelect", "test_code": "class CombinationCalculatorTestSelect(unittest.TestCase):\n def test_select(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(4, 2), 6)\n\n def test_select_2(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(5, 3), 10)\n\n def test_select_3(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(6, 6), 1)\n\n def test_select_4(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(6, 0), 1)\n\n def test_select_5(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(6, 3), 20)", "solution_code": "def select(self, m: int) -> List[List[str]]:\n result = []\n self._select(0, [None] * m, 0, result)\n return result", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "_select" ] } }, { "method_name": "select_all", "method_description": "def select_all(self) -> List[List[str]]:\n \"\"\"\n Generate all possible combinations of selecting elements from the given data list,and it uses the select method.\n :return: A list of combinations,List[List[str]].\n >>> calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n >>> calc.select_all()\n [['A'], ['B'], ['C'], ['D'], ['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D'], ['A', 'B', 'C'], ['A', 'B', 'D'], ['A', 'C', 'D'], ['B', 'C', 'D'], ['A', 'B', 'C', 'D']]\n\n \"\"\"", "test_class": "CombinationCalculatorTestSelectAll", "test_code": "class CombinationCalculatorTestSelectAll(unittest.TestCase):\n def test_select_all(self):\n calc = CombinationCalculator([\"A\"])\n self.assertEqual(calc.select_all(), [['A']])\n\n def test_select_all_2(self):\n calc = CombinationCalculator([\"A\", \"B\"])\n self.assertEqual(calc.select_all(), [['A'], ['B'], ['A', 'B']])\n\n def test_select_all_3(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\"])\n self.assertEqual(calc.select_all(),[['A'], ['B'], ['C'], ['A', 'B'], ['A', 'C'], ['B', 'C'], ['A', 'B', 'C']])\n\n def test_select_all_4(self):\n calc = CombinationCalculator([])\n self.assertEqual(calc.select_all(),[])\n\n def test_select_all_5(self):\n calc = CombinationCalculator([\"B\"])\n self.assertEqual(calc.select_all(),[['B']])", "solution_code": "def select_all(self) -> List[List[str]]:\n result = []\n for i in range(1, len(self.datas) + 1):\n result.extend(self.select(i))\n return result", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.datas" ], "method_dependencies": [ "select" ] } }, { "method_name": "_select", "method_description": "def _select(self, dataIndex: int, resultList: List[str], resultIndex: int, result: List[List[str]]):\n \"\"\"\n Generate combinations with a specified number of elements by recursion.\n :param dataIndex: The index of the data to be selected,int.\n :param resultList: The list of elements in the combination,List[str].\n :param resultIndex: The index of the element in the combination,int.\n :param result: The list of combinations,List[List[str]].\n :return: None.\n >>> calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n >>> result = []\n >>> calc._select(0, [None] * 2, 0, result)\n >>> result\n [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']]\n\n \"\"\"", "test_class": "CombinationCalculatorTestSelect2", "test_code": "class CombinationCalculatorTestSelect2(unittest.TestCase):\n def test_select2(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 2, 0, result)\n self.assertEqual(result, [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']])\n\n def test_select2_2(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 3, 0, result)\n self.assertEqual(result, [['A', 'B', 'C'], ['A', 'B', 'D'], ['A', 'C', 'D'], ['B', 'C', 'D']])\n\n def test_select2_3(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 1, 0, result)\n self.assertEqual(result, [['A'], ['B'], ['C'], ['D']])\n\n def test_select2_4(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 0, 0, result)\n self.assertEqual(result, [[]])\n\n def test_select2_5(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 4, 0, result)\n self.assertEqual(result, [['A', 'B', 'C', 'D']])", "solution_code": "def _select(self, dataIndex: int, resultList: List[str], resultIndex: int, result: List[List[str]]):\n resultLen = len(resultList)\n resultCount = resultIndex + 1\n if resultCount > resultLen:\n result.append(resultList.copy())\n return\n\n for i in range(dataIndex, len(self.datas) + resultCount - resultLen):\n resultList[resultIndex] = self.datas[i]\n self._select(i + 1, resultList, resultIndex + 1, result)", "dependencies": { "Standalone": false, "lib_dependencies": [ "List" ], "field_dependencies": [ "self.datas" ], "method_dependencies": [ "select" ] } } ]

[ "CombinationCalculatorTestCount", "CombinationCalculatorTestCountAll", "CombinationCalculatorTestSelect", "CombinationCalculatorTestSelectAll", "CombinationCalculatorTestSelect2", "CombinationCalculatorTestMain" ]

[ "self.datas" ]

[]

[ { "method_name": "add", "method_description": "def add(c1, c2):\n \"\"\"\n Adds two complex numbers.\n :param c1: The first complex number,complex.\n :param c2: The second complex number,complex.\n :return: The sum of the two complex numbers,complex.\n >>> complexCalculator = ComplexCalculator()\n >>> complexCalculator.add(1+2j, 3+4j)\n (4+6j)\n\n \"\"\"", "test_class": "ComplexCalculatorTestAdd", "test_code": "class ComplexCalculatorTestAdd(unittest.TestCase):\n def test_add(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(1+2j, 3+4j), (4+6j))\n\n def test_add_2(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(-1 - 2j, -3 - 4j), (-4 - 6j))\n\n def test_add_3(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(1-2j, 3-4j), (4-6j))\n\n def test_add_4(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(-1+2j, -3+4j), (-4+6j))\n\n def test_add_5(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(1+2j, -1-2j), (0+0j))", "solution_code": "def add(c1, c2):\n real = c1.real + c2.real\n imaginary = c1.imag + c2.imag\n answer = complex(real, imaginary)\n return answer", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "subtract", "method_description": "@staticmethod\n def subtract(c1, c2):\n \"\"\"\n Subtracts two complex numbers.\n :param c1: The first complex number,complex.\n :param c2: The second complex number,complex.\n :return: The difference of the two complex numbers,complex.\n >>> complexCalculator = ComplexCalculator()\n >>> complexCalculator.subtract(1+2j, 3+4j)\n (-2-2j)\n\n \"\"\"", "test_class": "ComplexCalculatorTestSubtract", "test_code": "class ComplexCalculatorTestSubtract(unittest.TestCase):\n def test_subtract(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(1+2j, 3+4j), (-2-2j))\n\n def test_subtract_2(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(-1-2j, -3-4j), (2+2j))\n\n def test_subtract_3(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(1-2j, 3-4j), (-2+2j))\n\n def test_subtract_4(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(-1+2j, -3+4j), (2-2j))\n\n def test_subtract_5(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(1+2j, 1+2j), (0+0j))", "solution_code": "@staticmethod\n def subtract(c1, c2):\n real = c1.real - c2.real\n imaginary = c1.imag - c2.imag\n return complex(real, imaginary)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "multiply", "method_description": "@staticmethod\n def multiply(c1, c2):\n \"\"\"\n Multiplies two complex numbers.\n :param c1: The first complex number,complex.\n :param c2: The second complex number,complex.\n :return: The product of the two complex numbers,complex.\n >>> complexCalculator = ComplexCalculator()\n >>> complexCalculator.multiply(1+2j, 3+4j)\n (-5+10j)\n\n \"\"\"", "test_class": "ComplexCalculatorTestMultiply", "test_code": "class ComplexCalculatorTestMultiply(unittest.TestCase):\n def test_multiply(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(1+2j, 3+4j), (-5+10j))\n\n def test_multiply_2(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(-1-2j, -3-4j), (-5+10j))\n\n def test_multiply_3(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(1-2j, 3-4j), (-5-10j))\n\n def test_multiply_4(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(-1+2j, -3+4j), (-5-10j))\n\n def test_multiply_5(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(1+2j, -1-2j), (3-4j))", "solution_code": "@staticmethod\n def multiply(c1, c2):\n real = c1.real * c2.real - c1.imag * c2.imag\n imaginary = c1.real * c2.imag + c1.imag * c2.real\n return complex(real, imaginary)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "divide", "method_description": "@staticmethod\n def divide(c1, c2):\n \"\"\"\n Divides two complex numbers.\n :param c1: The first complex number,complex.\n :param c2: The second complex number,complex.\n :return: The quotient of the two complex numbers,complex.\n >>> complexCalculator = ComplexCalculator()\n >>> complexCalculator.divide(1+2j, 3+4j)\n (0.44+0.08j)\n\n \"\"\"", "test_class": "ComplexCalculatorTestDivide", "test_code": "class ComplexCalculatorTestDivide(unittest.TestCase):\n def test_divide(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(1+2j, 3+4j), (0.44+0.08j))\n\n def test_divide_2(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(-1-2j, -3-4j), (0.44+0.08j))\n\n def test_divide_3(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(1-2j, 3-4j), (0.44-0.08j))\n\n def test_divide_4(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(-1+2j, -3+4j), (0.44-0.08j))\n\n def test_divide_5(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(1+2j, -1-2j), (-1+0j))", "solution_code": "@staticmethod\n def divide(c1, c2):\n denominator = c2.real**2 + c2.imag**2\n real = (c1.real * c2.real + c1.imag * c2.imag) / denominator\n imaginary = (c1.imag * c2.real - c1.real * c2.imag) / denominator\n return complex(real, imaginary)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "ComplexCalculatorTestAdd", "ComplexCalculatorTestSubtract", "ComplexCalculatorTestMultiply", "ComplexCalculatorTestDivide", "ComplexCalculatorTestMain" ]

[]

[ "import json" ]

[ { "method_name": "get_cookies", "method_description": "def get_cookies(self, reponse):\n \"\"\"\n Gets the cookies from the specified response,and save it to cookies_file.\n :param reponse: The response to get cookies from, dict.\n >>> cookies_util = CookiesUtil('cookies.json')\n >>> cookies_util.get_cookies({'cookies': {'key1': 'value1', 'key2': 'value2'}})\n >>> cookies_util.cookies\n {'key1': 'value1', 'key2': 'value2'}\n\n \"\"\"", "test_class": "CookiesUtilTestGetCookies", "test_code": "class CookiesUtilTestGetCookies(unittest.TestCase):\n\n def test_get_cookies(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.response = {'cookies': {'key1': 'value1', 'key2': 'value2'}}\n self.cookies_util.get_cookies(self.response)\n self.assertEqual(self.cookies_util.cookies, {'key1': 'value1', 'key2': 'value2'})\n\n def test_get_cookies_2(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.response = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'}}\n self.cookies_util.get_cookies(self.response)\n self.assertEqual(self.cookies_util.cookies, {'key1': 'value1', 'key2': 'value2'})\n\n def test_get_cookies_3(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.response = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'},\n 'cookies3': {'key5': 'value5', 'key6': 'value6'}}\n self.cookies_util.get_cookies(self.response)\n self.assertEqual(self.cookies_util.cookies, {'key1': 'value1', 'key2': 'value2'})\n\n def test_get_cookies_4(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.response = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'},\n 'cookies3': {'key5': 'value5', 'key6': 'value6'},\n 'cookies4': {'key7': 'value7', 'key8': 'value8'}}\n self.cookies_util.get_cookies(self.response)\n self.assertEqual(self.cookies_util.cookies, {'key1': 'value1', 'key2': 'value2'})\n\n def test_get_cookies_5(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.response = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'},\n 'cookies3': {'key5': 'value5', 'key6': 'value6'},\n 'cookies4': {'key7': 'value7', 'key8': 'value8'},\n 'cookies5': {'key9': 'value9', 'key10': 'value10'}}\n self.cookies_util.get_cookies(self.response)\n self.assertEqual(self.cookies_util.cookies, {'key1': 'value1', 'key2': 'value2'})", "solution_code": "def get_cookies(self, reponse):\n self.cookies = reponse['cookies']\n self._save_cookies()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.cookies" ], "method_dependencies": [ "_save_cookies" ] } }, { "method_name": "load_cookies", "method_description": "def load_cookies(self):\n \"\"\"\n Loads the cookies from the cookies_file to the cookies data.\n :return: The cookies data, dict.\n >>> cookies_util = CookiesUtil('cookies.json')\n >>> cookies_util.load_cookies()\n {'key1': 'value1', 'key2': 'value2'}\n\n \"\"\"", "test_class": "CookiesUtilTestLoadCookies", "test_code": "class CookiesUtilTestLoadCookies(unittest.TestCase):\n\n def test_load_cookies(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.assertEqual(self.cookies_util.load_cookies(), {'key1': 'value1', 'key2': 'value2'})\n\n def test_load_cookies_2(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'}}\n self.assertEqual(self.cookies_util.load_cookies(), {'key1': 'value1', 'key2': 'value2'})\n\n def test_load_cookies_3(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'}}\n self.assertEqual(self.cookies_util.load_cookies(), {'key1': 'value1', 'key2': 'value2'})\n\n def test_load_cookies_4(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'},\n 'cookies3': {'key5': 'value5', 'key6': 'value6'}}\n self.assertEqual(self.cookies_util.load_cookies(), {'key1': 'value1', 'key2': 'value2'})\n\n def test_load_cookies_5(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'},\n 'cookies3': {'key5': 'value5', 'key6': 'value6'},\n 'cookies4': {'key7': 'value7', 'key8': 'value8'}}\n self.assertEqual(self.cookies_util.load_cookies(), {'key1': 'value1', 'key2': 'value2'})\n\n def test_load_cookies_6(self):\n self.cookies_util = CookiesUtil('')\n self.assertEqual(self.cookies_util.load_cookies(), {})", "solution_code": "def load_cookies(self):\n try:\n with open(self.cookies_file, 'r') as file:\n cookies_data = json.load(file)\n return cookies_data\n except FileNotFoundError:\n return {}", "dependencies": { "Standalone": false, "lib_dependencies": [ "json" ], "field_dependencies": [ "self.cookies", "self.cookies_file" ], "method_dependencies": [] } }, { "method_name": "_save_cookies", "method_description": "def _save_cookies(self):\n \"\"\"\n Saves the cookies to the cookies_file, and returns True if successful, False otherwise.\n :return: True if successful, False otherwise.\n >>> cookies_util = CookiesUtil('cookies.json')\n >>> cookies_util.cookies = {'key1': 'value1', 'key2': 'value2'}\n >>> cookies_util._save_cookies()\n True\n\n \"\"\"", "test_class": "CookiesUtilTestSaveCookies", "test_code": "class CookiesUtilTestSaveCookies(unittest.TestCase):\n def setUp(self):\n self.cookies_util = CookiesUtil('cookies.json')\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'}}\n\n def test_save_cookies(self):\n self.assertTrue(self.cookies_util._save_cookies())\n\n def test_save_cookies_2(self):\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'}}\n self.assertTrue(self.cookies_util._save_cookies())\n\n def test_save_cookies_3(self):\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'},\n 'cookies3': {'key5': 'value5', 'key6': 'value6'}}\n self.assertTrue(self.cookies_util._save_cookies())\n\n def test_save_cookies_4(self):\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'},\n 'cookies3': {'key5': 'value5', 'key6': 'value6'},\n 'cookies4': {'key7': 'value7', 'key8': 'value8'}}\n self.assertTrue(self.cookies_util._save_cookies())\n\n def test_save_cookies_5(self):\n self.cookies_util.cookies = {'cookies': {'key1': 'value1', 'key2': 'value2'},\n 'cookies2': {'key3': 'value3', 'key4': 'value4'},\n 'cookies3': {'key5': 'value5', 'key6': 'value6'},\n 'cookies4': {'key7': 'value7', 'key8': 'value8'},\n 'cookies5': {'key9': 'value9', 'key10': 'value10'}}\n self.assertTrue(self.cookies_util._save_cookies())\n\n def test_save_cookies_6(self):\n self.cookies_util = CookiesUtil('')\n self.assertFalse(self.cookies_util._save_cookies())", "solution_code": "def _save_cookies(self):\n try:\n with open(self.cookies_file, 'w') as file:\n json.dump(self.cookies, file)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "json" ], "field_dependencies": [ "self.cookies", "self.cookies_file" ], "method_dependencies": [] } } ]

[ "CookiesUtilTestGetCookies", "CookiesUtilTestLoadCookies", "CookiesUtilTestSaveCookies", "CookiesUtilTestSetCookies", "CookiesUtilTestMain" ]

[ "self.cookies", "self.cookies_file" ]

[ "import csv" ]

[ { "method_name": "read_csv", "method_description": "def read_csv(self, file_name):\n \"\"\"\n Read the csv file by file_name, get the title and data from it\n :param file_name: str, name of the csv file\n :return title, data: (list, list), first row is title, the rest is data\n >>> csvProcessor = CSVProcessor()\n >>> csvProcessor.read_csv('read_test.csv')\n (['a', 'b', 'c', 'd'], [['hElLo', 'YoU', 'ME', 'LoW']])\n \"\"\"", "test_class": "CSVProcessorTestReadCSV", "test_code": "class CSVProcessorTestReadCSV(unittest.TestCase):\n def test_read_csv_1(self):\n self.file = 'read_test.csv'\n\n with open(self.file, 'w') as f:\n f.write('a,b,c,d\\nhElLo,YoU,ME,LoW')\n\n expected_title = ['a', 'b', 'c', 'd']\n expected_data = [['hElLo', 'YoU', 'ME', 'LoW']]\n csvProcessor = CSVProcessor()\n title, data = csvProcessor.read_csv(self.file)\n self.assertEqual(expected_data, data)\n self.assertEqual(expected_title, title)\n\n def test_read_csv_2(self):\n self.file = 'read_test.csv'\n with open(self.file, 'w') as f:\n f.write('1234\\nhElLo,YoU,ME,LoW')\n\n expected_title = ['1234']\n expected_data = [['hElLo', 'YoU', 'ME', 'LoW']]\n csvProcessor = CSVProcessor()\n title, data = csvProcessor.read_csv(self.file)\n self.assertEqual(expected_data, data)\n self.assertEqual(expected_title, title)\n\n def test_read_csv_3(self):\n self.file = 'read_test.csv'\n\n with open(self.file, 'w') as f:\n f.write('title\\nhElLo,YoU,ME,LoW')\n\n expected_title = ['title']\n expected_data = [['hElLo', 'YoU', 'ME', 'LoW']]\n csvProcessor = CSVProcessor()\n title, data = csvProcessor.read_csv(self.file)\n self.assertEqual(expected_data, data)\n self.assertEqual(expected_title, title)\n\n def test_read_csv_4(self):\n self.file = 'read_test.csv'\n\n with open(self.file, 'w') as f:\n f.write('title4\\nhElLo,YoU,ME,LoW')\n\n expected_title = ['title4']\n expected_data = [['hElLo', 'YoU', 'ME', 'LoW']]\n csvProcessor = CSVProcessor()\n title, data = csvProcessor.read_csv(self.file)\n self.assertEqual(expected_data, data)\n self.assertEqual(expected_title, title)\n\n def test_read_csv_5(self):\n self.file = 'read_test.csv'\n\n with open(self.file, 'w') as f:\n f.write('title5\\nhElLo,YoU,ME,LoW')\n\n expected_title = ['title5']\n expected_data = [['hElLo', 'YoU', 'ME', 'LoW']]\n csvProcessor = CSVProcessor()\n title, data = csvProcessor.read_csv(self.file)\n self.assertEqual(expected_data, data)\n self.assertEqual(expected_title, title)", "solution_code": "def read_csv(self, file_name):\n data = []\n with open(file_name, 'r') as file:\n reader = csv.reader(file)\n title = next(reader)\n for row in reader:\n data.append(row)\n return title, data", "dependencies": { "Standalone": false, "lib_dependencies": [ "csv" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "write_csv", "method_description": "def write_csv(self, data, file_name):\n \"\"\"\n Write data into a csv file.\n :param file_name: str, name of the csv file\n :return:int, if success return 1, or 0 otherwise\n >>> csvProcessor = CSVProcessor()\n >>> csvProcessor.write_csv([['a', 'b', 'c', 'd'], ['1', '2', '3', '4']], 'write_test.csv')\n 1\n \"\"\"", "test_class": "CSVProcessorTestWriteCSV", "test_code": "class CSVProcessorTestWriteCSV(unittest.TestCase):\n def test_write_csv_1(self):\n self.file = 'read_test.csv'\n\n file_path = self.file\n csvProcessor = CSVProcessor()\n data = [['a', 'b', 'c', 'd'], ['1', '2', '3', '4']]\n # assert return value\n self.assertEqual(1, csvProcessor.write_csv(data, file_path))\n\n # read to test if write correctly\n read_title, read_data = csvProcessor.read_csv(file_path)\n self.assertEqual(read_title, data[0])\n self.assertEqual(read_data[0], data[1])\n os.remove(file_path)\n\n def test_write_csv_2(self):\n self.file = 'read_test.csv'\n\n file_path = self.file\n csvProcessor = CSVProcessor()\n data = [['aa', 'bb', 'cc', 'dd'], ['1', '2', '3', '4']]\n # assert return value\n self.assertEqual(1, csvProcessor.write_csv(data, file_path))\n\n # read to test if write correctly\n read_title, read_data = csvProcessor.read_csv(file_path)\n self.assertEqual(read_title, data[0])\n self.assertEqual(read_data[0], data[1])\n os.remove(file_path)\n\n def test_write_csv_3(self):\n self.file = 'read_test.csv'\n\n file_path = self.file\n csvProcessor = CSVProcessor()\n data = [['a', 'b', 'c', 'd'], ['11', '22', '33', '44']]\n # assert return value\n self.assertEqual(1, csvProcessor.write_csv(data, file_path))\n\n # read to test if write correctly\n read_title, read_data = csvProcessor.read_csv(file_path)\n self.assertEqual(read_title, data[0])\n self.assertEqual(read_data[0], data[1])\n os.remove(file_path)\n\n def test_write_csv_4(self):\n self.file = 'read_test.csv'\n\n file_path = self.file\n csvProcessor = CSVProcessor()\n data = [['e', 'f', 'g', 'h'], ['1', '2', '3', '4']]\n # assert return value\n self.assertEqual(1, csvProcessor.write_csv(data, file_path))\n\n # read to test if write correctly\n read_title, read_data = csvProcessor.read_csv(file_path)\n self.assertEqual(read_title, data[0])\n self.assertEqual(read_data[0], data[1])\n os.remove(file_path)\n\n def test_write_csv_5(self):\n self.file = 'read_test.csv'\n\n file_path = self.file\n csvProcessor = CSVProcessor()\n data = [['a', 'b', 'c', 'd'], ['5', '6', '7', '8']]\n # assert return value\n self.assertEqual(1, csvProcessor.write_csv(data, file_path))\n\n # read to test if write correctly\n read_title, read_data = csvProcessor.read_csv(file_path)\n self.assertEqual(read_title, data[0])\n self.assertEqual(read_data[0], data[1])\n os.remove(file_path)\n\n def test_write_csv_6(self):\n self.file = ''\n file_path = self.file\n csvProcessor = CSVProcessor()\n # assert return value\n self.assertEqual(0, csvProcessor.write_csv([], file_path))", "solution_code": "def write_csv(self, data, file_name):\n try:\n with open(file_name, 'w', newline='') as file:\n writer = csv.writer(file)\n writer.writerows(data)\n return 1\n except:\n return 0", "dependencies": { "Standalone": false, "lib_dependencies": [ "csv" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "process_csv_data", "method_description": "def process_csv_data(self, N, save_file_name):\n \"\"\"\n Read a csv file into variable title and data.\n Only remain the N th (from 0) column data and Capitalize them, store the title and new data into a new csv file.\n Add '_process' suffix after old file name, as a new file name.\n :param N: int, the N th column(from 0)\n :param save_file_name, the name of file that needs to be processed.\n :return:int, if success return 1, or 0 otherwise\n >>> csvProcessor = CSVProcessor()\n >>> csvProcessor.read_csv('read_test.csv')\n (['a', 'b', 'c', 'd'], [['hElLo', 'YoU', 'ME', 'LoW']])\n >>> csvProcessor.process_csv_data(0, 'read_test.csv')\n 1\n >>> csvProcessor.read_csv('read_test_process.csv')\n (['a', 'b', 'c', 'd'], [['HELLO']])\n \"\"\"", "test_class": "CSVProcessorTestProcessCSVData", "test_code": "class CSVProcessorTestProcessCSVData(unittest.TestCase):\n def setUp(self) -> None:\n self.file = 'read_test.csv'\n self.file_process = 'read_test_process.csv'\n with open(self.file, 'w') as f:\n f.write('a,b,c,d\\nhElLo,YoU,ME,LoW,aBc')\n\n def test_process_csv_data_1(self):\n title = ['a', 'b', 'c', 'd']\n data = ['HELLO']\n csvProcessor = CSVProcessor()\n self.assertEqual(1, csvProcessor.process_csv_data(0, self.file))\n\n read_title, read_data = csvProcessor.read_csv(self.file_process)\n self.assertEqual(read_title, title)\n self.assertEqual(read_data[0], data)\n\n def test_process_csv_data_2(self):\n title = ['a', 'b', 'c', 'd']\n data = ['YOU']\n csvProcessor = CSVProcessor()\n self.assertEqual(1, csvProcessor.process_csv_data(1, self.file))\n\n read_title, read_data = csvProcessor.read_csv(self.file_process)\n self.assertEqual(read_title, title)\n self.assertEqual(read_data[0], data)\n\n def test_process_csv_data_3(self):\n title = ['a', 'b', 'c', 'd']\n data = ['ME']\n csvProcessor = CSVProcessor()\n self.assertEqual(1, csvProcessor.process_csv_data(2, self.file))\n\n read_title, read_data = csvProcessor.read_csv(self.file_process)\n self.assertEqual(read_title, title)\n self.assertEqual(read_data[0], data)\n\n def test_process_csv_data_4(self):\n title = ['a', 'b', 'c', 'd']\n data = ['LOW']\n csvProcessor = CSVProcessor()\n self.assertEqual(1, csvProcessor.process_csv_data(3, self.file))\n\n read_title, read_data = csvProcessor.read_csv(self.file_process)\n self.assertEqual(read_title, title)\n self.assertEqual(read_data[0], data)\n\n def test_process_csv_data_5(self):\n title = ['a', 'b', 'c', 'd']\n data = ['ABC']\n csvProcessor = CSVProcessor()\n self.assertEqual(1, csvProcessor.process_csv_data(4, self.file))\n\n read_title, read_data = csvProcessor.read_csv(self.file_process)\n self.assertEqual(read_title, title)\n self.assertEqual(read_data[0], data)", "solution_code": "def process_csv_data(self, N, save_file_name):\n title, data = self.read_csv(save_file_name)\n column_data = [row[N] for row in data]\n column_data = [row.upper() for row in column_data]\n new_data = [title, column_data]\n return self.write_csv(new_data, save_file_name.split('.')[0] + '_process.csv')", "dependencies": { "Standalone": false, "lib_dependencies": [ "csv" ], "field_dependencies": [], "method_dependencies": [ "read_csv", "write_csv" ] } } ]

[ "CSVProcessorTestReadCSV", "CSVProcessorTestWriteCSV", "CSVProcessorTestProcessCSVData", "CSVProcessorTestMain" ]

[]

[]

[ { "method_name": "convert", "method_description": "def convert(self, amount, from_currency, to_currency):\n \"\"\"\n Convert the value of a given currency to another currency type\n :param amount: float, The value of a given currency\n :param from_currency: string, source currency type\n :param to_currency: string, target currency type\n :return: float, value converted to another currency type\n >>> cc = CurrencyConverter()\n >>> cc.convert(64, 'CNY','USD')\n 10.0\n \"\"\"", "test_class": "CurrencyConverterTestConvert", "test_code": "class CurrencyConverterTestConvert(unittest.TestCase):\n def test_convert_1(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'CNY', 'USD')\n self.assertEqual(res, 10.0)\n\n def test_convert_2(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'USD', 'USD')\n self.assertEqual(res, 64)\n\n def test_convert_3(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'CNY', 'GBP')\n self.assertAlmostEqual(res, 7.1999999999999)\n\n def test_convert_4(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'USD', 'GBP')\n self.assertAlmostEqual(res, 46.08)\n\n def test_convert_5(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'USD', 'CAD')\n self.assertAlmostEqual(res, 78.72)\n\n def test_convert_6(self):\n cc = CurrencyConverter()\n res = cc.convert(64, '???', 'USD')\n self.assertFalse(res)", "solution_code": "def convert(self, amount, from_currency, to_currency):\n if from_currency == to_currency:\n return amount\n\n if from_currency not in self.rates or to_currency not in self.rates:\n return False\n\n from_rate = self.rates[from_currency]\n to_rate = self.rates[to_currency]\n\n converted_amount = (amount / from_rate) * to_rate\n return converted_amount", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.rates" ], "method_dependencies": [] } }, { "method_name": "get_supported_currencies", "method_description": "def get_supported_currencies(self):\n \"\"\"\n Returns a list of supported currency types\n :return:list, All supported currency types\n >>> cc = CurrencyConverter()\n >>> cc.get_supported_currencies()\n ['USD','EUR','GBP','JPY','CAD','AUD','CNY']\n \"\"\"", "test_class": "CurrencyConverterTestGetSupportedCurrencies", "test_code": "class CurrencyConverterTestGetSupportedCurrencies(unittest.TestCase):\n def test_get_supported_currencies_1(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n def test_get_supported_currencies_2(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n def test_get_supported_currencies_3(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n def test_get_supported_currencies_4(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n def test_get_supported_currencies_5(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])", "solution_code": "def get_supported_currencies(self):\n return list(self.rates.keys())", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.rates" ], "method_dependencies": [] } }, { "method_name": "add_currency_rate", "method_description": "def add_currency_rate(self, currency, rate):\n \"\"\"\n Add a new supported currency type, return False if the currency type is already in the support list\n :param currency:string, currency type to be added\n :param rate:float, exchange rate for this type of currency\n :return:If successful, returns None; if unsuccessful, returns False\n >>> cc = CurrencyConverter()\n >>> cc.add_currency_rate('KRW', 1308.84)\n self.rates['KRW'] = 1308.84\n \"\"\"", "test_class": "CurrencyConverterTestAddCurrencyRate", "test_code": "class CurrencyConverterTestAddCurrencyRate(unittest.TestCase):\n def test_add_currency_rate_1(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('KRW', 1308.84)\n self.assertEqual(cc.rates['KRW'], 1308.84)\n\n def test_add_currency_rate_2(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('aaa', 1.0)\n self.assertEqual(cc.rates['aaa'], 1.0)\n\n def test_add_currency_rate_3(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('bbb', 2.0)\n self.assertEqual(cc.rates['bbb'], 2.0)\n\n def test_add_currency_rate_4(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('ccc', 3.0)\n self.assertEqual(cc.rates['ccc'], 3.0)\n\n def test_add_currency_rate_5(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('ddd', 4.0)\n self.assertEqual(cc.rates['ddd'], 4.0)\n\n def test_add_currency_rate_6(self):\n cc = CurrencyConverter()\n res = cc.add_currency_rate('USD', 1.0)\n self.assertFalse(res)", "solution_code": "def add_currency_rate(self, currency, rate):\n if currency in self.rates:\n return False\n self.rates[currency] = rate", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.rates" ], "method_dependencies": [] } }, { "method_name": "update_currency_rate", "method_description": "def update_currency_rate(self, currency, new_rate):\n \"\"\"\n Update the exchange rate for a certain currency\n :param currency:string\n :param new_rate:float\n :return:If successful, returns None; if unsuccessful, returns False\n >>> cc = CurrencyConverter()\n >>> cc.update_currency_rate('CNY', 7.18)\n self.rates['CNY'] = 7.18\n \"\"\"", "test_class": "CurrencyConverterTestUpdateCurrencyRate", "test_code": "class CurrencyConverterTestUpdateCurrencyRate(unittest.TestCase):\n def test_update_currency_rate_1(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 7.18)\n self.assertEqual(cc.rates['CNY'], 7.18)\n\n def test_update_currency_rate_2(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 1.0)\n self.assertEqual(cc.rates['CNY'], 1.0)\n\n def test_update_currency_rate_3(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 2.0)\n self.assertEqual(cc.rates['CNY'], 2.0)\n\n def test_update_currency_rate_4(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 3.0)\n self.assertEqual(cc.rates['CNY'], 3.0)\n\n def test_update_currency_rate_5(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 4.0)\n self.assertEqual(cc.rates['CNY'], 4.0)\n\n def test_update_currency_rate_6(self):\n cc = CurrencyConverter()\n res = cc.update_currency_rate('???', 7.18)\n self.assertFalse(res)", "solution_code": "def update_currency_rate(self, currency, new_rate):\n if currency not in self.rates:\n return False\n self.rates[currency] = new_rate", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.rates" ], "method_dependencies": [] } } ]

[ "CurrencyConverterTestConvert", "CurrencyConverterTestGetSupportedCurrencies", "CurrencyConverterTestAddCurrencyRate", "CurrencyConverterTestUpdateCurrencyRate", "CurrencyConverterTest" ]

[ "self.rates" ]

[ "import sqlite3", "import pandas as pd" ]

[ { "method_name": "create_table", "method_description": "def create_table(self, table_name, key1, key2):\n \"\"\"\n Create a new table in the database if it doesn't exist.\n And make id (INTEGER) as PRIMARY KEY, make key1 as TEXT, key2 as INTEGER\n :param table_name: str, the name of the table to create.\n :param key1: str, the name of the first column in the table.\n :param key2: str, the name of the second column in the table.\n >>> db.create_table('user', 'name', 'age')\n \"\"\"", "test_class": "DatabaseProcessorTestCreateTable", "test_code": "class DatabaseProcessorTestCreateTable(unittest.TestCase):\n def setUp(self):\n self.database_name = \"test.db\"\n self.processor = DatabaseProcessor(self.database_name)\n\n def tearDown(self):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"DROP TABLE IF EXISTS test_table\")\n conn.commit()\n conn.close()\n\n def test_create_table_1(self):\n table_name = \"test_table\"\n self.processor.create_table(table_name, 'name', 'age')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table' AND name=?\", (table_name,))\n result = cursor.fetchone()\n conn.close()\n\n self.assertIsNotNone(result)\n self.assertEqual(result[0], table_name)\n\n def test_create_table_2(self):\n table_name = \"test_table2\"\n self.processor.create_table(table_name, 'name', 'age')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table' AND name=?\", (table_name,))\n result = cursor.fetchone()\n conn.close()\n\n self.assertIsNotNone(result)\n self.assertEqual(result[0], table_name)\n\n def test_create_table_3(self):\n table_name = \"test_table3\"\n self.processor.create_table(table_name, 'name', 'age')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table' AND name=?\", (table_name,))\n result = cursor.fetchone()\n conn.close()\n\n self.assertIsNotNone(result)\n self.assertEqual(result[0], table_name)\n\n def test_create_table_4(self):\n table_name = \"test_table4\"\n self.processor.create_table(table_name, 'name', 'age')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table' AND name=?\", (table_name,))\n result = cursor.fetchone()\n conn.close()\n\n self.assertIsNotNone(result)\n self.assertEqual(result[0], table_name)\n\n def test_create_table_5(self):\n table_name = \"test_table5\"\n self.processor.create_table(table_name, 'name', 'age')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table' AND name=?\", (table_name,))\n result = cursor.fetchone()\n conn.close()\n\n self.assertIsNotNone(result)\n self.assertEqual(result[0], table_name)", "solution_code": "def create_table(self, table_name, key1, key2):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n\n create_table_query = f\"CREATE TABLE IF NOT EXISTS {table_name} (id INTEGER PRIMARY KEY, {key1} TEXT, {key2} INTEGER)\"\n cursor.execute(create_table_query)\n\n conn.commit()\n conn.close()", "dependencies": { "Standalone": false, "lib_dependencies": [ "sqlite3" ], "field_dependencies": [ "self.database_name" ], "method_dependencies": [] } }, { "method_name": "insert_into_database", "method_description": "def insert_into_database(self, table_name, data):\n \"\"\"\n Insert data into the specified table in the database.\n :param table_name: str, the name of the table to insert data into.\n :param data: list, a list of dictionaries where each dictionary represents a row of data.\n >>> db.insert_into_database('user', [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ])\n \"\"\"", "test_class": "DatabaseProcessorTestInsertIntoDatabase", "test_code": "class DatabaseProcessorTestInsertIntoDatabase(unittest.TestCase):\n def setUp(self):\n self.database_name = \"test.db\"\n self.processor = DatabaseProcessor(self.database_name)\n\n def tearDown(self):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"DROP TABLE IF EXISTS test_table\")\n conn.commit()\n conn.close()\n\n def test_insert_into_database_1(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), len(data))\n self.assertEqual(result[0][2], 25)\n\n def test_insert_into_database_2(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 15},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), len(data))\n self.assertEqual(result[0][2], 15)\n\n def test_insert_into_database_3(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 16},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), len(data))\n self.assertEqual(result[0][2], 16)\n\n def test_insert_into_database_4(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 17},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), len(data))\n self.assertEqual(result[0][2], 17)\n\n def test_insert_into_database_5(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 18},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), len(data))\n self.assertEqual(result[0][2], 18)", "solution_code": "def insert_into_database(self, table_name, data):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n\n for item in data:\n insert_query = f\"INSERT INTO {table_name} (name, age) VALUES (?, ?)\"\n cursor.execute(insert_query, (item['name'], item['age']))\n\n conn.commit()\n conn.close()", "dependencies": { "Standalone": false, "lib_dependencies": [ "sqlite3" ], "field_dependencies": [ "self.database_name" ], "method_dependencies": [] } }, { "method_name": "search_database", "method_description": "def search_database(self, table_name, name):\n \"\"\"\n Search the specified table in the database for rows with a matching name.\n :param table_name: str, the name of the table to search.\n :param name: str, the name to search for.\n :return: list, a list of tuples representing the rows with matching name, if any;\n otherwise, returns None.\n >>> db.search_database('user', 'John')\n [(1, 'John', 25)]\n \"\"\"", "test_class": "DatabaseProcessorTestSearchDatabase", "test_code": "class DatabaseProcessorTestSearchDatabase(unittest.TestCase):\n def setUp(self):\n self.database_name = \"test.db\"\n self.processor = DatabaseProcessor(self.database_name)\n\n def tearDown(self):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"DROP TABLE IF EXISTS test_table\")\n conn.commit()\n conn.close()\n\n def test_search_database_1(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n result = self.processor.search_database(table_name, 'John')\n self.assertIsNotNone(result)\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'John')\n\n def test_search_database_2(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n result = self.processor.search_database(table_name, 'Alice')\n self.assertIsNotNone(result)\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'Alice')\n\n def test_search_database_3(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n result = self.processor.search_database(table_name, 'Bob')\n self.assertIsNone(result)\n\n def test_search_database_4(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n result = self.processor.search_database(table_name, 'aaa')\n self.assertIsNone(result)\n\n def test_search_database_5(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n result = self.processor.search_database(table_name, 'bbb')\n self.assertIsNone(result)", "solution_code": "def search_database(self, table_name, name):\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n\n select_query = f\"SELECT * FROM {table_name} WHERE name = ?\"\n cursor.execute(select_query, (name,))\n result = cursor.fetchall()\n\n if result:\n return result\n else:\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [ "sqlite3" ], "field_dependencies": [ "self.database_name" ], "method_dependencies": [] } }, { "method_name": "delete_from_database", "method_description": "def delete_from_database(self, table_name, name):\n \"\"\"\n Delete rows from the specified table in the database with a matching name.\n :param table_name: str, the name of the table to delete rows from.\n :param name: str, the name to match for deletion.\n >>> db.delete_from_database('user', 'John')\n \"\"\"", "test_class": "DatabaseProcessorTestDeteleFromDatabase", "test_code": "class DatabaseProcessorTestDeteleFromDatabase(unittest.TestCase):\n def setUp(self):\n self.database_name = \"test.db\"\n self.processor = DatabaseProcessor(self.database_name)\n\n def tearDown(self):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(\"DROP TABLE IF EXISTS test_table\")\n conn.commit()\n conn.close()\n\n def test_delete_from_database_1(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n self.processor.delete_from_database(table_name, 'John')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'Alice')\n\n def test_delete_from_database_2(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n self.processor.delete_from_database(table_name, 'Alice')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'John')\n\n def test_delete_from_database_3(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n self.processor.delete_from_database(table_name, 'John')\n self.processor.delete_from_database(table_name, 'Alice')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 0)\n\n def test_delete_from_database_4(self):\n table_name = \"test_table\"\n data = [\n {'name': 'John', 'age': 25},\n {'name': 'aaa', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n self.processor.delete_from_database(table_name, 'John')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'aaa')\n\n def test_delete_from_database_5(self):\n table_name = \"test_table\"\n data = [\n {'name': 'bbb', 'age': 25},\n {'name': 'Alice', 'age': 30}\n ]\n self.processor.create_table(table_name, 'name', 'age')\n self.processor.insert_into_database(table_name, data)\n\n self.processor.delete_from_database(table_name, 'bbb')\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n cursor.execute(f\"SELECT * FROM {table_name}\")\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'Alice')", "solution_code": "def delete_from_database(self, table_name, name):\n\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n\n delete_query = f\"DELETE FROM {table_name} WHERE name = ?\"\n cursor.execute(delete_query, (name,))\n\n conn.commit()\n conn.close()", "dependencies": { "Standalone": false, "lib_dependencies": [ "sqlite3" ], "field_dependencies": [ "self.database_name" ], "method_dependencies": [] } } ]

[ "DatabaseProcessorTestCreateTable", "DatabaseProcessorTestInsertIntoDatabase", "DatabaseProcessorTestSearchDatabase", "DatabaseProcessorTestDeteleFromDatabase", "DatabaseProcessorTest" ]

[ "self.database_name" ]

[ "from collections import Counter" ]

[ { "method_name": "mean", "method_description": "def mean(self, data):\n \"\"\"\n Calculate the average value of a group of data, accurate to two digits after the Decimal separator\n :param data:list, data list\n :return:float, the mean value\n >>> ds = DataStatistics()\n >>> ds.mean([1, 2, 3, 4, 5])\n 3.00\n \"\"\"", "test_class": "DataStatisticsTestMean", "test_code": "class DataStatisticsTestMean(unittest.TestCase):\n def test_mean_1(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 3, 4, 5])\n self.assertEqual(res, 3.00)\n\n def test_mean_2(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 3, 4, 5, 6])\n self.assertEqual(res, 3.50)\n\n def test_mean_3(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 4, 5, 6, 7])\n self.assertEqual(res, 4.17)\n\n def test_mean_4(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 4, 5, 6, 7, 8])\n self.assertEqual(res, 4.71)\n\n def test_mean_5(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 4, 5, 6, 7, 8, 9])\n self.assertEqual(res, 5.25)", "solution_code": "def mean(self, data):\n return round(sum(data) / len(data), 2)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "median", "method_description": "def median(self, data):\n \"\"\"\n Calculate the median of a group of data, accurate to two digits after the Decimal separator\n :param data:list, data list\n :return:float, the median value\n >>> ds = DataStatistics()\n >>> ds.median([2, 5, 1, 3, 4])\n 3.00\n \"\"\"", "test_class": "DataStatisticsTestMedian", "test_code": "class DataStatisticsTestMedian(unittest.TestCase):\n def test_median_1(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 3, 4])\n self.assertEqual(res, 3)\n\n def test_median_2(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 3, 4, 6])\n self.assertEqual(res, 3.50)\n\n def test_median_3(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 4, 6, 7])\n self.assertEqual(res, 4.5)\n\n def test_median_4(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 4, 6, 7, 8])\n self.assertEqual(res, 5)\n\n def test_median_5(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 4, 6, 7, 8, 9])\n self.assertEqual(res, 5.5)", "solution_code": "def median(self, data):\n sorted_data = sorted(data)\n n = len(sorted_data)\n if n % 2 == 0:\n middle = n // 2\n return round((sorted_data[middle - 1] + sorted_data[middle]) / 2, 2)\n else:\n middle = n // 2\n return sorted_data[middle]", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "mode", "method_description": "def mode(self, data):\n \"\"\"\n Calculate the mode of a set of data\n :param data:list, data list\n :return:float, the mode\n >>> ds = DataStatistics()\n >>> ds.mode([2, 2, 3, 3, 4])\n [2, 3]\n \"\"\"", "test_class": "DataStatisticsTestMode", "test_code": "class DataStatisticsTestMode(unittest.TestCase):\n def test_mode_1(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 3, 3, 4])\n self.assertEqual(res, [2, 3])\n\n def test_mode_2(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 2, 3, 3, 4])\n self.assertEqual(res, [2])\n\n def test_mode_3(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 3, 3, 4, 4])\n self.assertEqual(res, [2, 3, 4])\n\n def test_mode_4(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 3, 3, 4, 4, 4])\n self.assertEqual(res, [4])\n\n def test_mode_5(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 3, 3, 4, 4, 4, 5])\n self.assertEqual(res, [4])", "solution_code": "def mode(self, data):\n counter = Counter(data)\n mode_count = max(counter.values())\n mode = [x for x, count in counter.items() if count == mode_count]\n return mode", "dependencies": { "Standalone": false, "lib_dependencies": [ "Counter" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "DataStatisticsTestMean", "DataStatisticsTestMedian", "DataStatisticsTestMode", "DataStatisticsTest" ]

[]

[ "import numpy as np" ]

[ { "method_name": "get_sum", "method_description": "def get_sum(self):\n \"\"\"\n Calculate the sum of data\n :return:float\n >>> ds2 = DataStatistics2([1, 2, 3, 4])\n >>> ds2.get_sum()\n 10\n \"\"\"", "test_class": "DataStatistics2TestGetSum", "test_code": "class DataStatistics2TestGetSum(unittest.TestCase):\n def test_get_sum_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 10)\n\n def test_get_sum_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 210)\n\n def test_get_sum_3(self):\n ds2 = DataStatistics2([1, 2, 33, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 40)\n\n def test_get_sum_4(self):\n ds2 = DataStatistics2([1, 2, 333, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 340)\n\n def test_get_sum_5(self):\n ds2 = DataStatistics2([1, 2, 6, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 13)", "solution_code": "def get_sum(self):\n return np.sum(self.data)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data" ], "method_dependencies": [] } }, { "method_name": "get_min", "method_description": "def get_min(self):\n \"\"\"\n Calculate the minimum value in the data\n :return:float\n >>> ds2 = DataStatistics2([1, 2, 3, 4])\n >>> ds2.get_min()\n 1\n \"\"\"", "test_class": "DataStatistics2TestGetMin", "test_code": "class DataStatistics2TestGetMin(unittest.TestCase):\n def test_get_min_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_min()\n self.assertEqual(res, 1)\n\n def test_get_min_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_min()\n self.assertEqual(res, 1)\n\n def test_get_min_3(self):\n ds2 = DataStatistics2([0, -1, -3, 2])\n res = ds2.get_min()\n self.assertEqual(res, -3)\n\n def test_get_min_4(self):\n ds2 = DataStatistics2([-111, -1, -3, 2])\n res = ds2.get_min()\n self.assertEqual(res, -111)\n\n def test_get_min_5(self):\n ds2 = DataStatistics2([0, -1111, -3, 2])\n res = ds2.get_min()\n self.assertEqual(res, -1111)", "solution_code": "def get_min(self):\n return np.min(self.data)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data" ], "method_dependencies": [] } }, { "method_name": "get_max", "method_description": "def get_max(self):\n \"\"\"\n Calculate the maximum value in the data\n :return:float\n >>> ds2 = DataStatistics2([1, 2, 3, 4])\n >>> ds2.get_max()\n 4\n \"\"\"", "test_class": "DataStatistics2TestGetMax", "test_code": "class DataStatistics2TestGetMax(unittest.TestCase):\n def test_get_max_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_max()\n self.assertEqual(res, 4)\n\n def test_get_max_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_max()\n self.assertEqual(res, 203)\n\n def test_get_max_3(self):\n ds2 = DataStatistics2([-1, -4, 3, 2])\n res = ds2.get_max()\n self.assertEqual(res, 3)\n\n def test_get_max_4(self):\n ds2 = DataStatistics2([-1, 4, 3, 2])\n res = ds2.get_max()\n self.assertEqual(res, 4)\n\n def test_get_max_5(self):\n ds2 = DataStatistics2([-1, 444, 3, 2])\n res = ds2.get_max()\n self.assertEqual(res, 444)", "solution_code": "def get_max(self):\n return np.max(self.data)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data" ], "method_dependencies": [] } }, { "method_name": "get_variance", "method_description": "def get_variance(self):\n \"\"\"\n Calculate variance, accurate to two digits after the Decimal separator\n :return:float\n >>> ds2 = DataStatistics2([1, 2, 3, 4])\n >>> ds2.get_variance()\n 1.25\n \"\"\"", "test_class": "DataStatistics2TestGetVariance", "test_code": "class DataStatistics2TestGetVariance(unittest.TestCase):\n def test_get_variance_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)\n\n def test_get_variance_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_variance()\n self.assertEqual(res, 7551.25)\n\n def test_get_variance_3(self):\n ds2 = DataStatistics2([1, 4, 3, 2])\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)\n\n def test_get_variance_4(self):\n ds2 = DataStatistics2([11, 14, 13, 12])\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)\n\n def test_get_variance_5(self):\n ds2 = DataStatistics2([111, 114, 113, 112])\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)", "solution_code": "def get_variance(self):\n return round(np.var(self.data), 2)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data" ], "method_dependencies": [] } }, { "method_name": "get_std_deviation", "method_description": "def get_std_deviation(self):\n \"\"\"\n Calculate standard deviation, accurate to two digits after the Decimal separator\n :return:float\n >>> ds2 = DataStatistics2([1, 2, 3, 4])\n >>> ds2.get_std_deviation()\n 1.12\n \"\"\"", "test_class": "DataStatistics2TestGetStdDeviation", "test_code": "class DataStatistics2TestGetStdDeviation(unittest.TestCase):\n def test_get_std_deviation_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)\n\n def test_get_std_deviation_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 86.9)\n\n def test_get_std_deviation_3(self):\n ds2 = DataStatistics2([1, 4, 3, 2])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)\n\n def test_get_std_deviation_4(self):\n ds2 = DataStatistics2([11, 14, 13, 12])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)\n\n def test_get_std_deviation_5(self):\n ds2 = DataStatistics2([111, 114, 113, 112])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)", "solution_code": "def get_std_deviation(self):\n return round(np.std(self.data), 2)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data" ], "method_dependencies": [] } }, { "method_name": "get_correlation", "method_description": "def get_correlation(self):\n \"\"\"\n Calculate correlation\n :return:float\n >>> ds2 = DataStatistics2([1, 2, 3, 4])\n >>> ds2.get_correlation()\n 1.0\n \"\"\"", "test_class": "DataStatistics2TestGetCorrelation", "test_code": "class DataStatistics2TestGetCorrelation(unittest.TestCase):\n def test_get_correlation_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n def test_get_correlation_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n def test_get_correlation_3(self):\n ds2 = DataStatistics2([1, 4, 3, 2])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n def test_get_correlation_4(self):\n ds2 = DataStatistics2([11, 14, 13, 12])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n def test_get_correlation_5(self):\n ds2 = DataStatistics2([111, 114, 113, 112])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)", "solution_code": "def get_correlation(self):\n return np.corrcoef(self.data, rowvar=False)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data" ], "method_dependencies": [] } } ]

[ "DataStatistics2TestGetSum", "DataStatistics2TestGetMin", "DataStatistics2TestGetMax", "DataStatistics2TestGetVariance", "DataStatistics2TestGetStdDeviation", "DataStatistics2TestGetCorrelation", "DataStatistics2Test" ]

[ "self.data" ]

[ "import math" ]

[ { "method_name": "correlation_coefficient", "method_description": "def correlation_coefficient(data1, data2):\n \"\"\"\n Calculate the correlation coefficient of two sets of data.\n :param data1: The first set of data,list.\n :param data2: The second set of data,list.\n :return: The correlation coefficient, float.\n >>> DataStatistics4.correlation_coefficient([1, 2, 3], [4, 5, 6])\n 0.9999999999999998\n\n \"\"\"", "test_class": "DataStatistics4TestCorrelationCoefficient", "test_code": "class DataStatistics4TestCorrelationCoefficient(unittest.TestCase):\n def test_correlation_coefficient(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [4, 5, 6]), 0.9999999999999998)\n\n def test_correlation_coefficient_2(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 1, 1], [2, 2, 2]), 0)\n\n def test_correlation_coefficient_3(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [1, 2, 3]), 0.9999999999999998)\n\n def test_correlation_coefficient_4(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [1, 2, 4]), 0.9819805060619659)\n\n def test_correlation_coefficient_5(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [1, 5, 3]), 0.4999999999999999)", "solution_code": "def correlation_coefficient(data1, data2):\n n = len(data1)\n mean1 = sum(data1) / n\n mean2 = sum(data2) / n\n\n numerator = sum((data1[i] - mean1) * (data2[i] - mean2) for i in range(n))\n denominator = math.sqrt(sum((data1[i] - mean1) ** 2 for i in range(n))) * math.sqrt(sum((data2[i] - mean2) ** 2 for i in range(n)))\n\n return numerator / denominator if denominator != 0 else 0", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "skewness", "method_description": "@staticmethod\n def skewness(data):\n \"\"\"\n Calculate the skewness of a set of data.\n :param data: The input data list, list.\n :return: The skewness, float.\n >>> DataStatistics4.skewness([1, 2, 5])\n 2.3760224064818463\n\n \"\"\"", "test_class": "DataStatistics4TestSkewness", "test_code": "class DataStatistics4TestSkewness(unittest.TestCase):\n def test_skewness(self):\n self.assertEqual(DataStatistics4.skewness([1, 2, 5]), 2.3760224064818463)\n\n def test_skewness_2(self):\n self.assertEqual(DataStatistics4.skewness([1, 1, 1]), 0)\n\n def test_skewness_3(self):\n self.assertEqual(DataStatistics4.skewness([1, 2, 3]), 0)\n\n def test_skewness_4(self):\n self.assertEqual(DataStatistics4.skewness([1, 2, 4]), 1.7181079837227264)\n\n def test_skewness_5(self):\n self.assertEqual(DataStatistics4.skewness([1, 5, 3]), 0.0)", "solution_code": "@staticmethod\n def skewness(data):\n n = len(data)\n mean = sum(data) / n\n variance = sum((x - mean) ** 2 for x in data) / n\n std_deviation = math.sqrt(variance)\n\n skewness = sum((x - mean) ** 3 for x in data) * n / ((n - 1) * (n - 2) * std_deviation ** 3) if std_deviation != 0 else 0\n\n return skewness", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "kurtosis", "method_description": "@staticmethod\n def kurtosis(data):\n \"\"\"\n Calculate the kurtosis of a set of data.\n :param data: The input data list, list.\n :return: The kurtosis, float.\n >>> DataStatistics4.kurtosis([1, 20,100])\n -1.5000000000000007\n\n \"\"\"", "test_class": "DataStatistics4TestKurtosis", "test_code": "class DataStatistics4TestKurtosis(unittest.TestCase):\n def test_kurtosis(self):\n self.assertEqual(DataStatistics4.kurtosis([1, 2, 5]), -1.5000000000000002)\n\n def test_kurtosis_2(self):\n self.assertTrue(math.isnan(DataStatistics4.kurtosis([1, 1, 1])))\n\n def test_kurtosis_3(self):\n self.assertEqual(DataStatistics4.kurtosis([1, 2, 3]), -1.5000000000000002)\n\n def test_kurtosis_4(self):\n self.assertEqual(DataStatistics4.kurtosis([1, 2, 4]), -1.4999999999999996)\n\n def test_kurtosis_5(self):\n self.assertEqual(DataStatistics4.kurtosis([1, 5, 3]), -1.5000000000000002)", "solution_code": "@staticmethod\n def kurtosis(data):\n\n n = len(data)\n mean = sum(data) / n\n std_dev = math.sqrt(sum((x - mean) ** 2 for x in data) / n)\n\n if std_dev == 0:\n return math.nan\n\n centered_data = [(x - mean) for x in data]\n fourth_moment = sum(x ** 4 for x in centered_data) / n\n\n kurtosis_value = (fourth_moment / std_dev ** 4) - 3\n\n return kurtosis_value", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "pdf", "method_description": "@staticmethod\n def pdf(data, mu, sigma):\n \"\"\"\n Calculate the probability density function (PDF) of a set of data under a normal distribution.\n :param data: The input data list, list.\n :param mu: The mean of the normal distribution, float.\n :param sigma: The standard deviation of the normal distribution, float.\n :return: The probability density function (PDF), list.\n >>> DataStatistics4.pdf([1, 2, 3], 1, 1)\n [0.3989422804014327, 0.24197072451914337, 0.05399096651318806]\n\n \"\"\"", "test_class": "DataStatistics4TestPDF", "test_code": "class DataStatistics4TestPDF(unittest.TestCase):\n def test_pdf(self):\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 1, 1),\n [0.3989422804014327, 0.24197072451914337, 0.05399096651318806])\n\n def test_pdf_2(self):\n self.assertEqual(DataStatistics4.pdf([1, 1, 1], 1, 1),\n [0.3989422804014327, 0.3989422804014327, 0.3989422804014327])\n\n def test_pdf_3(self):\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 2, 1),\n [0.24197072451914337, 0.3989422804014327, 0.24197072451914337])\n\n def test_pdf_4(self):\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 1, 2),\n [0.19947114020071635, 0.17603266338214976, 0.12098536225957168])\n\n def test_pdf_5(self):\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 2, 2),\n [0.17603266338214976, 0.19947114020071635, 0.17603266338214976])", "solution_code": "@staticmethod\n def pdf(data, mu, sigma):\n pdf_values = [1 / (sigma * math.sqrt(2 * math.pi)) * math.exp(-0.5 * ((x - mu) / sigma) ** 2) for x in data]\n return pdf_values", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "DataStatistics4TestCorrelationCoefficient", "DataStatistics4TestSkewness", "DataStatistics4TestKurtosis", "DataStatistics4TestPDF", "DataStatistics4TestMain" ]

[]

[]

[ { "method_name": "caesar_decipher", "method_description": "def caesar_decipher(self, ciphertext, shift):\n \"\"\"\n Deciphers the given ciphertext using the Caesar cipher\n :param ciphertext: The ciphertext to decipher,str.\n :param shift: The shift to use for decryption,int.\n :return: The deciphered plaintext,str.\n >>> d = DecryptionUtils('key')\n >>> d.caesar_decipher('ifmmp', 1)\n 'hello'\n\n \"\"\"", "test_class": "DecryptionUtilsTestCaesarDecipher", "test_code": "class DecryptionUtilsTestCaesarDecipher(unittest.TestCase):\n def test_caesar_decipher(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('ifmmp', 1), 'hello')\n\n def test_caesar_decipher_2(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('bcdyza', 27), 'abcxyz')\n\n def test_caesar_decipher_3(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('bcd', 0), 'bcd')\n\n def test_caesar_decipher_4(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('bcd', 26), 'bcd')\n\n def test_caesar_decipher_5(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('bcd', -26), 'bcd')\n\n def test_caesar_decipher_6(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('IFMMP', 1), 'HELLO')\n\n def test_caesar_decipher_7(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('123', 1), '123')", "solution_code": "def caesar_decipher(self, ciphertext, shift):\n plaintext = \"\"\n for char in ciphertext:\n if char.isalpha():\n if char.isupper():\n ascii_offset = 65\n else:\n ascii_offset = 97\n shifted_char = chr((ord(char) - ascii_offset - shift) % 26 + ascii_offset)\n plaintext += shifted_char\n else:\n plaintext += char\n return plaintext", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "vigenere_decipher", "method_description": "def vigenere_decipher(self, ciphertext):\n \"\"\"\n Deciphers the given ciphertext using the Vigenere cipher\n :param ciphertext: The ciphertext to decipher,str.\n :return: The deciphered plaintext,str.\n >>> d = DecryptionUtils('key')\n >>> d.vigenere_decipher('ifmmp')\n 'ybocl'\n\n \"\"\"", "test_class": "DecryptionUtilsTestVigenereDecipher", "test_code": "class DecryptionUtilsTestVigenereDecipher(unittest.TestCase):\n def test_vigenere_decipher(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('ifmmp'), 'ybocl')\n\n def test_vigenere_decipher_2(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('rijvs'), 'hello')\n\n def test_vigenere_decipher_3(self):\n d = DecryptionUtils('longkey')\n self.assertEqual(d.vigenere_decipher('LpPjOjE'), 'AbCdEfG')\n\n def test_vigenere_decipher_4(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('bcd'), 'ryf')\n\n def test_vigenere_decipher_5(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('bcdaa'), 'ryfqw')\n\n def test_vigenere_decipher_6(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('123'), '123')", "solution_code": "def vigenere_decipher(self, ciphertext):\n decrypted_text = \"\"\n key_index = 0\n for char in ciphertext:\n if char.isalpha():\n shift = ord(self.key[key_index % len(self.key)].lower()) - ord('a')\n decrypted_char = chr((ord(char.lower()) - ord('a') - shift) % 26 + ord('a'))\n decrypted_text += decrypted_char.upper() if char.isupper() else decrypted_char\n key_index += 1\n else:\n decrypted_text += char\n return decrypted_text", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.key" ], "method_dependencies": [] } }, { "method_name": "rail_fence_decipher", "method_description": "def rail_fence_decipher(self, encrypted_text, rails):\n \"\"\"\n Deciphers the given ciphertext using the Rail Fence cipher\n :param encrypted_text: The ciphertext to decipher,str.\n :param rails: The number of rails to use for decryption,int.\n :return: The deciphered plaintext,str.\n >>> d = DecryptionUtils('key')\n >>> d.rail_fence_decipher('Hoo!el,Wrdl l', 3)\n 'Hello, World!'\n\n \"\"\"", "test_class": "DecryptionUtilsTestRailFenceDecipher", "test_code": "class DecryptionUtilsTestRailFenceDecipher(unittest.TestCase):\n def test_rail_fence_decipher(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 3), 'Hello, World!')\n\n def test_rail_fence_decipher_2(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 4), 'H!W reoldll,o')\n\n def test_rail_fence_decipher_3(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 5), 'Holr d,!oeWll')\n\n def test_rail_fence_decipher_4(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 6), 'Holrll d,!oeW')\n\n def test_rail_fence_decipher_5(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 7), 'Hoe,rll dWl!o')", "solution_code": "def rail_fence_decipher(self, encrypted_text, rails):\n fence = [['\\n' for _ in range(len(encrypted_text))] for _ in range(rails)]\n direction = -1\n row, col = 0, 0\n\n for _ in range(len(encrypted_text)):\n if row == 0 or row == rails - 1:\n direction = -direction\n\n fence[row][col] = ''\n col += 1\n row += direction\n\n index = 0\n for i in range(rails):\n for j in range(len(encrypted_text)):\n if fence[i][j] == '':\n fence[i][j] = encrypted_text[index]\n index += 1\n\n plain_text = ''\n direction = -1\n row, col = 0, 0\n for _ in range(len(encrypted_text)):\n if row == 0 or row == rails - 1:\n direction = -direction\n\n plain_text += fence[row][col]\n col += 1\n row += direction\n\n return plain_text", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "DecryptionUtilsTestCaesarDecipher", "DecryptionUtilsTestVigenereDecipher", "DecryptionUtilsTestRailFenceDecipher", "DecryptionUtilsTestMain" ]

[ "self.key" ]

[]

[ { "method_name": "total", "method_description": "def total(self):\n \"\"\"\n Calculate the total cost of items in the cart.\n :return: float, total cost of items\n >>> customer = {'name': 'John Doe', 'fidelity': 1200}\n >>> cart = [{'product': 'product', 'quantity': 14, 'price': 23.5}]\n >>> ds = DiscountStrategy(customer, cart)\n >>> ds.total()\n 329.0\n\n \"\"\"", "test_class": "DiscountStrategyTestTotal", "test_code": "class DiscountStrategyTestTotal(unittest.TestCase):\n def test_total_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 250.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n def test_total_2(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 150.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n def test_total_3(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 200.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 2050.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n def test_total_4(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 1, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 70.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n def test_total_5(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = []\n order = DiscountStrategy(customer, cart)\n expected_total = 0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)", "solution_code": "def total(self):\n self.__total = sum(item['quantity'] * item['price'] for item in self.cart)\n return self.__total", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.cart" ], "method_dependencies": [] } }, { "method_name": "due", "method_description": "def due(self):\n \"\"\"\n Calculate the final amount to be paid after applying the discount.\n :return: float, final amount to be paid\n >>> customer = {'name': 'John Doe', 'fidelity': 1200}\n >>> cart = [{'product': 'product', 'quantity': 14, 'price': 23.5}]\n >>> ds = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n >>> ds.due()\n 312.55\n\n \"\"\"", "test_class": "DiscountStrategyTestDue", "test_code": "class DiscountStrategyTestDue(unittest.TestCase):\n def test_due_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_due = 250.0\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n def test_due_2(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_due = 237.5\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n def test_due_3(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 20, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_due = 410.0\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n def test_due_4(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(15)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_due = 139.5\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n def test_due_5(self):\n customer = {'name': 'John Doe', 'fidelity': 900}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_due = 250.0\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)", "solution_code": "def due(self):\n if self.promotion is None:\n discount = 0\n else:\n discount = self.promotion(self)\n return self.__total - discount", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.promotion" ], "method_dependencies": [ "total" ] } }, { "method_name": "FidelityPromo", "method_description": "@staticmethod\n def FidelityPromo(order):\n \"\"\"\n Calculate the discount based on the fidelity points of the customer.Customers with over 1000 points can enjoy a 5% discount on the entire order.\n :param order: object, the order to apply the discount to\n :return: float, discount amount\n >>> customer = {'name': 'John Doe', 'fidelity': 1200}\n >>> cart = [{'product': 'product', 'quantity': 14, 'price': 23.5}]\n >>> order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n >>> DiscountStrategy.FidelityPromo(order)\n 16.45\n\n \"\"\"", "test_class": "DiscountStrategyTestFidelityPromo", "test_code": "class DiscountStrategyTestFidelityPromo(unittest.TestCase):\n def test_fidelity_promo_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1000}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 12.5\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_fidelity_promo_2(self):\n customer = {'name': 'John Doe', 'fidelity': 800}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_fidelity_promo_3(self):\n customer = {'name': 'John Doe', 'fidelity': 0}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_fidelity_promo_4(self):\n customer = {'name': 'John Doe', 'fidelity': 10000}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 12.5\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_fidelity_promo_5(self):\n customer = {'name': 'John Doe', 'fidelity': 1800}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 12.5\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)", "solution_code": "@staticmethod\n def FidelityPromo(order):\n return order.total() * 0.05 if order.customer['fidelity'] >= 1000 else 0", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "total" ] } }, { "method_name": "BulkItemPromo", "method_description": "@staticmethod\n def BulkItemPromo(order):\n \"\"\"\n Calculate the discount based on bulk item quantity in the order.In the same order, if the quantity of a single item reaches 20 or more, each item will enjoy a 10% discount.\n :param order: object, the order to apply the discount to\n :return: float, discount amount\n >>> customer = {'name': 'John Doe', 'fidelity': 1200}\n >>> cart = [{'product': 'product', 'quantity': 20, 'price': 23.5}]\n >>> order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n >>> DiscountStrategy.BulkItemPromo(order)\n 47.0\n\n \"\"\"", "test_class": "DiscountStrategyTestBulkItemPromo", "test_code": "class DiscountStrategyTestBulkItemPromo(unittest.TestCase):\n def test_bulk_item_promo_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 20, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 20.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_bulk_item_promo_2(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_bulk_item_promo_3(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 100, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 100.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_bulk_item_promo_4(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 1, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 0.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_bulk_item_promo_5(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 30, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 30.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)", "solution_code": "@staticmethod\n def BulkItemPromo(order):\n discount = 0\n for item in order.cart:\n if item['quantity'] >= 20:\n discount += item['quantity'] * item['price'] * 0.1\n return discount", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "LargeOrderPromo", "method_description": "@staticmethod\n def LargeOrderPromo(order):\n \"\"\"\n Calculate the discount based on the number of different products in the order.If the quantity of different products in the order reaches 10 or more, the entire order will enjoy a 7% discount.\n :param order: object, the order to apply the discount to\n :return: float, discount amount\n >>> customer = {'name': 'John Doe', 'fidelity': 1200}\n >>> cart = [{'product': 'product', 'quantity': 14, 'price': 23.5}]\n >>> order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n >>> DiscountStrategy.LargeOrderPromo(order)\n 0.0\n\n \"\"\"", "test_class": "DiscountStrategyTestLargeOrderPromo", "test_code": "class DiscountStrategyTestLargeOrderPromo(unittest.TestCase):\n def test_large_order_promo_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(10)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 7.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)\n\n def test_large_order_promo_2(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(5)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_large_order_promo_3(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(100)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 70.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)\n\n def test_large_order_promo_4(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(1000)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 700.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)\n\n def test_large_order_promo_5(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(1)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 0.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)", "solution_code": "@staticmethod\n def LargeOrderPromo(order):\n return order.total() * 0.07 if len({item['product'] for item in order.cart}) >= 10 else 0", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "total" ] } } ]

[ "DiscountStrategyTestTotal", "DiscountStrategyTestDue", "DiscountStrategyTestFidelityPromo", "DiscountStrategyTestBulkItemPromo", "DiscountStrategyTestLargeOrderPromo", "DiscountStrategyTest" ]

[ "self.cart", "self.customer", "self.promotion" ]

[ "from docx import Document", "from docx.shared import Pt", "from docx.enum.text import WD_PARAGRAPH_ALIGNMENT" ]

[ { "method_name": "read_text", "method_description": "def read_text(self):\n \"\"\"\n Reads the content of a Word document and returns it as a string.\n :return: str, the content of the Word document.\n \"\"\"", "test_class": "DocFileHandlerTestReadText", "test_code": "class DocFileHandlerTestReadText(unittest.TestCase):\n def test_read_text_1(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"Initial content\")\n doc.save(self.file_path)\n\n text_content = self.handler.read_text()\n expected_content = \"Initial content\"\n self.assertEqual(text_content, expected_content)\n\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n def test_read_text_2(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"111\")\n doc.save(self.file_path)\n\n text_content = self.handler.read_text()\n expected_content = \"111\"\n self.assertEqual(text_content, expected_content)\n\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n def test_read_text_3(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"aaa\")\n doc.save(self.file_path)\n\n text_content = self.handler.read_text()\n expected_content = \"aaa\"\n self.assertEqual(text_content, expected_content)\n\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n def test_read_text_4(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"aaa\\nbbb\")\n doc.save(self.file_path)\n\n text_content = self.handler.read_text()\n expected_content = \"aaa\\nbbb\"\n self.assertEqual(text_content, expected_content)\n\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n def test_read_text_5(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"\")\n doc.save(self.file_path)\n\n text_content = self.handler.read_text()\n expected_content = \"\"\n self.assertEqual(text_content, expected_content)\n\n if os.path.exists(self.file_path):\n os.remove(self.file_path)", "solution_code": "def read_text(self):\n doc = Document(self.file_path)\n text = []\n for paragraph in doc.paragraphs:\n text.append(paragraph.text)\n return \"\\n\".join(text)", "dependencies": { "Standalone": false, "lib_dependencies": [ "Document" ], "field_dependencies": [ "self.file_path" ], "method_dependencies": [] } }, { "method_name": "write_text", "method_description": "def write_text(self, content, font_size=12, alignment='left'):\n \"\"\"\n Writes the specified content to a Word document.\n :param content: str, the text content to write.\n :param font_size: int, optional, the font size of the text (default is 12).\n :param alignment: str, optional, the alignment of the text ('left', 'center', or 'right'; default is 'left').\n :return: bool, True if the write operation is successful, False otherwise.\n \"\"\"", "test_class": "DocFileHandlerTestWriteText", "test_code": "class DocFileHandlerTestWriteText(unittest.TestCase):\n def setUp(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"Initial content\")\n doc.save(self.file_path)\n\n def tearDown(self):\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n def test_write_text_1(self):\n new_content = \"New content 1\"\n self.handler.write_text(new_content)\n text_content = self.handler.read_text()\n self.assertEqual(text_content, new_content)\n\n def test_write_text_2(self):\n new_content = \"New content 2\"\n self.handler.write_text(new_content)\n text_content = self.handler.read_text()\n self.assertEqual(text_content, new_content)\n\n def test_write_text_3(self):\n new_content = \"New content 3\"\n self.handler.write_text(new_content)\n text_content = self.handler.read_text()\n self.assertEqual(text_content, new_content)\n\n def test_write_text_4(self):\n new_content = \"New content 4\"\n self.handler.write_text(new_content)\n text_content = self.handler.read_text()\n self.assertEqual(text_content, new_content)\n\n def test_write_text_5(self):\n new_content = \"\"\n self.handler.write_text(new_content)\n text_content = self.handler.read_text()\n self.assertEqual(text_content, new_content)", "solution_code": "def write_text(self, content, font_size=12, alignment='left'):\n try:\n doc = Document()\n paragraph = doc.add_paragraph()\n run = paragraph.add_run(content)\n font = run.font\n font.size = Pt(font_size)\n alignment_value = self._get_alignment_value(alignment)\n paragraph.alignment = alignment_value\n doc.save(self.file_path)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "Document", "Pt" ], "field_dependencies": [ "self.file_path" ], "method_dependencies": [ "_get_alignment_value" ] } }, { "method_name": "add_heading", "method_description": "def add_heading(self, heading, level=1):\n \"\"\"\n Adds a heading to the Word document.\n :param heading: str, the text of the heading.\n :param level: int, optional, the level of the heading (1, 2, 3, etc.; default is 1).\n :return: bool, True if the heading is successfully added, False otherwise.\n \"\"\"", "test_class": "DocFileHandlerTestAddHeading", "test_code": "class DocFileHandlerTestAddHeading(unittest.TestCase):\n def setUp(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"Initial content\")\n doc.save(self.file_path)\n\n def tearDown(self):\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n def test_add_heading_1(self):\n heading = \"Test Heading 1\"\n self.handler.add_heading(heading)\n doc = Document(self.file_path)\n headings = [p.text for p in doc.paragraphs if p.style.name.startswith('Heading')]\n self.assertIn(heading, headings)\n\n def test_add_heading_2(self):\n heading = \"Test Heading 2\"\n self.handler.add_heading(heading)\n doc = Document(self.file_path)\n headings = [p.text for p in doc.paragraphs if p.style.name.startswith('Heading')]\n self.assertIn(heading, headings)\n\n def test_add_heading_3(self):\n heading = \"Test Heading 3\"\n self.handler.add_heading(heading)\n doc = Document(self.file_path)\n headings = [p.text for p in doc.paragraphs if p.style.name.startswith('Heading')]\n self.assertIn(heading, headings)\n\n def test_add_heading_4(self):\n heading = \"Test Heading 4\"\n self.handler.add_heading(heading)\n doc = Document(self.file_path)\n headings = [p.text for p in doc.paragraphs if p.style.name.startswith('Heading')]\n self.assertIn(heading, headings)\n\n def test_add_heading_5(self):\n heading = \"Test Heading 5\"\n self.handler.add_heading(heading)\n doc = Document(self.file_path)\n headings = [p.text for p in doc.paragraphs if p.style.name.startswith('Heading')]\n self.assertIn(heading, headings)", "solution_code": "def add_heading(self, heading, level=1):\n try:\n doc = Document(self.file_path)\n doc.add_heading(heading, level)\n doc.save(self.file_path)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "Document" ], "field_dependencies": [ "self.file_path" ], "method_dependencies": [] } }, { "method_name": "add_table", "method_description": "def add_table(self, data):\n \"\"\"\n Adds a table to the Word document with the specified data.\n :param data: list of lists, the data to populate the table.\n :return: bool, True if the table is successfully added, False otherwise.\n \"\"\"", "test_class": "DocFileHandlerTestAddTable", "test_code": "class DocFileHandlerTestAddTable(unittest.TestCase):\n def setUp(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"Initial content\")\n doc.save(self.file_path)\n\n def tearDown(self):\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n def test_add_table_1(self):\n data = [['Name', 'Age']]\n self.handler.add_table(data)\n doc = Document(self.file_path)\n table = doc.tables[0]\n self.assertEqual(len(table.rows), 1)\n self.assertEqual(len(table.columns), 2)\n\n def test_add_table_2(self):\n data = [['Name', 'Age'], ['John', '25']]\n self.handler.add_table(data)\n doc = Document(self.file_path)\n table = doc.tables[0]\n self.assertEqual(len(table.rows), 2)\n self.assertEqual(len(table.columns), 2)\n self.assertEqual(table.cell(1, 0).text, 'John')\n\n def test_add_table_3(self):\n data = [['Name', 'Age'], ['John', '25'], ['Emma', '30']]\n self.handler.add_table(data)\n doc = Document(self.file_path)\n table = doc.tables[0]\n self.assertEqual(len(table.rows), 3)\n self.assertEqual(len(table.columns), 2)\n self.assertEqual(table.cell(1, 0).text, 'John')\n self.assertEqual(table.cell(2, 1).text, '30')\n\n def test_add_table_4(self):\n data = [['Name', 'Age'], ['aaa', '25'], ['Emma', '30']]\n self.handler.add_table(data)\n doc = Document(self.file_path)\n table = doc.tables[0]\n self.assertEqual(len(table.rows), 3)\n self.assertEqual(len(table.columns), 2)\n self.assertEqual(table.cell(1, 0).text, 'aaa')\n self.assertEqual(table.cell(2, 1).text, '30')\n\n def test_add_table_5(self):\n data = [['Name', 'Age'], ['John', '25'], ['Emma', '90']]\n self.handler.add_table(data)\n doc = Document(self.file_path)\n table = doc.tables[0]\n self.assertEqual(len(table.rows), 3)\n self.assertEqual(len(table.columns), 2)\n self.assertEqual(table.cell(1, 0).text, 'John')\n self.assertEqual(table.cell(2, 1).text, '90')", "solution_code": "def add_table(self, data):\n try:\n doc = Document(self.file_path)\n table = doc.add_table(rows=len(data), cols=len(data[0]))\n for i, row in enumerate(data):\n for j, cell_value in enumerate(row):\n table.cell(i, j).text = str(cell_value)\n doc.save(self.file_path)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "Document" ], "field_dependencies": [ "self.file_path" ], "method_dependencies": [] } }, { "method_name": "_get_alignment_value", "method_description": "def _get_alignment_value(self, alignment):\n \"\"\"\n Returns the alignment value corresponding to the given alignment string.\n :param alignment: str, the alignment string ('left', 'center', or 'right').\n :return: int, the alignment value.\n \"\"\"", "test_class": "DocFileHandlerTest", "test_code": "class DocFileHandlerTest(unittest.TestCase):\n def test_DocFileHandler(self):\n self.file_path = \"test_example.docx\"\n self.handler = DocFileHandler(self.file_path)\n doc = Document()\n doc.add_paragraph(\"Initial content\")\n doc.save(self.file_path)\n\n text_content = self.handler.read_text()\n expected_content = \"Initial content\"\n self.assertEqual(text_content, expected_content)\n\n new_content = \"New content 1\"\n self.handler.write_text(new_content)\n text_content = self.handler.read_text()\n self.assertEqual(text_content, new_content)\n\n heading = \"Test Heading 1\"\n self.handler.add_heading(heading)\n doc = Document(self.file_path)\n headings = [p.text for p in doc.paragraphs if p.style.name.startswith('Heading')]\n self.assertIn(heading, headings)\n\n data = [['Name', 'Age']]\n self.handler.add_table(data)\n doc = Document(self.file_path)\n table = doc.tables[0]\n self.assertEqual(len(table.rows), 1)\n self.assertEqual(len(table.columns), 2)\n\n if os.path.exists(self.file_path):\n os.remove(self.file_path)", "solution_code": "def _get_alignment_value(self, alignment):\n alignment_options = {\n 'left': WD_PARAGRAPH_ALIGNMENT.LEFT,\n 'center': WD_PARAGRAPH_ALIGNMENT.CENTER,\n 'right': WD_PARAGRAPH_ALIGNMENT.RIGHT\n }\n return alignment_options.get(alignment.lower(), WD_PARAGRAPH_ALIGNMENT.LEFT)", "dependencies": { "Standalone": false, "lib_dependencies": [ "WD_PARAGRAPH_ALIGNMENT" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "DocFileHandlerTestReadText", "DocFileHandlerTestWriteText", "DocFileHandlerTestAddHeading", "DocFileHandlerTestAddTable", "DocFileHandlerTest" ]

[ "self.file_path" ]

[]

[ { "method_name": "find_blank", "method_description": "def find_blank(self, state):\n \"\"\"\n Find the blank position of current state, which is the 0 element.\n :param state: a 3*3 size list of Integer, stores the current state.\n :return i, j: two Integers, represent the coordinate of the blank block.\n >>> eightPuzzle = EightPuzzle([[2, 3, 4], [5, 8, 1], [6, 0, 7]])\n >>> eightPuzzle.find_blank([[2, 3, 4], [5, 8, 1], [6, 0, 7]])\n (2, 1)\n \"\"\"", "test_class": "EightPuzzleTestFindBlank", "test_code": "class EightPuzzleTestFindBlank(unittest.TestCase):\n def test_find_blank_1(self):\n state = [[2, 3, 4], [5, 8, 1], [6, 0, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), (2, 1))\n\n def test_find_blank_2(self):\n state = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), (1, 1))\n\n def test_find_blank_3(self):\n state = [[2, 3, 4], [5, 8, 1], [6, 8, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), None)\n\n def test_find_blank_4(self):\n state = [[2, 3, 4], [5, 8, 1], [6, 8, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), None)\n\n def test_find_blank_5(self):\n state = [[2, 3, 4], [5, 8, 1], [6, 8, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), None)", "solution_code": "def find_blank(self, state):\n for i in range(3):\n for j in range(3):\n if state[i][j] == 0:\n return i, j", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "move", "method_description": "def move(self, state, direction):\n \"\"\"\n Find the blank block, then makes the board moves forward the given direction.\n :param state: a 3*3 size list of Integer, stores the state before moving.\n :param direction: str, only has 4 direction 'up', 'down', 'left', 'right'\n :return new_state: a 3*3 size list of Integer, stores the state after moving.\n >>> eightPuzzle.move([[2, 3, 4], [5, 8, 1], [6, 0, 7]], 'left')\n [[2, 3, 4], [5, 8, 1], [0, 6, 7]]\n \"\"\"", "test_class": "EightPuzzleTestMove", "test_code": "class EightPuzzleTestMove(unittest.TestCase):\n def setUp(self):\n self.initial_state = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\n self.eightPuzzle = EightPuzzle(self.initial_state)\n\n def test_move_1(self):\n result = self.eightPuzzle.move(self.initial_state, 'up')\n expected = [[2, 0, 4], [5, 3, 1], [6, 8, 7]]\n self.assertEqual(result, expected)\n\n def test_move_2(self):\n result = self.eightPuzzle.move(self.initial_state, 'down')\n expected = [[2, 3, 4], [5, 8, 1], [6, 0, 7]]\n self.assertEqual(result, expected)\n\n def test_move_3(self):\n result = self.eightPuzzle.move(self.initial_state, 'left')\n expected = [[2, 3, 4], [0, 5, 1], [6, 8, 7]]\n self.assertEqual(result, expected)\n\n def test_move_4(self):\n result = self.eightPuzzle.move(self.initial_state, 'right')\n expected = [[2, 3, 4], [5, 1, 0], [6, 8, 7]]\n self.assertEqual(result, expected)\n\n def test_move_5(self):\n result = self.eightPuzzle.move(self.initial_state, '???')\n expected = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\n self.assertEqual(result, expected)", "solution_code": "def move(self, state, direction):\n i, j = self.find_blank(state)\n new_state = [row[:] for row in state]\n\n if direction == 'up':\n new_state[i][j], new_state[i - 1][j] = new_state[i - 1][j], new_state[i][j]\n elif direction == 'down':\n new_state[i][j], new_state[i + 1][j] = new_state[i + 1][j], new_state[i][j]\n elif direction == 'left':\n new_state[i][j], new_state[i][j - 1] = new_state[i][j - 1], new_state[i][j]\n elif direction == 'right':\n new_state[i][j], new_state[i][j + 1] = new_state[i][j + 1], new_state[i][j]\n\n return new_state", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "find_blank" ] } }, { "method_name": "get_possible_moves", "method_description": "def get_possible_moves(self, state):\n \"\"\"\n According the current state, find all the possible moving directions. Only has 4 direction 'up', 'down', 'left', 'right'.\n :param state: a 3*3 size list of Integer, stores the current state.\n :return moves: a list of str, store all the possible moving directions according to the current state.\n >>> eightPuzzle.get_possible_moves([[2, 3, 4], [5, 8, 1], [6, 0, 7]])\n ['up', 'left', 'right']\n \"\"\"", "test_class": "EightPuzzleTestGetPossibleMoves", "test_code": "class EightPuzzleTestGetPossibleMoves(unittest.TestCase):\n def test_get_possible_moves_1(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['up', 'down', 'left', 'right']\n for direction in result:\n self.assertIn(direction, expected)\n\n def test_get_possible_moves_2(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 3, 4], [5, 8, 1], [6, 0, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['up', 'left', 'right']\n for direction in result:\n self.assertIn(direction, expected)\n\n def test_get_possible_moves_3(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 0, 4], [5, 3, 1], [6, 8, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['down', 'left', 'right']\n for direction in result:\n self.assertIn(direction, expected)\n\n def test_get_possible_moves_4(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 3, 4], [5, 1, 0], [6, 8, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['up', 'down', 'left']\n for direction in result:\n self.assertIn(direction, expected)\n\n def test_get_possible_moves_5(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 3, 4], [0, 5, 1], [6, 8, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['up', 'down', 'right']\n for direction in result:\n self.assertIn(direction, expected)", "solution_code": "def get_possible_moves(self, state):\n moves = []\n i, j = self.find_blank(state)\n\n if i > 0:\n moves.append('up')\n if i < 2:\n moves.append('down')\n if j > 0:\n moves.append('left')\n if j < 2:\n moves.append('right')\n\n return moves", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "find_blank", "move" ] } }, { "method_name": "solve", "method_description": "def solve(self):\n \"\"\"\n Use BFS algorithm to find the path solution which makes the initial state to the goal method.\n Maintain a list as a queue, named as open_list, append the initial state.\n Always visit and pop the 0 index element, invoke get_possible_moves method find all the possible directions.\n Traversal the possible_moves list and invoke move method to get several new states.Then append them.\n redo the above steps until the open_list is empty or the state has changed to the goal state.\n :return path: list of str, the solution to the goal state.\n >>> eightPuzzle = EightPuzzle([[1, 2, 3], [4, 5, 6], [7, 0, 8]])\n >>> eightPuzzle.solve()\n ['right']\n \"\"\"", "test_class": "EightPuzzleTestSolve", "test_code": "class EightPuzzleTestSolve(unittest.TestCase):\n def test_solve_1(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [4, 5, 6], [7, 0, 8]])\n result = eightPuzzle.solve()\n expected = ['right']\n self.assertEqual(result, expected)\n\n def test_solve_2(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [4, 0, 6], [7, 5, 8]])\n result = eightPuzzle.solve()\n expected = ['down', 'right']\n self.assertEqual(result, expected)\n\n def test_solve_3(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [0, 4, 5], [6, 7, 8]])\n result = eightPuzzle.solve()\n expected = ['right', 'right', 'down', 'left', 'left', 'up', 'right', 'down', 'right', 'up', 'left', 'left', 'down', 'right', 'right']\n self.assertEqual(result, expected)\n\n def test_solve_4(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [4, 5, 6], [7, 8, 0]])\n result = eightPuzzle.solve()\n expected = []\n self.assertEqual(result, expected)\n\n def test_solve_5(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [4, 5, 6], [0, 7, 8]])\n result = eightPuzzle.solve()\n expected = ['right', 'right']\n self.assertEqual(result, expected)\n\n def test_solve_6(self):\n eightPuzzle = EightPuzzle([[0, 0, 0], [0, 0, 0], [0, 0, 0]])\n result = eightPuzzle.solve()\n expected = None\n self.assertEqual(result, expected)", "solution_code": "def solve(self):\n open_list = [(self.initial_state, [])]\n closed_list = []\n\n while open_list:\n current_state, path = open_list.pop(0)\n closed_list.append(current_state)\n\n if current_state == self.goal_state:\n return path\n\n for move in self.get_possible_moves(current_state):\n new_state = self.move(current_state, move)\n if new_state not in closed_list:\n open_list.append((new_state, path + [move]))\n\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.goal_state", "self.initial_state" ], "method_dependencies": [ "move", "get_possible_moves" ] } } ]

[ "EightPuzzleTestFindBlank", "EightPuzzleTestMove", "EightPuzzleTestGetPossibleMoves", "EightPuzzleTestSolve" ]

[ "self.goal_state", "self.initial_state" ]

[ "from datetime import datetime" ]

[ { "method_name": "send_to", "method_description": "def send_to(self, recv, content, size):\n \"\"\"\n Sends an email to the given email address.\n :param recv: The email address of the receiver, str.\n :param content: The content of the email, str.\n :param size: The size of the email, float.\n :return: True if the email is sent successfully, False if the receiver's email box is full.\n >>> sender = EmailClient('[email protected]', 100)\n >>> receiver = EmailClient('[email protected]', 50)\n >>> sender.send_to(receiver, 'Hello', 10)\n True\n >>> receiver.inbox\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10, 'time': '2023-07-13 11:36:40', 'state': 'unread'}\n\n \"\"\"", "test_class": "EmailClientTestSendTo", "test_code": "class EmailClientTestSendTo(unittest.TestCase):\n def test_send_to(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.assertTrue(sender.send_to(receiver, 'Hello', 10))\n self.assertEqual(receiver.inbox[0], {\"sender\": '[email protected]','receiver': '[email protected]','content': 'Hello','size': 10,'time': timestamp,'state': 'unread'})\n\n def test_send_to_2(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 0)\n self.assertFalse(sender.send_to(receiver, 'Hello', 10))\n\n def test_send_to_3(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n receiver.inbox = [{'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 50, 'time': '2021-01-01 00:00:00', 'state': 'unread'}]\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.assertFalse(sender.send_to(receiver, 'Hello', 10))\n self.assertEqual(receiver.inbox, [{'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 50, 'time': '2021-01-01 00:00:00', 'state': 'unread'}])\n\n def test_send_to_4(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 30)\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.assertTrue(sender.send_to(receiver, 'Hello', 20))\n self.assertEqual(receiver.inbox, [{'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 20, 'time': timestamp, 'state': 'unread'}])\n\n def test_send_to_5(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 30)\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.assertTrue(sender.send_to(receiver, 'bye', 20))\n self.assertEqual(receiver.inbox, [{'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'bye', 'size': 20, 'time': timestamp, 'state': 'unread'}])", "solution_code": "def send_to(self, recv, content, size):\n if not recv.is_full_with_one_more_email(size):\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n email = {\n \"sender\": self.addr,\n \"receiver\": recv.addr,\n \"content\": content,\n \"size\": size,\n \"time\": timestamp,\n \"state\": \"unread\"\n }\n recv.inbox.append(email)\n return True\n else:\n self.clear_inbox(size)\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime" ], "field_dependencies": [ "self.addr" ], "method_dependencies": [ "is_full_with_one_more_email", "clear_inbox" ] } }, { "method_name": "fetch", "method_description": "def fetch(self):\n \"\"\"\n Retrieves the first unread email in the email box and marks it as read.\n :return: The first unread email in the email box, dict.\n >>> sender = EmailClient('[email protected]', 100)\n >>> receiver = EmailClient('[email protected]', 50)\n >>> receiver.inbox = [{'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10, 'time': '2023-07-13 11:36:40', 'state': 'unread'}]\n >>> receiver.fetch()\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10, 'time': '2023-07-13 11:36:40', 'state': 'read'}\n\n \"\"\"", "test_class": "EmailClientTestFetch", "test_code": "class EmailClientTestFetch(unittest.TestCase):\n def test_fetch(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n receiver.inbox = [\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10,\n 'time': timestamp, 'state': 'unread'}]\n self.assertEqual(receiver.fetch(), {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10, 'time':timestamp, 'state': 'read'})\n\n def test_fetch_2(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.assertEqual(receiver.fetch(),None)\n\n def test_fetch_3(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n receiver.inbox = [\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10,\n 'time': timestamp, 'state': 'read'}]\n self.assertEqual(receiver.fetch(), None)\n\n def test_fetch_4(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n receiver.inbox = [\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10,\n 'time': '2021-01-01 00:00:00', 'state': 'unread'},\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10,\n 'time': timestamp, 'state': 'unread'}]\n self.assertEqual(receiver.fetch(), {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10,\n 'time': '2021-01-01 00:00:00', 'state': 'read'})\n\n def test_fetch_5(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n receiver.inbox = [\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10,\n 'time': '2021-01-01 00:00:00', 'state': 'read'},\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10,\n 'time': timestamp, 'state': 'unread'}]\n self.assertEqual(receiver.fetch(), {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10,\n 'time': timestamp, 'state': 'read'})", "solution_code": "def fetch(self):\n if len(self.inbox) == 0:\n return None\n for i in range(len(self.inbox)):\n if self.inbox[i]['state'] == \"unread\":\n self.inbox[i]['state'] = \"read\"\n return self.inbox[i]\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inbox" ], "method_dependencies": [] } }, { "method_name": "is_full_with_one_more_email", "method_description": "def is_full_with_one_more_email(self, size):\n \"\"\"\n Determines whether the email box is full after adding an email of the given size.\n :param size: The size of the email, float.\n :return: True if the email box is full, False otherwise.\n >>> sender = EmailClient('[email protected]', 100)\n >>> receiver = EmailClient('[email protected]', 50)\n >>> receiver.is_full_with_one_more_email(10)\n False\n\n \"\"\"", "test_class": "EmailClientTestIsFullWithOneMoreEmail", "test_code": "class EmailClientTestIsFullWithOneMoreEmail(unittest.TestCase):\n def test_is_full_with_one_more_email(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n self.assertFalse(receiver.is_full_with_one_more_email(10))\n\n def test_is_full_with_one_more_email_2(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 0)\n self.assertTrue(receiver.is_full_with_one_more_email(10))\n\n def test_is_full_with_one_more_email_3(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 10)\n self.assertFalse(receiver.is_full_with_one_more_email(10))\n\n def test_is_full_with_one_more_email_4(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 10)\n self.assertTrue(receiver.is_full_with_one_more_email(20))\n\n def test_is_full_with_one_more_email_5(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 20)\n self.assertFalse(receiver.is_full_with_one_more_email(20))", "solution_code": "def is_full_with_one_more_email(self, size):\n occupied_size = self.get_occupied_size()\n return True if occupied_size + size > self.capacity else False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.capacity" ], "method_dependencies": [ "get_occupied_size" ] } }, { "method_name": "get_occupied_size", "method_description": "def get_occupied_size(self):\n \"\"\"\n Gets the total size of the emails in the email box.\n :return: The total size of the emails in the email box, float.\n >>> sender = EmailClient('[email protected]', 100)\n >>> receiver = EmailClient('[email protected]', 50)\n >>> sender.inbox = [{'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10, 'time': datetime.now, 'state': 'unread'}]\n >>> sender.get_occupied_size()\n 10\n\n \"\"\"", "test_class": "EmailClientTestGetOccupiedSize", "test_code": "class EmailClientTestGetOccupiedSize(unittest.TestCase):\n def test_get_occupied_size(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n sender.inbox = [{'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 10, 'time': datetime.now, 'state': 'unread'}]\n self.assertEqual(sender.get_occupied_size(), 10)\n\n def test_get_occupied_size_2(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n sender.inbox =[]\n self.assertEqual(sender.get_occupied_size(), 0)\n\n def test_get_occupied_size_3(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n sender.inbox = [\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 20,\n 'time': datetime.now, 'state': 'unread'}]\n self.assertEqual(sender.get_occupied_size(), 20)\n\n def test_get_occupied_size_4(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n sender.inbox = [\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 20,\n 'time': datetime.now, 'state': 'unread'},\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 30,\n 'time': datetime.now, 'state': 'unread'}]\n self.assertEqual(sender.get_occupied_size(), 50)\n\n def test_get_occupied_size_5(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n sender.inbox = [\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 20,\n 'time': datetime.now, 'state': 'unread'},\n {'sender': '[email protected]', 'receiver': '[email protected]', 'content': 'Hello', 'size': 60,\n 'time': datetime.now, 'state': 'unread'}]\n self.assertEqual(sender.get_occupied_size(), 80)", "solution_code": "def get_occupied_size(self):\n occupied_size = 0\n for email in self.inbox:\n occupied_size += email[\"size\"]\n return occupied_size", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inbox" ], "method_dependencies": [] } }, { "method_name": "clear_inbox", "method_description": "def clear_inbox(self, size):\n \"\"\"\n Clears the email box by deleting the oldest emails until the email box has enough space to accommodate the given size.\n :param size: The size of the email, float.\n >>> sender = EmailClient('[email protected]', 100)\n >>> receiver = EmailClient('[email protected]', 50)\n >>> receiver.inbox = [{'size': 10},{'size': 20},{'size': 15}]\n >>> receiver.clear_inbox(30)\n >>> receiver.inbox\n [{'size': 15}]\n\n \"\"\"", "test_class": "EmailClientTestClearInbox", "test_code": "class EmailClientTestClearInbox(unittest.TestCase):\n def test_clear_inbox(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n receiver.inbox = [{'size': 10},{'size': 20},{'size': 15}]\n receiver.clear_inbox(30)\n self.assertEqual(receiver.inbox, [{'size': 15}])\n\n def test_clear_inbox_2(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('', 50)\n receiver.inbox = [{'size': 10},{'size': 20},{'size': 15}]\n self.assertEqual(receiver.clear_inbox(30),None)\n self.assertEqual(receiver.inbox, [{'size': 10},{'size': 20},{'size': 15}])\n\n def test_clear_inbox_3(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n receiver.inbox = [{'size': 10}, {'size': 20}, {'size': 15}]\n self.assertEqual(receiver.clear_inbox(50), None)\n\n def test_clear_inbox_4(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n receiver.inbox = [{'size': 10}, {'size': 20}, {'size': 15}]\n receiver.clear_inbox(45)\n self.assertEqual(receiver.inbox, [])\n def test_clear_inbox_5(self):\n sender = EmailClient('[email protected]', 100)\n receiver = EmailClient('[email protected]', 50)\n receiver.inbox = [{'size': 10}, {'size': 20}, {'size': 15}]\n receiver.clear_inbox(10)\n self.assertEqual(receiver.inbox, [{'size': 20}, {'size': 15}])", "solution_code": "def clear_inbox(self, size):\n if len(self.addr) == 0:\n return\n freed_space = 0\n while freed_space < size and self.inbox:\n email = self.inbox[0]\n freed_space += email['size']\n del self.inbox[0]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.addr", "self.inbox" ], "method_dependencies": [] } } ]

[ "EmailClientTestSendTo", "EmailClientTestFetch", "EmailClientTestIsFullWithOneMoreEmail", "EmailClientTestGetOccupiedSize", "EmailClientTestClearInbox", "EmailClientTestMain" ]

[ "self.addr", "self.capacity", "self.inbox" ]

[]

[ { "method_name": "caesar_cipher", "method_description": "def caesar_cipher(self, plaintext, shift):\n \"\"\"\n Encrypts the plaintext using the Caesar cipher.\n :param plaintext: The plaintext to encrypt, str.\n :param shift: The number of characters to shift each character in the plaintext, int.\n :return: The ciphertext, str.\n >>> e = EncryptionUtils(\"key\")\n >>> e.caesar_cipher(\"abc\", 1)\n 'bcd'\n\n \"\"\"", "test_class": "EncryptionUtilsTestCaesarCipher", "test_code": "class EncryptionUtilsTestCaesarCipher(unittest.TestCase):\n def test_caesar_cipher(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"abc\", 1), \"bcd\")\n\n def test_caesar_cipher_2(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"WORLD\", -2), \"UMPJB\")\n\n def test_caesar_cipher_3(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"\", 4), \"\")\n\n def test_caesar_cipher_4(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"abcxyz\", 26), \"abcxyz\")\n\n def test_caesar_cipher_5(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"abcxyz\", 27), \"bcdyza\")\n\n def test_caesar_cipher_6(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"123\", 27), \"123\")", "solution_code": "def caesar_cipher(self, plaintext, shift):\n ciphertext = \"\"\n for char in plaintext:\n if char.isalpha():\n if char.isupper():\n ascii_offset = 65\n else:\n ascii_offset = 97\n shifted_char = chr((ord(char) - ascii_offset + shift) % 26 + ascii_offset)\n ciphertext += shifted_char\n else:\n ciphertext += char\n return ciphertext", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "vigenere_cipher", "method_description": "def vigenere_cipher(self, plaintext):\n \"\"\"\n Encrypts the plaintext using the Vigenere cipher.\n :param plaintext: The plaintext to encrypt, str.\n :return: The ciphertext, str.\n >>> e = EncryptionUtils(\"key\")\n >>> e.vigenere_cipher(\"abc\")\n 'kfa'\n\n \"\"\"", "test_class": "EncryptionUtilsTestVigenereCipher", "test_code": "class EncryptionUtilsTestVigenereCipher(unittest.TestCase):\n def test_vigenere_cipher(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"abc\"), \"kfa\")\n\n def test_vigenere_cipher_2(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"hello\"), \"rijvs\")\n\n def test_vigenere_cipher_3(self):\n encryption_utils = EncryptionUtils(\"longkey\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"AbCdEfG\"), \"LpPjOjE\")\n\n def test_vigenere_cipher_4(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"Hello, World! 123\"), \"Rijvs, Uyvjn! 123\")\n\n def test_vigenere_cipher_5(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"\"), \"\")", "solution_code": "def vigenere_cipher(self, plain_text):\n encrypted_text = \"\"\n key_index = 0\n for char in plain_text:\n if char.isalpha():\n shift = ord(self.key[key_index % len(self.key)].lower()) - ord('a')\n encrypted_char = chr((ord(char.lower()) - ord('a') + shift) % 26 + ord('a'))\n encrypted_text += encrypted_char.upper() if char.isupper() else encrypted_char\n key_index += 1\n else:\n encrypted_text += char\n return encrypted_text", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.key" ], "method_dependencies": [] } }, { "method_name": "rail_fence_cipher", "method_description": "def rail_fence_cipher(self,plain_text, rails):\n \"\"\"\n Encrypts the plaintext using the Rail Fence cipher.\n :param plaintext: The plaintext to encrypt, str.\n :return: The ciphertext, str.\n >>> e = EncryptionUtils(\"key\")\n >>> e.rail_fence_cipher(\"abc\", 2)\n 'acb'\n\n \"\"\"", "test_class": "EncryptionUtilsTestRailFenceCipher", "test_code": "class EncryptionUtilsTestRailFenceCipher(unittest.TestCase):\n def test_rail_fence_cipher(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"abc\", 2), \"acb\")\n\n def test_rail_fence_cipher_2(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"hello\", 2), \"hloel\")\n\n def test_rail_fence_cipher_3(self):\n encryption_utils = EncryptionUtils(\"longkey\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"AbCdEfG\", 2), \"ACEGbdf\")\n\n def test_rail_fence_cipher_4(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"Hello, World! 123\", 2), \"Hlo ol!13el,Wrd 2\")\n\n def test_rail_fence_cipher_5(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"\", 2), \"\")\n\n def test_rail_fence_cipher_6(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"abcdefg\", 3), \"aebdfcg\")", "solution_code": "def rail_fence_cipher(self, plain_text, rails):\n fence = [['\\n' for _ in range(len(plain_text))] for _ in range(rails)]\n direction = -1\n row, col = 0, 0\n\n for char in plain_text:\n if row == 0 or row == rails-1:\n direction = -direction\n\n fence[row][col] = char\n col += 1\n row += direction\n\n encrypted_text = ''\n for i in range(rails):\n for j in range(len(plain_text)):\n if fence[i][j] != '\\n':\n encrypted_text += fence[i][j]\n\n return encrypted_text", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "EncryptionUtilsTestCaesarCipher", "EncryptionUtilsTestVigenereCipher", "EncryptionUtilsTestRailFenceCipher", "EncryptionUtilsTestMain" ]

[ "self.key" ]

[ "import openpyxl" ]

[ { "method_name": "read_excel", "method_description": "def read_excel(self, file_name):\n \"\"\"\n Reading data from Excel files\n :param file_name:str, Excel file name to read\n :return:list of data, Data in Excel\n \"\"\"", "test_class": "ExcelProcessorTestReadExcel", "test_code": "class ExcelProcessorTestReadExcel(unittest.TestCase):\n def test_read_excel_1(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'Age', 'Country'],\n ['John', 25, 'USA'],\n ['Alice', 30, 'Canada'],\n ['Bob', 35, 'Australia']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n data = processor.read_excel(self.test_file_name)\n expected_data = [\n ('Name', 'Age', 'Country'),\n ('John', 25, 'USA'),\n ('Alice', 30, 'Canada'),\n ('Bob', 35, 'Australia')\n ]\n self.assertEqual(data, expected_data)\n\n def test_read_excel_2(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'Age'],\n ['John', 25],\n ['Alice', 30],\n ['Bob', 35]]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n data = processor.read_excel(self.test_file_name)\n expected_data = [\n ('Name', 'Age'),\n ('John', 25),\n ('Alice', 30),\n ('Bob', 35)\n ]\n self.assertEqual(data, expected_data)\n\n def test_read_excel_3(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name'],\n ['John'],\n ['Alice'],\n ['Bob']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n data = processor.read_excel(self.test_file_name)\n expected_data = [\n ('Name',),\n ('John',),\n ('Alice',),\n ('Bob',)\n ]\n self.assertEqual(data, expected_data)\n\n def test_read_excel_4(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'Country'],\n ['John', 'USA'],\n ['Alice', 'Canada'],\n ['Bob', 'Australia']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n data = processor.read_excel(self.test_file_name)\n expected_data = [\n ('Name', 'Country'),\n ('John', 'USA'),\n ('Alice', 'Canada'),\n ('Bob', 'Australia')\n ]\n self.assertEqual(data, expected_data)\n\n def test_read_excel_5(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'Country'],\n ['John', 'USA']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n data = processor.read_excel(self.test_file_name)\n expected_data = [\n ('Name', 'Country'),\n ('John', 'USA')\n ]\n self.assertEqual(data, expected_data)\n\n def test_read_excel_6(self):\n self.test_file_name = ''\n processor = ExcelProcessor()\n res = processor.read_excel(self.test_file_name)\n self.assertEqual(res, None)", "solution_code": "def read_excel(self, file_name):\n data = []\n try:\n workbook = openpyxl.load_workbook(file_name)\n sheet = workbook.active\n for row in sheet.iter_rows(values_only=True):\n data.append(row)\n workbook.close()\n return data\n except:\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [ "openpyxl" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "write_excel", "method_description": "def write_excel(self, data, file_name):\n \"\"\"\n Write data to the specified Excel file\n :param data: list, Data to be written\n :param file_name: str, Excel file name to write to\n :return: 0 or 1, 1 represents successful writing, 0 represents failed writing\n >>> processor = ExcelProcessor()\n >>> new_data = [\n >>> ('Name', 'Age', 'Country'),\n >>> ('John', 25, 'USA'),\n >>> ('Alice', 30, 'Canada'),\n >>> ('Bob', 35, 'Australia'),\n >>> ('Julia', 28, 'Germany')\n >>> ]\n >>> data = processor.write_excel(new_data, 'test_data.xlsx')\n \"\"\"", "test_class": "ExcelProcessorTestWriteExcel", "test_code": "class ExcelProcessorTestWriteExcel(unittest.TestCase):\n def test_write_excel_1(self):\n processor = ExcelProcessor()\n new_data = [\n ('Name', 'Age', 'Country'),\n ('John', 25, 'USA'),\n ('Alice', 30, 'Canada'),\n ('Bob', 35, 'Australia'),\n ('Julia', 28, 'Germany')\n ]\n save_file_name = 'test_output.xlsx'\n success = processor.write_excel(new_data, save_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(save_file_name))\n saved_data = processor.read_excel(save_file_name)\n self.assertEqual(saved_data, new_data)\n os.remove(save_file_name)\n\n def test_write_excel_2(self):\n processor = ExcelProcessor()\n new_data = [\n ('Name', 'Age'),\n ('John', 25),\n ('Alice', 30),\n ('Bob', 35),\n ('Julia', 28)\n ]\n save_file_name = 'test_output.xlsx'\n success = processor.write_excel(new_data, save_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(save_file_name))\n saved_data = processor.read_excel(save_file_name)\n self.assertEqual(saved_data, new_data)\n os.remove(save_file_name)\n\n def test_write_excel_3(self):\n processor = ExcelProcessor()\n new_data = [\n ('Name', 'Age', 'Country'),\n ('John', 25, 'USA'),\n ('Alice', 30, 'Canada'),\n ('Bob', 35, 'Australia')\n ]\n save_file_name = 'test_output.xlsx'\n success = processor.write_excel(new_data, save_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(save_file_name))\n saved_data = processor.read_excel(save_file_name)\n self.assertEqual(saved_data, new_data)\n os.remove(save_file_name)\n\n def test_write_excel_4(self):\n processor = ExcelProcessor()\n new_data = [\n ('Name', 'Age', 'Country'),\n ('John', 25, 'USA'),\n ('Alice', 30, 'Canada')\n ]\n save_file_name = 'test_output.xlsx'\n success = processor.write_excel(new_data, save_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(save_file_name))\n saved_data = processor.read_excel(save_file_name)\n self.assertEqual(saved_data, new_data)\n os.remove(save_file_name)\n\n def test_write_excel_5(self):\n processor = ExcelProcessor()\n new_data = [\n ('Name', 'Age', 'Country'),\n ('John', 25, 'USA')\n ]\n save_file_name = 'test_output.xlsx'\n success = processor.write_excel(new_data, save_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(save_file_name))\n saved_data = processor.read_excel(save_file_name)\n self.assertEqual(saved_data, new_data)\n os.remove(save_file_name)\n\n def test_write_excel_6(self):\n processor = ExcelProcessor()\n new_data = [\n ('Name', 'Age', 'Country'),\n ('John', 25, 'USA')\n ]\n save_file_name = ''\n success = processor.write_excel(new_data, save_file_name)\n self.assertEqual(success, 0)", "solution_code": "def write_excel(self, data, file_name):\n try:\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(file_name)\n workbook.close()\n return 1\n except:\n return 0", "dependencies": { "Standalone": false, "lib_dependencies": [ "openpyxl" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "process_excel_data", "method_description": "def process_excel_data(self, N, save_file_name):\n \"\"\"\n Change the specified column in the Excel file to uppercase\n :param N: int, The serial number of the column that want to change\n :param save_file_name: str, source file name\n :return:(int, str), The former is the return value of write_excel, while the latter is the saved file name of the processed data\n >>> processor = ExcelProcessor()\n >>> success, output_file = processor.process_excel_data(1, 'test_data.xlsx')\n \"\"\"", "test_class": "ExcelProcessorTestProcessExcelData", "test_code": "class ExcelProcessorTestProcessExcelData(unittest.TestCase):\n def test_process_excel_data_1(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'Age', 'Country'],\n ['John', 25, 'USA'],\n ['Alice', 30, 'Canada'],\n ['Bob', 35, 'Australia']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n N = 1\n success, output_file = processor.process_excel_data(N, self.test_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.isfile(output_file))\n processed_data = processor.read_excel(output_file)\n expected_processed_data = [\n ('Name', 'Age', 'Country', 'AGE'),\n ('John', 25, 'USA', 25),\n ('Alice', 30, 'Canada', 30),\n ('Bob', 35, 'Australia', 35)\n ]\n self.assertEqual(processed_data, expected_processed_data)\n os.remove(output_file)\n\n def test_process_excel_data_2(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'Age', 'Country'],\n ['John', 25, 'USA'],\n ['Alice', 30, 'Canada'],\n ['Bob', 35, 'Australia']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n N = 0\n success, output_file = processor.process_excel_data(N, self.test_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.isfile(output_file))\n processed_data = processor.read_excel(output_file)\n expected_processed_data = [\n ('Name', 'Age', 'Country', 'NAME'),\n ('John', 25, 'USA', 'JOHN'),\n ('Alice', 30, 'Canada', 'ALICE'),\n ('Bob', 35, 'Australia', 'BOB')\n ]\n self.assertEqual(processed_data, expected_processed_data)\n os.remove(output_file)\n\n def test_process_excel_data_3(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'Age', 'Country'],\n ['John', 25, 'USA'],\n ['Alice', 30, 'Canada'],\n ['Bob', 35, 'Australia']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n N = 2\n success, output_file = processor.process_excel_data(N, self.test_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.isfile(output_file))\n processed_data = processor.read_excel(output_file)\n expected_processed_data = [\n ('Name', 'Age', 'Country', 'COUNTRY'),\n ('John', 25, 'USA', 'USA'),\n ('Alice', 30, 'Canada', 'CANADA'),\n ('Bob', 35, 'Australia', 'AUSTRALIA')\n ]\n self.assertEqual(processed_data, expected_processed_data)\n os.remove(output_file)\n\n def test_process_excel_data_4(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'Age', 'COUNTRY'],\n ['John', 25, 'USA'],\n ['Alice', 30, 'CANADA'],\n ['Bob', 35, 'AUSTRALIA']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n N = 2\n success, output_file = processor.process_excel_data(N, self.test_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.isfile(output_file))\n processed_data = processor.read_excel(output_file)\n expected_processed_data = [\n ('Name', 'Age', 'COUNTRY', 'COUNTRY'),\n ('John', 25, 'USA', 'USA'),\n ('Alice', 30, 'CANADA', 'CANADA'),\n ('Bob', 35, 'AUSTRALIA', 'AUSTRALIA')\n ]\n self.assertEqual(processed_data, expected_processed_data)\n os.remove(output_file)\n\n def test_process_excel_data_5(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'AGE', 'COUNTRY'],\n ['John', 25, 'USA'],\n ['Alice', 30, 'CANADA'],\n ['Bob', 35, 'AUSTRALIA']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n N = 1\n success, output_file = processor.process_excel_data(N, self.test_file_name)\n self.assertTrue(success)\n self.assertTrue(os.path.isfile(output_file))\n processed_data = processor.read_excel(output_file)\n expected_processed_data = [\n ('Name', 'AGE', 'COUNTRY', 'AGE'),\n ('John', 25, 'USA', 25),\n ('Alice', 30, 'CANADA', 30),\n ('Bob', 35, 'AUSTRALIA', 35)\n ]\n self.assertEqual(processed_data, expected_processed_data)\n os.remove(output_file)\n\n def test_process_excel_data_6(self):\n self.test_file_name = 'test_data.xlsx'\n data = [['Name', 'AGE', 'COUNTRY'],\n ['John', 25, 'USA'],\n ['Alice', 30, 'CANADA'],\n ['Bob', 35, 'AUSTRALIA']]\n workbook = openpyxl.Workbook()\n sheet = workbook.active\n for row in data:\n sheet.append(row)\n workbook.save(self.test_file_name)\n workbook.close()\n\n processor = ExcelProcessor()\n res = processor.process_excel_data(100, self.test_file_name)\n self.assertEqual(res, 0)", "solution_code": "def process_excel_data(self, N, save_file_name):\n data = self.read_excel(save_file_name)\n if data is None or N >= len(data[0]):\n return 0\n new_data = []\n for row in data:\n new_row = list(row[:])\n if not str(row[N]).isdigit():\n new_row.append(str(row[N]).upper())\n else:\n new_row.append(row[N])\n new_data.append(new_row)\n new_file_name = save_file_name.split('.')[0] + '_process.xlsx'\n success = self.write_excel(new_data, new_file_name)\n return success, new_file_name", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "read_excel", "write_excel" ] } } ]

[ "ExcelProcessorTestReadExcel", "ExcelProcessorTestWriteExcel", "ExcelProcessorTestProcessExcelData", "ExcelProcessorTest" ]

[]

[ "import re", "from collections import deque", "from decimal import Decimal" ]

[ { "method_name": "calculate", "method_description": "def calculate(self, expression):\n \"\"\"\n Calculate the result of the given postfix expression\n :param expression: string, the postfix expression to be calculated\n :return: float, the calculated result\n >>> expression_calculator = ExpressionCalculator()\n >>> expression_calculator.calculate(\"2 + 3 * 4\")\n 14.0\n\n \"\"\"", "test_class": "ExpressionCalculatorTestCalculate", "test_code": "class ExpressionCalculatorTestCalculate(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_calculate_1(self):\n result = self.expression_calculator.calculate(\"2 + 3 * 4\")\n self.assertEqual(result, 14.0)\n\n def test_calculate_2(self):\n result = self.expression_calculator.calculate(\"2 + 3 + 4\")\n self.assertEqual(result, 9.0)\n\n def test_calculate_3(self):\n result = self.expression_calculator.calculate(\"2 * 3 * 4\")\n self.assertEqual(result, 24.0)\n\n def test_calculate_4(self):\n result = self.expression_calculator.calculate(\"2 + 4 / 4\")\n self.assertEqual(result, 3.0)\n\n def test_calculate_5(self):\n result = self.expression_calculator.calculate(\"(2 + 3) * 4\")\n self.assertEqual(result, 20.0)", "solution_code": "def calculate(self, expression):\n self.prepare(self.transform(expression))\n\n result_stack = deque()\n self.postfix_stack.reverse()\n\n while self.postfix_stack:\n current_op = self.postfix_stack.pop()\n if not self.is_operator(current_op):\n current_op = current_op.replace(\"~\", \"-\")\n result_stack.append(current_op)\n else:\n second_value = result_stack.pop()\n first_value = result_stack.pop()\n\n first_value = first_value.replace(\"~\", \"-\")\n second_value = second_value.replace(\"~\", \"-\")\n\n temp_result = self._calculate(first_value, second_value, current_op)\n result_stack.append(str(temp_result))\n\n return float(eval(\"*\".join(result_stack)))", "dependencies": { "Standalone": false, "lib_dependencies": [ "re", "deque" ], "field_dependencies": [ "self.postfix_stack" ], "method_dependencies": [ "prepare", "is_operator", "_calculate", "transform" ] } }, { "method_name": "prepare", "method_description": "def prepare(self, expression):\n \"\"\"\n Prepare the infix expression for conversion to postfix notation\n :param expression: string, the infix expression to be prepared\n >>> expression_calculator = ExpressionCalculator()\n >>> expression_calculator.prepare(\"2+3*4\")\n\n expression_calculator.postfix_stack = ['2', '3', '4', '*', '+']\n \"\"\"", "test_class": "ExpressionCalculatorTestPrepare", "test_code": "class ExpressionCalculatorTestPrepare(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_prepare_1(self):\n self.expression_calculator.prepare(\"2+3*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '*', '+']))\n\n def test_prepare_2(self):\n self.expression_calculator.prepare(\"2+3/4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '/', '+']))\n\n def test_prepare_3(self):\n self.expression_calculator.prepare(\"2-3*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '*', '-']))\n\n def test_prepare_4(self):\n self.expression_calculator.prepare(\"1+3*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['1', '3', '4', '*', '+']))\n\n def test_prepare_5(self):\n self.expression_calculator.prepare(\"(2+3)*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '+', '4', '*']))\n\n def test_prepare_6(self):\n self.expression_calculator.prepare(\"\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque([]))", "solution_code": "def prepare(self, expression):\n op_stack = deque([','])\n arr = list(expression)\n current_index = 0\n count = 0\n\n for i, current_op in enumerate(arr):\n if self.is_operator(current_op):\n if count > 0:\n self.postfix_stack.append(\"\".join(arr[current_index: current_index + count]))\n peek_op = op_stack[-1]\n if current_op == ')':\n while op_stack[-1] != '(':\n self.postfix_stack.append(str(op_stack.pop()))\n op_stack.pop()\n else:\n while current_op != '(' and peek_op != ',' and self.compare(current_op, peek_op):\n self.postfix_stack.append(str(op_stack.pop()))\n peek_op = op_stack[-1]\n op_stack.append(current_op)\n\n count = 0\n current_index = i + 1\n else:\n count += 1\n\n if count > 1 or (count == 1 and not self.is_operator(arr[current_index])):\n self.postfix_stack.append(\"\".join(arr[current_index: current_index + count]))\n\n while op_stack[-1] != ',':\n self.postfix_stack.append(str(op_stack.pop()))", "dependencies": { "Standalone": false, "lib_dependencies": [ "re", "deque" ], "field_dependencies": [ "self.postfix_stack" ], "method_dependencies": [ "is_operator", "compare" ] } }, { "method_name": "is_operator", "method_description": "@staticmethod\n def is_operator(c):\n \"\"\"\n Check if a character is an operator in {'+', '-', '*', '/', '(', ')', '%'}\n :param c: string, the character to be checked\n :return: bool, True if the character is an operator, False otherwise\n >>> expression_calculator = ExpressionCalculator()\n >>> expression_calculator.is_operator(\"+\")\n True\n\n \"\"\"", "test_class": "ExpressionCalculatorTestIsOperator", "test_code": "class ExpressionCalculatorTestIsOperator(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_is_operator_1(self):\n self.assertTrue(self.expression_calculator.is_operator(\"+\"))\n\n def test_is_operator_2(self):\n self.assertTrue(self.expression_calculator.is_operator(\"-\"))\n\n def test_is_operator_3(self):\n self.assertTrue(self.expression_calculator.is_operator(\"*\"))\n\n def test_is_operator_4(self):\n self.assertTrue(self.expression_calculator.is_operator(\"/\"))\n\n def test_is_operator_5(self):\n self.assertFalse(self.expression_calculator.is_operator(\"5\"))", "solution_code": "@staticmethod\n def is_operator(c):\n return c in {'+', '-', '*', '/', '(', ')', '%'}", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "compare", "method_description": "def compare(self, cur, peek):\n \"\"\"\n Compare the precedence of two operators\n :param cur: string, the current operator\n :param peek: string, the operator at the top of the operator stack\n :return: bool, True if the current operator has higher or equal precedence, False otherwise\n >>> expression_calculator = ExpressionCalculator()\n >>> expression_calculator.compare(\"+\", \"-\")\n True\n\n \"\"\"", "test_class": "ExpressionCalculatorTestCompare", "test_code": "class ExpressionCalculatorTestCompare(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_compare_1(self):\n result = self.expression_calculator.compare(\"+\", \"-\")\n self.assertTrue(result)\n\n def test_compare_2(self):\n result = self.expression_calculator.compare(\"*\", \"/\")\n self.assertTrue(result)\n\n def test_compare_3(self):\n result = self.expression_calculator.compare(\"+\", \"*\")\n self.assertTrue(result)\n\n def test_compare_4(self):\n result = self.expression_calculator.compare(\"*\", \"+\")\n self.assertFalse(result)\n\n def test_compare_5(self):\n result = self.expression_calculator.compare(\"/\", \"+\")\n self.assertFalse(result)\n\n def test_compare_6(self):\n result = self.expression_calculator.compare(\"%\", \"+\")\n self.assertFalse(result)\n\n def test_compare_7(self):\n result = self.expression_calculator.compare(\"+\", \"%\")\n self.assertTrue(result)", "solution_code": "def compare(self, cur, peek):\n if cur == '%':\n cur = '/'\n if peek == '%':\n peek = '/'\n return self.operat_priority[ord(peek) - 40] >= self.operat_priority[ord(cur) - 40]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.operat_priority" ], "method_dependencies": [] } }, { "method_name": "_calculate", "method_description": "@staticmethod\n def _calculate(first_value, second_value, current_op):\n \"\"\"\n Perform the mathematical calculation based on the given operands and operator\n :param first_value: string, the first operand\n :param second_value: string, the second operand\n :param current_op: string, the operator\n :return: decimal.Decimal, the calculated result\n >>> expression_calculator = ExpressionCalculator()\n >>> expression_calculator._calculate(\"2\", \"3\", \"+\")\n 5.0\n\n \"\"\"", "test_class": "ExpressionCalculatorTestCalculateMethod", "test_code": "class ExpressionCalculatorTestCalculateMethod(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_calculate_method_1(self):\n result = self.expression_calculator._calculate(\"2\", \"3\", \"+\")\n self.assertEqual(result, Decimal(5.0))\n\n def test_calculate_method_2(self):\n result = self.expression_calculator._calculate(\"3\", \"2\", \"-\")\n self.assertEqual(result, Decimal(1.0))\n\n def test_calculate_method_3(self):\n result = self.expression_calculator._calculate(\"2\", \"3\", \"*\")\n self.assertEqual(result, Decimal(6.0))\n\n def test_calculate_method_4(self):\n result = self.expression_calculator._calculate(\"3\", \"3\", \"/\")\n self.assertEqual(result, Decimal(1.0))\n\n def test_calculate_method_5(self):\n result = self.expression_calculator._calculate(\"6\", \"2\", \"/\")\n self.assertEqual(result, Decimal(3.0))\n\n def test_calculate_method_6(self):\n result = self.expression_calculator._calculate(\"6\", \"2\", \"%\")\n self.assertEqual(result, Decimal(0.0))\n\n def test_calculate_method_7(self):\n try:\n self.expression_calculator._calculate(\"6\", \"2\", \"??\")\n except:\n pass", "solution_code": "@staticmethod\n def _calculate(first_value, second_value, current_op):\n if current_op == '+':\n return Decimal(first_value) + Decimal(second_value)\n elif current_op == '-':\n return Decimal(first_value) - Decimal(second_value)\n elif current_op == '*':\n return Decimal(first_value) * Decimal(second_value)\n elif current_op == '/':\n return Decimal(first_value) / Decimal(second_value)\n elif current_op == '%':\n return Decimal(first_value) % Decimal(second_value)\n else:\n raise ValueError(\"Unexpected operator: {}\".format(current_op))", "dependencies": { "Standalone": false, "lib_dependencies": [ "Decimal" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "transform", "method_description": "@staticmethod\n def transform(expression):\n \"\"\"\n Transform the infix expression to a format suitable for conversion\n :param expression: string, the infix expression to be transformed\n :return: string, the transformed expression\n >>> expression_calculator = ExpressionCalculator()\n >>> expression_calculator.transform(\"2 + 3 * 4\")\n \"2+3*4\"\n\n \"\"\"", "test_class": "ExpressionCalculatorTestTransform", "test_code": "class ExpressionCalculatorTestTransform(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_transform_1(self):\n result = self.expression_calculator.transform(\"2 + 3 * 4\")\n self.assertEqual(result, \"2+3*4\")\n\n def test_transform_2(self):\n result = self.expression_calculator.transform(\"2 + 3 / 4\")\n self.assertEqual(result, \"2+3/4\")\n\n def test_transform_3(self):\n result = self.expression_calculator.transform(\"2 - 3 * 4\")\n self.assertEqual(result, \"2-3*4\")\n\n def test_transform_4(self):\n result = self.expression_calculator.transform(\"1 + 3 * 4\")\n self.assertEqual(result, \"1+3*4\")\n\n def test_transform_5(self):\n result = self.expression_calculator.transform(\"-2 + (-3) * 4\")\n self.assertEqual(result, \"~2+(~3)*4\")\n\n def test_transform_6(self):\n result = self.expression_calculator.transform(\"~(1 + 1)\")\n self.assertEqual(result, \"0-(1+1)\")", "solution_code": "@staticmethod\n def transform(expression):\n expression = re.sub(r\"\\s+\", \"\", expression)\n expression = re.sub(r\"=$\", \"\", expression)\n arr = list(expression)\n\n for i, c in enumerate(arr):\n if c == '-':\n if i == 0:\n arr[i] = '~'\n else:\n prev_c = arr[i - 1]\n if prev_c in {'+', '-', '*', '/', '(', 'E', 'e'}:\n arr[i] = '~'\n\n if arr[0] == '~' and (len(arr) > 1 and arr[1] == '('):\n arr[0] = '-'\n return \"0\" + \"\".join(arr)\n else:\n return \"\".join(arr)", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "ExpressionCalculatorTestCalculate", "ExpressionCalculatorTestPrepare", "ExpressionCalculatorTestIsOperator", "ExpressionCalculatorTestCompare", "ExpressionCalculatorTestCalculateMethod", "ExpressionCalculatorTestTransform", "ExpressionCalculatorTest" ]

[ "self.operat_priority", "self.postfix_stack" ]

[]

[ { "method_name": "get_BMI", "method_description": "def get_BMI(self):\n \"\"\"\n Calculate the BMI based on the height and weight.\n :return: BMI,which is the weight divide by the square of height, float.\n >>> fitnessTracker = FitnessTracker(1.8, 70, 20, \"male\")\n >>> fitnessTracker.get_BMI()\n 21.604938271604937\n\n \"\"\"", "test_class": "FitnessTrackerTestGetBMI", "test_code": "class FitnessTrackerTestGetBMI(unittest.TestCase):\n def test_get_BMI(self):\n fitnessTracker = FitnessTracker(1.8, 70, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 21.604938271604937)\n\n def test_get_BMI_2(self):\n fitnessTracker = FitnessTracker(1.8, 50, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 15.432098765432098)\n\n def test_get_BMI_3(self):\n fitnessTracker = FitnessTracker(1.72, 53, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 17.915089237425637)\n\n def test_get_BMI_4(self):\n fitnessTracker = FitnessTracker(1.72, 60, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 20.281233098972418)\n\n def test_get_BMI_5(self):\n fitnessTracker = FitnessTracker(1.72, 65, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 21.971335857220122)", "solution_code": "def get_BMI(self):\n return self.weight / self.height ** 2", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.height", "self.weight" ], "method_dependencies": [] } }, { "method_name": "condition_judge", "method_description": "def condition_judge(self):\n \"\"\"\n Judge the condition of the user based on the BMI standard.\n :return: 1 if the user is too fat, -1 if the user is too thin, 0 if the user is normal, int.\n >>> fitnessTracker = FitnessTracker(1.8, 70, 20, \"male\")\n >>> fitnessTracker.condition_judge()\n -1\n\n \"\"\"", "test_class": "FitnessTrackerTestConditionJudge", "test_code": "class FitnessTrackerTestConditionJudge(unittest.TestCase):\n def test_condition_judge(self):\n fitnessTracker = FitnessTracker(1.8, 45, 20, \"female\")\n self.assertEqual(fitnessTracker.condition_judge(), -1)\n\n def test_condition_judge_2(self):\n fitnessTracker = FitnessTracker(1.72, 80, 22, \"female\")\n self.assertEqual(fitnessTracker.condition_judge(), 1)\n\n def test_condition_judge_3(self):\n fitnessTracker = FitnessTracker(1.72, 53, 22, \"male\")\n self.assertEqual(fitnessTracker.condition_judge(), -1)\n\n def test_condition_judge_4(self):\n fitnessTracker = FitnessTracker(1.72, 60, 22, \"male\")\n self.assertEqual(fitnessTracker.condition_judge(), 0)\n\n def test_condition_judge_5(self):\n fitnessTracker = FitnessTracker(1.72, 75, 22, \"male\")\n self.assertEqual(fitnessTracker.condition_judge(), 1)", "solution_code": "def condition_judge(self):\n BMI = self.get_BMI()\n if self.sex == \"male\":\n BMI_range = self.BMI_std[0][\"male\"]\n else:\n BMI_range = self.BMI_std[1][\"female\"]\n if BMI > BMI_range[1]:\n # too fat\n return 1\n elif BMI < BMI_range[0]:\n # too thin\n return -1\n else:\n # normal\n return 0", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.BMI_std", "self.sex" ], "method_dependencies": [ "get_BMI" ] } }, { "method_name": "calculate_calorie_intake", "method_description": "def calculate_calorie_intake(self):\n \"\"\"\n Calculate the calorie intake based on the user's condition and BMR (Basal Metabolic Rate),BMR is calculated based on the user's height, weight, age, and sex,male is10 * self.weight + 6.25 * self.height - 5 * self.age + 5,female is 10 * self.weight + 6.25 * self.height - 5 * self.age - 161, and the calorie intake is calculated based on the BMR and the user's condition,if the user is too fat, the calorie intake is BMR * 1.2, if the user is too thin, the calorie intake is BMR * 1.6, if the user is normal, the calorie intake is BMR * 1.4.\n :return: calorie intake, float.\n >>> fitnessTracker = FitnessTracker(1.8, 70, 20, \"male\")\n >>> fitnessTracker.calculate_calorie_intake()\n 986.0\n\n \"\"\"", "test_class": "FitnessTrackerTestCaculateCalorieIntake", "test_code": "class FitnessTrackerTestCaculateCalorieIntake(unittest.TestCase):\n def test_calculate_calorie_intake(self):\n fitnessTracker = FitnessTracker(1.8, 70, 20, \"female\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 630.3499999999999)\n\n def test_calculate_calorie_intake_2(self):\n fitnessTracker = FitnessTracker(1.72, 80, 22, \"female\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 647.6999999999999)\n\n def test_calculate_calorie_intake_3(self):\n fitnessTracker = FitnessTracker(1.72, 53, 22, \"male\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 697.2)\n\n def test_calculate_calorie_intake_4(self):\n fitnessTracker = FitnessTracker(1.72, 60, 22, \"male\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 708.05)\n\n def test_calculate_calorie_intake_5(self):\n fitnessTracker = FitnessTracker(1.72, 75, 22, \"male\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 786.9)", "solution_code": "def calculate_calorie_intake(self):\n if self.sex == \"male\":\n BMR = 10 * self.weight + 6.25 * self.height - 5 * self.age + 5\n else:\n BMR = 10 * self.weight + 6.25 * self.height - 5 * self.age - 161\n if self.condition_judge() == 1:\n calorie_intake = BMR * 1.2 # Sedentary lifestyle\n elif self.condition_judge() == -1:\n calorie_intake = BMR * 1.6 # Active lifestyle\n else:\n calorie_intake = BMR * 1.4 # Moderate lifestyle\n return calorie_intake", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.age", "self.height", "self.sex", "self.weight" ], "method_dependencies": [ "condition_judge" ] } } ]

[ "FitnessTrackerTestGetBMI", "FitnessTrackerTestConditionJudge", "FitnessTrackerTestCaculateCalorieIntake", "FitnessTrackerTestMain" ]

[ "self.BMI_std", "self.age", "self.height", "self.sex", "self.weight" ]

[]

[ { "method_name": "make_move", "method_description": "def make_move(self, row, col):\n \"\"\"\n Makes a move at the given row and column.\n If the move is valid, it places the current player's symbol on the board\n and changes the current player to the other player (if the current player is 'X', then it becomes 'O' and vice versa).\n :param row: int, the row index of this move\n :param col: int, the column index\n return: True if the move is valid, or False otherwise.\n >>> gomokuGame = GomokuGame(10)\n >>> gomokuGame.make_move(5, 5)\n True\n >>> gomokuGame.make_move(5, 5)\n False\n \"\"\"", "test_class": "GomokuGameTestMakeMove", "test_code": "class GomokuGameTestMakeMove(unittest.TestCase):\n def setUp(self) -> None:\n self.board_size = 10\n self.gomokuGame = GomokuGame(self.board_size)\n\n def test_make_move_1(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n board[0][0] = 'X'\n self.assertEqual(board, self.gomokuGame.board)\n\n # same position\n def test_make_move_2(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n self.assertEqual(False, self.gomokuGame.make_move(0, 0))\n board[0][0] = 'X'\n self.assertEqual(board, self.gomokuGame.board)\n\n def test_make_move_3(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n self.assertEqual(True, self.gomokuGame.make_move(0, 1))\n board[0][0] = 'X'\n board[0][1] = 'O'\n self.assertEqual(board, self.gomokuGame.board)\n\n def test_make_move_4(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n self.assertEqual(True, self.gomokuGame.make_move(0, 1))\n self.assertEqual(False, self.gomokuGame.make_move(0, 0))\n board[0][0] = 'X'\n board[0][1] = 'O'\n self.assertEqual(board, self.gomokuGame.board)\n\n def test_make_move_5(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n self.assertEqual(True, self.gomokuGame.make_move(0, 1))\n self.assertEqual(False, self.gomokuGame.make_move(0, 1))\n board[0][0] = 'X'\n board[0][1] = 'O'\n self.assertEqual(board, self.gomokuGame.board)", "solution_code": "def make_move(self, row, col):\n if self.board[row][col] == ' ':\n self.board[row][col] = self.current_player\n self.current_player = 'O' if self.current_player == 'X' else 'X'\n return True\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.board", "self.current_player" ], "method_dependencies": [] } }, { "method_name": "check_winner", "method_description": "def check_winner(self):\n \"\"\"\n Checks if there is a winner by looking for five in a row in all directions (horizontal, vertical, diagonal).\n return: the symbol of the winning player (either 'X' or 'O') if there is a winner, or None otherwise.\n >>> gomokuGame = GomokuGame(10)\n >>> moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1)]\n >>> for move in moves:\n ... gomokuGame.make_move(move[0], move[1])\n >>> gomokuGame.check_winner()\n 'X'\n \"\"\"", "test_class": "GomokuGameTestCheckWinner", "test_code": "class GomokuGameTestCheckWinner(unittest.TestCase):\n def test_check_winner_1(self):\n gomokuGame = GomokuGame(10)\n self.assertEqual(None, gomokuGame.check_winner())\n\n def test_check_winner_2(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1)]\n for move in moves:\n gomokuGame.make_move(move[0], move[1])\n self.assertEqual('X', gomokuGame.check_winner())\n\n def test_check_winner_3(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 0), (0, 4)]\n for move in moves:\n gomokuGame.make_move(move[0], move[1])\n self.assertEqual('O', gomokuGame.check_winner())\n\n def test_check_winner_4(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1), (0, 4)]\n for move in moves:\n gomokuGame.make_move(move[0], move[1])\n self.assertEqual(gomokuGame.check_winner(), 'O')\n\n def test_check_winner_5(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1), (0, 4), (5, 0)]\n for move in moves:\n gomokuGame.make_move(move[0], move[1])\n self.assertEqual('O', gomokuGame.check_winner())", "solution_code": "def check_winner(self):\n directions = [(0, 1), (1, 0), (1, 1), (1, -1)]\n for row in range(self.board_size):\n for col in range(self.board_size):\n if self.board[row][col] != ' ':\n for direction in directions:\n if self._check_five_in_a_row(row, col, direction):\n return self.board[row][col]\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.board", "self.board_size" ], "method_dependencies": [ "_check_five_in_a_row" ] } }, { "method_name": "_check_five_in_a_row", "method_description": "def _check_five_in_a_row(self, row, col, direction):\n \"\"\"\n checks if there are five consecutive symbols of the same player in a row starting from a given cell in a given direction (horizontal, vertical, diagonal).\n Counts the number of consecutive symbols in that direction starting from the given cell,\n :param row: int, row of the given cell\n :param col: int, column of the given cell\n :param direction: tuple, (int, int), named as (dx, dy). Row and col will plus several dx and dy repectively.\n :return: True if there are five consecutive symbols of the same player, and False otherwise.\n >>> gomokuGame = GomokuGame(10)\n >>> moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1)]\n >>> for move in moves:\n ... gomokuGame.make_move(move[0], move[1])\n >>> gomokuGame._check_five_in_a_row(5, 1, (0, 1))\n True\n >>> gomokuGame._check_five_in_a_row(5, 1, (1, 1))\n False\n \"\"\"", "test_class": "GomokuGameTestCheckFiveInARow", "test_code": "class GomokuGameTestCheckFiveInARow(unittest.TestCase):\n def setUp(self) -> None:\n self.gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1)]\n for move in moves:\n self.gomokuGame.make_move(move[0], move[1])\n\n def test_check_five_in_a_row_1(self):\n self.assertEqual(True, self.gomokuGame._check_five_in_a_row(5, 5, (0, -1)))\n\n def test_check_five_in_a_row_2(self):\n self.assertEqual(True, self.gomokuGame._check_five_in_a_row(5, 1, (0, 1)))\n\n def test_check_five_in_a_row_3(self):\n self.assertEqual(False, self.gomokuGame._check_five_in_a_row(0, 0, (0, 1)))\n\n def test_check_five_in_a_row_4(self):\n self.assertEqual(False, self.gomokuGame._check_five_in_a_row(0, 0, (1, 0)))\n\n def test_check_five_in_a_row_5(self):\n self.assertEqual(False, self.gomokuGame._check_five_in_a_row(5, 5, (1, 0)))", "solution_code": "def _check_five_in_a_row(self, row, col, direction):\n dx, dy = direction\n count = 1\n symbol = self.board[row][col]\n for i in range(1, 5):\n new_row = row + dx * i\n new_col = col + dy * i\n if not (0 <= new_row < self.board_size and 0 <= new_col < self.board_size):\n return False\n if self.board[new_row][new_col] != symbol:\n return False\n count += 1\n return count == 5", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.board", "self.board_size" ], "method_dependencies": [] } } ]

[ "GomokuGameTestMakeMove", "GomokuGameTestCheckWinner", "GomokuGameTestCheckFiveInARow", "GomokuGameTestMain" ]

[ "self.board", "self.board_size", "self.current_player" ]

[]

[ { "method_name": "book_room", "method_description": "def book_room(self, room_type, room_number, name):\n \"\"\"\n Check if there are any rooms of the specified type available.\n if rooms are adequate, modify available_rooms and booked_rooms and finish booking, or fail to book otherwise.\n :param room_type: str\n :param room_number: int, the expected number of specified type rooms to be booked\n :param name: str, guest name\n :return: if number of rooms about to be booked doesn't exceed the remaining rooms, return str 'Success!'\n if exceeds but quantity of available rooms is not equal to zero, return int(the remaining quantity of this room type).\n if exceeds and quantity is zero or the room_type isn't in available_room, return False.\n >>> hotel = Hotel('peace hotel', {'single': 5, 'double': 3})\n >>> hotel.book_room('single', 1, 'guest 1')\n 'Success!'\n >>> hotel.book_room('single', 5, 'guest 1')\n 4\n >>> hotel.book_room('single', 4, 'guest 1')\n 'Success!'\n >>> hotel.book_room('single', 1, 'guest 1')\n False\n >>> hotel.book_room('triple', 1, 'guest 1')\n False\n \"\"\"", "test_class": "HotelTestBookRoom", "test_code": "class HotelTestBookRoom(unittest.TestCase):\n def setUp(self):\n self.hotel = Hotel('peace hotel', {'single': 3, 'double': 2})\n\n def test_book_room_1(self):\n result = self.hotel.book_room('single', 2, 'guest 1')\n self.assertEqual(result, 'Success!')\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\n self.assertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n\n def test_book_room_2(self):\n result = self.hotel.book_room('triple', 2, 'guest 1')\n self.assertFalse(result)\n self.assertEqual(self.hotel.booked_rooms, {})\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 2})\n\n def test_book_room_3(self):\n self.hotel.book_room('single', 2, 'guest 1')\n result = self.hotel.book_room('single', 2, 'guest 2')\n self.assertEqual(result, 1)\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\n self.assertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n\n def test_book_room_4(self):\n self.hotel.book_room('single', 2, 'guest 1')\n result = self.hotel.book_room('single', 1, 'guest 2')\n self.assertEqual(result, 'Success!')\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2, 'guest 2': 1}})\n self.assertEqual(self.hotel.available_rooms, {'double': 2, 'single': 0})\n\n def test_book_room_5(self):\n self.hotel.book_room('single', 2, 'guest 1')\n result = self.hotel.book_room('single', 3, 'guest 2')\n self.assertEqual(result, 1)\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\n self.assertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n\n def test_book_room_6(self):\n self.hotel.book_room('single', 3, 'guest 1')\n result = self.hotel.book_room('single', 100, 'guest 1')\n self.assertFalse(result)", "solution_code": "def book_room(self, room_type, room_number, name):\n # Check if there are any rooms of the specified type available\n if room_type not in self.available_rooms.keys():\n return False\n\n if room_number <= self.available_rooms[room_type]:\n # Book the room by adding it to the booked_rooms dictionary\n if room_type not in self.booked_rooms.keys():\n self.booked_rooms[room_type] = {}\n self.booked_rooms[room_type][name] = room_number\n self.available_rooms[room_type] -= room_number\n return \"Success!\"\n elif self.available_rooms[room_type] != 0:\n return self.available_rooms[room_type]\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.available_rooms", "self.booked_rooms" ], "method_dependencies": [] } }, { "method_name": "check_in", "method_description": "def check_in(self, room_type, room_number, name):\n \"\"\"\n Check if the room of the specified type and number is booked by the person named name.\n Remove this name when check in successfuly(room_number is equal to specific person's booked_rooms. When the actual check in quantity (room_number) is less than the booked quantity, number in booked_rooms will be booked quantity minus actual quantity\n :param room_type: str, check in room type\n :param room_number: int, check in room number\n :param name: str, person name\n :return False: only if the room_type is not in the booked_rooms or room_number is higher than quantity in booked rooms.\n >>> hotel = Hotel('peace hotel', {'single': 5, 'double': 3})\n >>> hotel.book_room('single', 1, 'guest 1')\n 'Success!'\n >>> hotel.check_in('single', 2, 'guest 1')\n False\n >>> hotel.check_in('single', 1, 'guest 1')\n >>> hotel.booked_rooms\n {'single': {}}\n \"\"\"", "test_class": "HotelTestCheckIn", "test_code": "class HotelTestCheckIn(unittest.TestCase):\n def setUp(self):\n self.hotel = Hotel('Test Hotel', {'single': 3, 'double': 2})\n self.hotel.booked_rooms = {'single': {'guest 1': 2}, 'double': {'guest 2': 1}}\n\n def test_check_in_1(self):\n self.hotel.check_in('single', 1, 'guest 1')\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 1}, 'double': {'guest 2': 1}})\n\n def test_check_in_2(self):\n self.assertFalse(self.hotel.check_in('single', 3, 'guest 1'))\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_in_3(self):\n self.assertFalse(self.hotel.check_in('double', 1, 'guest 1'))\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_in_4(self):\n self.hotel.check_in('double', 1, 'guest 2')\n self.assertEqual(self.hotel.booked_rooms, {'double': {}, 'single': {'guest 1': 2}})\n\n def test_check_in_5(self):\n self.hotel.check_in('double', 2, 'guest 2')\n self.assertEqual(self.hotel.booked_rooms, {'double': {'guest 2': 1}, 'single': {'guest 1': 2}})\n\n def test_check_in_6(self):\n res = self.hotel.check_in('abc', 1, 'guest 1')\n self.assertFalse(res)", "solution_code": "def check_in(self, room_type, room_number, name):\n # Check if the room of the specified type and number is booked\n if room_type not in self.booked_rooms.keys():\n return False\n if name in self.booked_rooms[room_type]:\n if room_number > self.booked_rooms[room_type][name]:\n return False\n elif room_number == self.booked_rooms[room_type][name]:\n # Check in the room by removing it from the booked_rooms dictionary\n self.booked_rooms[room_type].pop(name)\n else:\n self.booked_rooms[room_type][name] -= room_number", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.booked_rooms" ], "method_dependencies": [] } }, { "method_name": "check_out", "method_description": "def check_out(self, room_type, room_number):\n \"\"\"\n Check out rooms, add number for specific type in available_rooms.\n If room_type is new, add new type in available_rooms.\n :param room_type: str, check out room type\n :param room_number: int, check out room number\n >>> hotel = Hotel('peace hotel', {'single': 5, 'double': 3})\n >>> hotel.check_out('single', 2)\n >>> hotel.available_rooms\n {'single': 7, 'double': 3}\n >>> hotel.check_out('triple', 2)\n >>> hotel.available_rooms\n {'single': 7, 'double': 3, 'triple': 2}\n \"\"\"", "test_class": "HotelTestCheckOut", "test_code": "class HotelTestCheckOut(unittest.TestCase):\n def setUp(self):\n self.hotel = Hotel('Test Hotel', {'single': 3, 'double': 2})\n self.hotel.booked_rooms = {'single': {'guest 1': 2}, 'double': {'guest 2': 1}}\n\n def test_check_out_1(self):\n self.hotel.check_out('single', 1)\n self.assertEqual(self.hotel.available_rooms, {'single': 4, 'double': 2})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_out_2(self):\n self.hotel.check_out('single', 3)\n self.assertEqual(self.hotel.available_rooms, {'single': 6, 'double': 2})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_out_3(self):\n self.hotel.check_out('triple', 2)\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 2, 'triple': 2})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_out_4(self):\n self.hotel.check_out('double', 1)\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 3})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_out_5(self):\n self.hotel.check_out('double', 2)\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 4})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})", "solution_code": "def check_out(self, room_type, room_number):\n if room_type in self.available_rooms:\n self.available_rooms[room_type] += room_number\n else:\n self.available_rooms[room_type] = room_number", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.available_rooms" ], "method_dependencies": [] } }, { "method_name": "get_available_rooms", "method_description": "def get_available_rooms(self, room_type):\n \"\"\"\n Get the number of specific type of available rooms.\n :param room_type: str, the room type that want to know\n :return: int, the remaining number of this type rooms.\n >>> hotel = Hotel('peace hotel', {'single': 5, 'double': 3})\n >>> hotel.get_available_rooms('single')\n 5\n \"\"\"", "test_class": "HotelTestAvailableRooms", "test_code": "class HotelTestAvailableRooms(unittest.TestCase):\n def setUp(self):\n self.hotel = Hotel('Test Hotel', {'single': 3, 'double': 2, 'triple': 2})\n\n def test_get_available_rooms(self):\n result = self.hotel.get_available_rooms('single')\n self.assertEqual(result, 3)\n\n def test_get_available_rooms_2(self):\n self.hotel.book_room('single', 2, 'guest 1')\n result = self.hotel.get_available_rooms('single')\n self.assertEqual(result, 1)\n\n def test_get_available_rooms_3(self):\n self.hotel.book_room('single', 3, 'guest 1')\n result = self.hotel.get_available_rooms('single')\n self.assertEqual(result, 0)\n\n def test_get_available_rooms_4(self):\n self.hotel.book_room('single', 3, 'guest 1')\n result = self.hotel.get_available_rooms('double')\n self.assertEqual(result, 2)\n\n def test_get_available_rooms_5(self):\n self.hotel.book_room('single', 3, 'guest 1')\n result = self.hotel.get_available_rooms('triple')\n self.assertEqual(result, 2)", "solution_code": "def get_available_rooms(self, room_type):\n return self.available_rooms[room_type]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.available_rooms" ], "method_dependencies": [] } } ]

[ "HotelTestBookRoom", "HotelTestCheckIn", "HotelTestCheckOut", "HotelTestAvailableRooms", "HotelTestMain" ]

[ "self.available_rooms", "self.booked_rooms", "self.name" ]

[]

[ { "method_name": "add_employee", "method_description": "def add_employee(self, employee_id, name, position, department, salary):\n \"\"\"\n Add a new employee to the HRManagementSystem.\n :param employee_id: The employee's id, int.\n :param name: The employee's name, str.\n :param position: The employee's position, str.\n :param department: The employee's department, str.\n :param salary: The employee's salary, int.\n :return: If the employee is already in the HRManagementSystem, returns False, otherwise, returns True.\n >>> hrManagementSystem = HRManagementSystem()\n >>> hrManagementSystem.add_employee(1, 'John', 'Manager', 'Sales', 100000)\n True\n >>> hrManagementSystem.add_employee(1, 'John', 'Manager', 'Sales', 100000)\n False\n\n \"\"\"", "test_class": "HRManagementSystemTestAddEmployee", "test_code": "class HRManagementSystemTestAddEmployee(unittest.TestCase):\n def test_add_employee(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000})\n\n def test_add_employee_2(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), False)\n self.assertEqual(hr_system.employees[1], {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000})\n\n def test_add_employee_3(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(2, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.employees,{1: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}, 2: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\n\n def test_add_employee_4(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(2, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), False)\n self.assertEqual(hr_system.employees,{1: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}, 2: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\n\n def test_add_employee_5(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(2, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), False)\n self.assertEqual(hr_system.add_employee(2, \"John Doe\", \"Manager\", \"HR\", 5000), False)\n self.assertEqual(hr_system.employees,{1: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}, 2: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})", "solution_code": "def add_employee(self, employee_id, name, position, department, salary):\n if employee_id in self.employees:\n return False\n else:\n self.employees[employee_id] = {\n 'name': name,\n 'position': position,\n 'department': department,\n 'salary': salary\n }\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.employees" ], "method_dependencies": [] } }, { "method_name": "remove_employee", "method_description": "def remove_employee(self, employee_id):\n \"\"\"\n Remove an employee from the HRManagementSystem.\n :param employee_id: The employee's id, int.\n :return: If the employee is already in the HRManagementSystem, returns True, otherwise, returns False.\n >>> hrManagementSystem = HRManagementSystem()\n >>> hrManagementSystem.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n >>> hrManagementSystem.remove_employee(1)\n True\n >>> hrManagementSystem.remove_employee(2)\n False\n\n \"\"\"", "test_class": "HRManagementSystemTestRemoveEmployee", "test_code": "class HRManagementSystemTestRemoveEmployee(unittest.TestCase):\n def test_remove_employee(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.employees, {})\n\n def test_remove_employee_2(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.remove_employee(1), False)\n self.assertEqual(hr_system.employees, {})\n\n def test_remove_employee_3(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.employees, {2: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_remove_employee_4(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.remove_employee(2), True)\n self.assertEqual(hr_system.employees, {})\n\n def test_remove_employee_5(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.remove_employee(2), True)\n self.assertEqual(hr_system.remove_employee(1), False)\n self.assertEqual(hr_system.remove_employee(2), False)\n self.assertEqual(hr_system.employees, {})", "solution_code": "def remove_employee(self, employee_id):\n if employee_id in self.employees:\n del self.employees[employee_id]\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.employees" ], "method_dependencies": [] } }, { "method_name": "update_employee", "method_description": "def update_employee(self, employee_id: int, employee_info: dict):\n \"\"\"\n Update an employee's information in the HRManagementSystem.\n :param employee_id: The employee's id, int.\n :param employee_info: The employee's information, dict.\n :return: If the employee is already in the HRManagementSystem, returns True, otherwise, returns False.\n >>> hrManagementSystem = HRManagementSystem()\n >>> hrManagementSystem.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n >>> hrManagementSystem.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000})\n True\n >>> hrManagementSystem.update_employee(2, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000})\n False\n\n \"\"\"", "test_class": "HRManagementSystemTestUpdateEmployee", "test_code": "class HRManagementSystemTestUpdateEmployee(unittest.TestCase):\n def test_update_employee(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000})\n\n def test_update_employee_2(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {}\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), False)\n self.assertEqual(hr_system.employees, {})\n\n def test_update_employee_3(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(2, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), False)\n self.assertEqual(hr_system.employees, {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_update_employee_4(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000})\n\n def test_update_employee_5(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n\n def test_update_employee_6(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(1, {'Name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), False)", "solution_code": "def update_employee(self, employee_id: int, employee_info: dict):\n employee = self.get_employee(employee_id)\n if employee == False:\n return False\n else:\n for key, value in employee_info.items():\n if key not in employee:\n return False\n for key, value in employee_info.items():\n employee[key] = value\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "get_employee" ] } }, { "method_name": "get_employee", "method_description": "def get_employee(self, employee_id):\n \"\"\"\n Get an employee's information from the HRManagementSystem.\n :param employee_id: The employee's id, int.\n :return: If the employee is already in the HRManagementSystem, returns the employee's information, otherwise, returns False.\n >>> hrManagementSystem = HRManagementSystem()\n >>> hrManagementSystem.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n >>> hrManagementSystem.get_employee(1)\n {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}\n >>> hrManagementSystem.get_employee(2)\n False\n\n \"\"\"", "test_class": "HRManagementSystemTestGetEmployee", "test_code": "class HRManagementSystemTestGetEmployee(unittest.TestCase):\n def test_get_employee(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n\n def test_get_employee_2(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {}\n self.assertEqual(hr_system.get_employee(1), False)\n\n def test_get_employee_3(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.get_employee(2), False)\n\n def test_get_employee_4(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n self.assertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n\n def test_get_employee_5(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n self.assertEqual(hr_system.get_employee(2), {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})", "solution_code": "def get_employee(self, employee_id):\n if employee_id in self.employees:\n return self.employees[employee_id]\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.employees" ], "method_dependencies": [] } }, { "method_name": "list_employees", "method_description": "def list_employees(self):\n “”“\n List all employees' information in the HRManagementSystem.\n :return: A list of all employees' information,dict.\n >>> hrManagementSystem = HRManagementSystem()\n >>> hrManagementSystem.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n >>> hrManagementSystem.list_employees()\n {1: {'employee_ID': 1, 'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n\n \"\"\"", "test_class": "HRManagementSystemTestListEmployees", "test_code": "class HRManagementSystemTestListEmployees(unittest.TestCase):\n def test_list_employees(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_list_employees_2(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {}\n self.assertEqual(hr_system.list_employees(), {})\n\n def test_list_employees_3(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'employee_ID':2,'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_list_employees_4(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'employee_ID':2,'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_list_employees_5(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'employee_ID':2,'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n hr_system.employees = {}\n self.assertEqual(hr_system.list_employees(), {})", "solution_code": "def list_employees(self):\n employee_data = {}\n if self.employees:\n for employee_id, employee_info in self.employees.items():\n employee_details = {}\n employee_details[\"employee_ID\"] = employee_id\n for key, value in employee_info.items():\n employee_details[key] = value\n employee_data[employee_id] = employee_details\n return employee_data", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.employees" ], "method_dependencies": [] } } ]

[ "HRManagementSystemTestAddEmployee", "HRManagementSystemTestRemoveEmployee", "HRManagementSystemTestUpdateEmployee", "HRManagementSystemTestGetEmployee", "HRManagementSystemTestListEmployees", "HRManagementSystemTestMain" ]

[ "self.employees" ]

[ "import re", "import string", "import gensim", "from bs4 import BeautifulSoup" ]

[ { "method_name": "__format_line_feed", "method_description": "def __format_line_feed(text):\n \"\"\"\n Replace consecutive line breaks with a single line break\n :param text: string with consecutive line breaks\n :return:string, replaced text with single line break\n \"\"\"", "test_class": "HtmlUtilTestFormatLineFeed", "test_code": "class HtmlUtilTestFormatLineFeed(unittest.TestCase):\n def test_format_line_feed_1(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed('aaa\\n\\n\\n'), 'aaa\\n')\n\n def test_format_line_feed_2(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed('aaa\\n\\n\\n\\n'), 'aaa\\n')\n\n def test_format_line_feed_3(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed('aaa\\n\\n\\nbbb\\n\\n'), 'aaa\\nbbb\\n')\n\n def test_format_line_feed_4(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed('ccc\\n\\n\\n'), 'ccc\\n')\n\n def test_format_line_feed_5(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed(''), '')", "solution_code": "def __format_line_feed(text):\n return re.sub(re.compile(r'\\n+'), '\\n', text)", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "format_line_html_text", "method_description": "def format_line_html_text(self, html_text):\n \"\"\"\n get the html text without the code, and add the code tag -CODE- where the code is\n :param html_text:string\n :return:string\n >>>htmlutil = HtmlUtil()\n >>>htmlutil.format_line_html_text(<html>\n >>> <body>\n >>> <h1>Title</h1>\n >>> <p>This is a paragraph.</p>\n >>> <pre>print('Hello, world!')</pre>\n >>> <p>Another paragraph.</p>\n >>> <pre><code>for i in range(5):\n >>> print(i)</code></pre>\n >>> </body>\n >>> </html>)\n Title\n This is a paragraph.\n -CODE-\n Another paragraph.\n -CODE-\n \"\"\"", "test_class": "HtmlUtilTestFormatLineHtmlText", "test_code": "class HtmlUtilTestFormatLineHtmlText(unittest.TestCase):\n def test_format_line_html_text_1(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n <html>\n <body>\n <h1>Title</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(5):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, '''\nTitle\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n\n def test_format_line_html_text_2(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n <html>\n <body>\n <h1>Title2</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(5):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, '''\nTitle2\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n\n def test_format_line_html_text_3(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n <html>\n <body>\n <h1>Title3</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(5):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, '''\nTitle3\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n\n def test_format_line_html_text_4(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n <html>\n <body>\n <h1>Title4</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(5):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, '''\nTitle4\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n\n def test_format_line_html_text_5(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n <html>\n <body>\n <h1>Title5</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(5):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, '''\nTitle5\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n def test_format_line_html_text_6(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('')\n self.assertEqual(res, '')\n\n def test_format_line_html_text_7(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''<ul><li>Item 1!</li></ul>''')\n self.assertEqual(res, '''[-]Item 1!''')\n\n def test_format_line_html_text_8(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''<ul><li></li></ul>''')\n self.assertEqual(res, '')\n\n def test_format_line_html_text_9(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''<p>Some sentence here.</p>''')\n self.assertEqual(res, 'Some sentence here.')\n\n def test_format_line_html_text_10(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''<p>Some paragraph here</p><code>Code block</code>''')\n self.assertEqual(res, '''Some paragraph here.Code block''')\n\n def test_format_line_html_text_11(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''<p>Some paragraph here</p><div>Some text here</div>''')\n self.assertEqual(res, '''Some paragraph here.Some text here''')\n\n def test_format_line_html_text_12(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''<ul><li>Item 1</li></ul>''')\n self.assertEqual(res, '''[-]Item 1.''')", "solution_code": "def format_line_html_text(self, html_text):\n if html_text is None or len(html_text) == 0:\n return ''\n soup = BeautifulSoup(html_text, 'lxml')\n\n code_tag = soup.find_all(name=['pre', 'blockquote'])\n for tag in code_tag:\n tag.string = self.CODE_MARK\n\n ul_ol_group = soup.find_all(name=['ul', 'ol'])\n for ul_ol_item in ul_ol_group:\n li_group = ul_ol_item.find_all('li')\n for li_item in li_group:\n li_item_text = li_item.get_text().strip()\n if len(li_item_text) == 0:\n continue\n if li_item_text[-1] in string.punctuation:\n li_item.string = '[{0}]{1}'.format('-', li_item_text)\n continue\n li_item.string = '[{0}]{1}.'.format('-', li_item_text)\n\n p_group = soup.find_all(name=['p'])\n for p_item in p_group:\n p_item_text = p_item.get_text().strip()\n if p_item_text:\n if p_item_text[-1] in string.punctuation:\n p_item.string = p_item_text\n continue\n next_sibling = p_item.find_next_sibling()\n if next_sibling and self.CODE_MARK in next_sibling.get_text():\n p_item.string = p_item_text + ':'\n continue\n p_item.string = p_item_text + '.'\n\n clean_text = gensim.utils.decode_htmlentities(soup.get_text())\n return self.__format_line_feed(clean_text)", "dependencies": { "Standalone": false, "lib_dependencies": [ "string", "gensim", "BeautifulSoup" ], "field_dependencies": [ "self.CODE_MARK" ], "method_dependencies": [ "__format_line_feed" ] } }, { "method_name": "extract_code_from_html_text", "method_description": "def extract_code_from_html_text(self, html_text):\n \"\"\"\n extract codes from the html body\n :param html_text: string, html text\n :return: the list of code\n >>>htmlutil = HtmlUtil()\n >>>htmlutil.extract_code_from_html_text(<html>\n >>> <body>\n >>> <h1>Title</h1>\n >>> <p>This is a paragraph.</p>\n >>> <pre>print('Hello, world!')</pre>\n >>> <p>Another paragraph.</p>\n >>> <pre><code>for i in range(5):\n >>> print(i)</code></pre>\n >>> </body>\n >>> </html>)\n [\"print('Hello, world!')\", 'for i in range(5):\\n print(i)']\n \"\"\"", "test_class": "HtmlUtilTestExtractCodeFromHtmlText", "test_code": "class HtmlUtilTestExtractCodeFromHtmlText(unittest.TestCase):\n def test_extract_code_from_html_text_1(self):\n htmlutil = HtmlUtil()\n res = htmlutil.extract_code_from_html_text('''\n <html>\n <body>\n <h1>Title</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(5):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(5):\\n print(i)'])\n\n def test_extract_code_from_html_text_2(self):\n htmlutil = HtmlUtil()\n res = htmlutil.extract_code_from_html_text('''\n <html>\n <body>\n <h1>Title</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(4):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(4):\\n print(i)'])\n\n def test_extract_code_from_html_text_3(self):\n htmlutil = HtmlUtil()\n res = htmlutil.extract_code_from_html_text('''\n <html>\n <body>\n <h1>Title</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(3):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(3):\\n print(i)'])\n\n def test_extract_code_from_html_text_4(self):\n htmlutil = HtmlUtil()\n res = htmlutil.extract_code_from_html_text('''\n <html>\n <body>\n <h1>Title</h1>\n <p>This is a paragraph.</p>\n <pre>print('Hello, world!')</pre>\n <p>Another paragraph.</p>\n <pre><code>for i in range(2):\n print(i)</code></pre>\n </body>\n </html>\n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(2):\\n print(i)'])\n\n def test_extract_code_from_html_text_5(self):\n htmlutil = HtmlUtil()\n htmlutil.CODE_MARK = 'abcdefg'\n res = htmlutil.extract_code_from_html_text(\"\")\n self.assertEqual(res, [])", "solution_code": "def extract_code_from_html_text(self, html_text):\n text_with_code_tag = self.format_line_html_text(html_text)\n\n if self.CODE_MARK not in text_with_code_tag:\n return []\n\n code_index_start = 0\n soup = BeautifulSoup(html_text, 'lxml')\n code_tag = soup.find_all(name=['pre', 'blockquote'])\n code_count = text_with_code_tag.count(self.CODE_MARK)\n code_list = []\n for code_index in range(code_index_start, code_index_start + code_count):\n code = code_tag[code_index].get_text()\n if code:\n code_list.append(code)\n return code_list", "dependencies": { "Standalone": false, "lib_dependencies": [ "BeautifulSoup" ], "field_dependencies": [ "self.CODE_MARK" ], "method_dependencies": [ "format_line_html_text" ] } } ]

[ "HtmlUtilTestFormatLineFeed", "HtmlUtilTestFormatLineHtmlText", "HtmlUtilTestExtractCodeFromHtmlText", "HtmlUtilTest" ]

[ "self.CODE_MARK", "self.COMMAND_MARK", "self.COMMENT_MARK", "self.JSON_MARK", "self.MARKUP_LANGUAGE_MARK", "self.NUMBER_MARK", "self.SPACE_MARK", "self.TRACE_MARK", "self.URL_MARK" ]

[ "from PIL import Image, ImageEnhance, ImageChops" ]

[ { "method_name": "load_image", "method_description": "def load_image(self, image_path):\n \"\"\"\n Use Image util in PIL to open a image\n :param image_path: str, path of image that is to be\n >>> processor.load_image('test.jpg')\n >>> processor.image\n <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=3072x4096 at 0x194F2412A48>\n \"\"\"", "test_class": "ImageProcessorTestLoadImage", "test_code": "class ImageProcessorTestLoadImage(unittest.TestCase):\n def setUp(self):\n self.processor = ImageProcessor()\n self.image_path = os.path.join(os.path.dirname(__file__), \"test.png\")\n image = Image.new(\"RGB\", (100, 100), (255, 255, 255))\n image.save(self.image_path)\n\n def tearDown(self):\n self.processor.image.close()\n # if os.path.exists(self.image_path):\n # os.remove(self.image_path)\n\n def test_load_image(self):\n self.processor.load_image(self.image_path)\n self.assertIsNotNone(self.processor.image)\n\n def test_load_image_2(self):\n self.processor.load_image(self.image_path)\n self.assertEqual(self.processor.image.size, (100, 100))\n\n def test_load_image_3(self):\n self.processor.load_image(self.image_path)\n self.assertEqual(self.processor.image.mode, \"RGB\")\n\n def test_load_image_4(self):\n self.processor.load_image(self.image_path)\n self.assertEqual(self.processor.image.format, \"PNG\")\n\n def test_load_image_5(self):\n self.processor.load_image(self.image_path)\n self.assertEqual(self.processor.image.filename, self.image_path)", "solution_code": "def load_image(self, image_path):\n self.image = Image.open(image_path)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.image" ], "method_dependencies": [] } }, { "method_name": "save_image", "method_description": "def save_image(self, save_path):\n \"\"\"\n Save image to a path if image has opened\n :param save_path: str, the path that the image will be saved\n >>> processor.load_image('test.jpg')\n >>> processor.save_image('test2.jpg')\n \"\"\"", "test_class": "ImageProcessorTestSaveImage", "test_code": "class ImageProcessorTestSaveImage(unittest.TestCase):\n def setUp(self):\n self.processor = ImageProcessor()\n self.image_path = os.path.join(os.path.dirname(__file__), \"test.png\")\n image = Image.new(\"RGB\", (100, 100), (255, 255, 255))\n image.save(self.image_path)\n\n def tearDown(self):\n self.processor.image.close()\n\n def test_save_image(self):\n save_path = os.path.join(os.path.dirname(__file__), \"test_save.png\")\n self.processor.load_image(self.image_path)\n self.processor.save_image(save_path)\n saved_image = Image.open(save_path)\n self.assertIsNotNone(saved_image)\n\n def test_save_image_2(self):\n save_path = os.path.join(os.path.dirname(__file__), \"test_save.png\")\n self.processor.load_image(self.image_path)\n self.processor.save_image(save_path)\n saved_image = Image.open(save_path)\n self.assertEqual(saved_image.size, (100, 100))\n\n def test_save_image_3(self):\n save_path = os.path.join(os.path.dirname(__file__), \"test_save.png\")\n self.processor.load_image(self.image_path)\n self.processor.save_image(save_path)\n saved_image = Image.open(save_path)\n self.assertEqual(saved_image.mode, \"RGB\")\n\n def test_save_image_4(self):\n save_path = os.path.join(os.path.dirname(__file__), \"test_save.png\")\n self.processor.load_image(self.image_path)\n self.processor.save_image(save_path)\n saved_image = Image.open(save_path)\n self.assertEqual(saved_image.format, \"PNG\")\n\n def test_save_image_5(self):\n save_path = os.path.join(os.path.dirname(__file__), \"test_save.png\")\n self.processor.load_image(self.image_path)\n self.processor.save_image(save_path)\n saved_image = Image.open(save_path)\n self.assertEqual(saved_image.filename, save_path)", "solution_code": "def save_image(self, save_path):\n if self.image:\n self.image.save(save_path)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.image" ], "method_dependencies": [] } }, { "method_name": "resize_image", "method_description": "def resize_image(self, width, height):\n \"\"\"\n Risize the image if image has opened.\n :param width: int, the target width of image\n :param height: int, the target height of image\n >>> processor.load_image('test.jpg')\n >>> processor.resize_image(300, 300)\n >>> processor.image.width\n 300\n >>> processor.image.height\n 300\n \"\"\"", "test_class": "ImageProcessorTestResizeImage", "test_code": "class ImageProcessorTestResizeImage(unittest.TestCase):\n def setUp(self):\n self.processor = ImageProcessor()\n self.image_path = os.path.join(os.path.dirname(__file__), \"test.png\")\n image = Image.new(\"RGB\", (100, 100), (255, 255, 255))\n image.save(self.image_path)\n\n def tearDown(self):\n self.processor.image.close()\n\n def test_resize_image(self):\n self.processor.load_image(self.image_path)\n self.processor.resize_image(30, 15)\n self.assertEqual(self.processor.image.size, (30, 15))\n\n def test_resize_image_2(self):\n self.processor.load_image(self.image_path)\n self.processor.resize_image(30, 15)\n self.assertEqual(self.processor.image.mode, \"RGB\")\n\n def test_resize_image_3(self):\n self.processor.load_image(self.image_path)\n self.processor.resize_image(30, 15)\n self.assertEqual(self.processor.image.format, None)\n\n def test_resize_image_4(self):\n self.processor.load_image(self.image_path)\n self.processor.resize_image(40, 20)\n self.assertEqual(self.processor.image.mode, \"RGB\")\n\n def test_resize_image_5(self):\n self.processor.load_image(self.image_path)\n self.processor.resize_image(50, 25)\n self.assertEqual(self.processor.image.format, None)", "solution_code": "def resize_image(self, width, height):\n if self.image:\n self.image = self.image.resize((width, height))", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.image" ], "method_dependencies": [] } }, { "method_name": "rotate_image", "method_description": "def rotate_image(self, degrees):\n \"\"\"\n rotate image if image has opened\n :param degrees: float, the degrees that the image will be rotated\n >>> processor.load_image('test.jpg')\n >>> processor.resize_image(90)\n \"\"\"", "test_class": "ImageProcessorTestRotateImage", "test_code": "class ImageProcessorTestRotateImage(unittest.TestCase):\n def setUp(self):\n self.processor = ImageProcessor()\n self.image_path = os.path.join(os.path.dirname(__file__), \"test.png\")\n image = Image.new(\"RGB\", (100, 100), (255, 255, 255))\n image.save(self.image_path)\n\n def tearDown(self):\n self.processor.image.close()\n\n def test_rotate_image(self):\n self.processor.load_image(self.image_path)\n original_image = self.processor.image\n self.processor.rotate_image(90)\n self.assertTrue(ImageChops.difference(original_image.rotate(90), self.processor.image).getbbox() is None)\n\n def test_rotate_image_2(self):\n self.processor.load_image(self.image_path)\n original_image = self.processor.image\n self.processor.rotate_image(180)\n self.assertTrue(ImageChops.difference(original_image.rotate(180), self.processor.image).getbbox() is None)\n\n def test_rotate_image_3(self):\n self.processor.load_image(self.image_path)\n original_image = self.processor.image\n self.processor.rotate_image(270)\n self.assertTrue(ImageChops.difference(original_image.rotate(270), self.processor.image).getbbox() is None)\n\n def test_rotate_image_4(self):\n self.processor.load_image(self.image_path)\n original_image = self.processor.image\n self.processor.rotate_image(360)\n self.assertTrue(ImageChops.difference(original_image.rotate(360), self.processor.image).getbbox() is None)\n\n def test_rotate_image_5(self):\n self.processor.load_image(self.image_path)\n original_image = self.processor.image\n self.processor.rotate_image(45)\n self.assertTrue(ImageChops.difference(original_image.rotate(45), self.processor.image).getbbox() is None)", "solution_code": "def rotate_image(self, degrees):\n if self.image:\n self.image = self.image.rotate(degrees)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.image" ], "method_dependencies": [] } }, { "method_name": "adjust_brightness", "method_description": "def adjust_brightness(self, factor):\n \"\"\"\n Adjust the brightness of image if image has opened.\n :param factor: float, brightness of an image. A factor of 0.0 gives a black image. A factor of 1.0 gives the original image.\n >>> processor.load_image('test.jpg')\n >>> processor.adjust_brightness(0.5)\n \"\"\"", "test_class": "ImageProcessorTestAdjustBrightness", "test_code": "class ImageProcessorTestAdjustBrightness(unittest.TestCase):\n def setUp(self):\n self.processor = ImageProcessor()\n self.image_path = os.path.join(os.path.dirname(__file__), \"test.png\")\n image = Image.new(\"RGB\", (100, 100), (255, 255, 255))\n image.save(self.image_path)\n\n def tearDown(self):\n self.processor.image.close()\n\n def test_adjust_brightness(self):\n self.processor.load_image(self.image_path)\n enhancer = ImageEnhance.Brightness(Image.open(self.image_path))\n expected_image = enhancer.enhance(0.3)\n self.processor.adjust_brightness(0.3)\n self.assertTrue(ImageChops.difference(expected_image, self.processor.image).getbbox() is None)\n\n def test_adjust_brightness_2(self):\n self.processor.load_image(self.image_path)\n enhancer = ImageEnhance.Brightness(Image.open(self.image_path))\n expected_image = enhancer.enhance(0.5)\n self.processor.adjust_brightness(0.5)\n self.assertTrue(ImageChops.difference(expected_image, self.processor.image).getbbox() is None)\n\n def test_adjust_brightness_3(self):\n self.processor.load_image(self.image_path)\n enhancer = ImageEnhance.Brightness(Image.open(self.image_path))\n expected_image = enhancer.enhance(0.7)\n self.processor.adjust_brightness(0.7)\n self.assertTrue(ImageChops.difference(expected_image, self.processor.image).getbbox() is None)\n\n def test_adjust_brightness_4(self):\n self.processor.load_image(self.image_path)\n enhancer = ImageEnhance.Brightness(Image.open(self.image_path))\n expected_image = enhancer.enhance(1.0)\n self.processor.adjust_brightness(1.0)\n self.assertTrue(ImageChops.difference(expected_image, self.processor.image).getbbox() is None)\n\n def test_adjust_brightness_5(self):\n self.processor.load_image(self.image_path)\n enhancer = ImageEnhance.Brightness(Image.open(self.image_path))\n expected_image = enhancer.enhance(1.5)\n self.processor.adjust_brightness(1.5)\n self.assertTrue(ImageChops.difference(expected_image, self.processor.image).getbbox() is None)", "solution_code": "def adjust_brightness(self, factor):\n if self.image:\n enhancer = ImageEnhance.Brightness(self.image)\n self.image = enhancer.enhance(factor)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.image" ], "method_dependencies": [] } } ]

[ "ImageProcessorTestLoadImage", "ImageProcessorTestSaveImage", "ImageProcessorTestResizeImage", "ImageProcessorTestRotateImage", "ImageProcessorTestAdjustBrightness", "ImageProcessorTestMain" ]

[ "self.image" ]

[]

[ { "method_name": "interpolate_1d", "method_description": "def interpolate_1d(x, y, x_interp):\n \"\"\"\n Linear interpolation of one-dimensional data\n :param x: The x-coordinate of the data point, list.\n :param y: The y-coordinate of the data point, list.\n :param x_interp: The x-coordinate of the interpolation point, list.\n :return: The y-coordinate of the interpolation point, list.\n >>> interpolation = Interpolation()\n >>> interpolation.interpolate_1d([1, 2, 3], [1, 2, 3], [1.5, 2.5])\n [1.5, 2.5]\n\n \"\"\"", "test_class": "InterpolationTestInterpolate1d", "test_code": "class InterpolationTestInterpolate1d(unittest.TestCase):\n def test_interpolate_1d(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 2, 3], [1, 2, 3], [1.5, 2.5]), [1.5, 2.5])\n\n def test_interpolate_1d_2(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 2, 5], [1.5, 2.5]), [1.1, 1.3])\n\n def test_interpolate_1d_3(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 7, 5], [1.5, 2.5]), [1.6, 2.8])\n\n def test_interpolate_1d_4(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 2, 5], [2, 3]), [1.2, 1.4])\n\n def test_interpolate_1d_5(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 7, 5], [2, 3]), [2.2, 3.4])\n\n def test_interpolate_1d_6(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 7, 5], []), [])\n\n def test_interpolate_1d_7(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([], [], [[], []]), [])", "solution_code": "def interpolate_1d(x, y, x_interp):\n y_interp = []\n for xi in x_interp:\n for i in range(len(x) - 1):\n if x[i] <= xi <= x[i+1]:\n yi = y[i] + (y[i+1] - y[i]) * (xi - x[i]) / (x[i+1] - x[i])\n y_interp.append(yi)\n break\n return y_interp", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "interpolate_2d", "method_description": "@staticmethod\n def interpolate_2d(x, y, z, x_interp, y_interp):\n ”“”\n Linear interpolation of two-dimensional data\n :param x: The x-coordinate of the data point, list.\n :param y: The y-coordinate of the data point, list.\n :param z: The z-coordinate of the data point, list.\n :param x_interp: The x-coordinate of the interpolation point, list.\n :param y_interp: The y-coordinate of the interpolation point, list.\n :return: The z-coordinate of the interpolation point, list.\n >>> interpolation = Interpolation()\n >>> interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5], [1.5, 2.5])\n [3.0, 7.0]\n\n ”“”", "test_class": "InterpolationTestInterpolate2d", "test_code": "class InterpolationTestInterpolate2d(unittest.TestCase):\n def test_interpolate_2d(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5],\n [1.5, 2.5]), [3.0, 7.0])\n\n def test_interpolate_2d_2(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5], [3, 4]),\n [4.5])\n\n def test_interpolate_2d_3(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [3, 4], [1.5, 2.5]),\n [7.5])\n\n def test_interpolate_2d_4(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [3, 4], [3, 4]),\n [9.0])\n\n def test_interpolate_2d_5(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5],\n [1.5, 2.5]), [3.0, 7.0])", "solution_code": "@staticmethod\n def interpolate_2d(x, y, z, x_interp, y_interp):\n z_interp = []\n for xi, yi in zip(x_interp, y_interp):\n for i in range(len(x) - 1):\n if x[i] <= xi <= x[i+1]:\n for j in range(len(y) - 1):\n if y[j] <= yi <= y[j+1]:\n z00 = z[i][j]\n z01 = z[i][j+1]\n z10 = z[i+1][j]\n z11 = z[i+1][j+1]\n zi = (z00 * (x[i+1] - xi) * (y[j+1] - yi) +\n z10 * (xi - x[i]) * (y[j+1] - yi) +\n z01 * (x[i+1] - xi) * (yi - y[j]) +\n z11 * (xi - x[i]) * (yi - y[j])) / ((x[i+1] - x[i]) * (y[j+1] - y[j]))\n z_interp.append(zi)\n break\n break\n return z_interp", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "InterpolationTestInterpolate1d", "InterpolationTestInterpolate2d", "InterpolationTestMain" ]

[]

[]

[ { "method_name": "is_valid", "method_description": "def is_valid(self):\n \"\"\"\n Judge whether the IP address is valid, that is, whether the IP address is composed of four Decimal digits separated by '.'. Each digit is greater than or equal to 0 and less than or equal to 255\n :return: bool\n >>> ipaddress = IPAddress(\"10.10.10.10\")\n >>> ipaddress.is_valid()\n True\n \"\"\"", "test_class": "IPAddressTestIsValid", "test_code": "class IPAddressTestIsValid(unittest.TestCase):\n def test_is_valid_1(self):\n ipaddress = IPAddress(\"10.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), True)\n\n def test_is_valid_2(self):\n ipaddress = IPAddress(\"-1.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), False)\n\n def test_is_valid_3(self):\n ipaddress = IPAddress(\"10.10.10\")\n self.assertEqual(ipaddress.is_valid(), False)\n\n def test_is_valid_4(self):\n ipaddress = IPAddress(\"a.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), False)\n\n def test_is_valid_5(self):\n ipaddress = IPAddress(\"300.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), False)", "solution_code": "def is_valid(self):\n octets = self.ip_address.split('.')\n if len(octets) != 4:\n return False\n for octet in octets:\n if not octet.isdigit() or int(octet) < 0 or int(octet) > 255:\n return False\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.ip_address" ], "method_dependencies": [] } }, { "method_name": "get_octets", "method_description": "def get_octets(self):\n \"\"\"\n If the IP address is valid, the list of four decimal numbers separated by \".\" constituting the IP address is returned; otherwise, an empty list is returned\n :return: list\n >>> ipaddress = IPAddress(\"10.10.10.10\")\n >>> ipaddress.get_octets()\n [\"10\", \"10\", \"10\", \"10\"]\n \"\"\"", "test_class": "IPAddressTestGetOctets", "test_code": "class IPAddressTestGetOctets(unittest.TestCase):\n def test_get_octets_1(self):\n ipaddress = IPAddress(\"10.10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [\"10\", \"10\", \"10\", \"10\"])\n\n def test_get_octets_2(self):\n ipaddress = IPAddress(\"a.10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [])\n\n def test_get_octets_3(self):\n ipaddress = IPAddress(\"-1.10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [])\n\n def test_get_octets_4(self):\n ipaddress = IPAddress(\"300.10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [])\n\n def test_get_octets_5(self):\n ipaddress = IPAddress(\".10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [])", "solution_code": "def get_octets(self):\n if self.is_valid():\n return self.ip_address.split('.')\n else:\n return []", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.ip_address" ], "method_dependencies": [ "is_valid" ] } }, { "method_name": "get_binary", "method_description": "def get_binary(self):\n \"\"\"\n If the IP address is valid, return the binary form of the IP address; otherwise, return ''\n :return: string\n >>> ipaddress = IPAddress(\"10.10.10.10\")\n >>> ipaddress.get_binary()\n \"00001010.00001010.00001010.00001010\"\n \"\"\"", "test_class": "IPAddressTestGetBinary", "test_code": "class IPAddressTestGetBinary(unittest.TestCase):\n def test_get_binary_1(self):\n ipaddress = IPAddress(\"10.10.10.10\")\n self.assertEqual(ipaddress.get_binary(), \"00001010.00001010.00001010.00001010\")\n\n def test_get_binary_2(self):\n ipaddress = IPAddress(\"a.10.10.10\")\n self.assertEqual(ipaddress.get_binary(), '')\n\n def test_get_binary_3(self):\n ipaddress = IPAddress(\"-1.10.10.10\")\n self.assertEqual(ipaddress.get_binary(), '')\n\n def test_get_binary_4(self):\n ipaddress = IPAddress(\"300.10.10.10\")\n self.assertEqual(ipaddress.get_binary(), '')\n\n def test_get_binary_5(self):\n ipaddress = IPAddress(\".10.10.10\")\n self.assertEqual(ipaddress.get_binary(), '')", "solution_code": "def get_binary(self):\n if self.is_valid():\n binary_octets = []\n for octet in self.get_octets():\n binary_octets.append(format(int(octet), '08b'))\n return '.'.join(binary_octets)\n else:\n return ''", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "is_valid", "get_octets" ] } } ]

[ "IPAddressTestIsValid", "IPAddressTestGetOctets", "IPAddressTestGetBinary", "IPAddressTest" ]

[ "self.ip_address" ]

[ "import socket" ]

[ { "method_name": "is_valid_ipv4", "method_description": "def is_valid_ipv4(ip_address):\n \"\"\"\n Check if the given IP address is a valid IPv4 address.\n :param ip_address: string, the IP address to check\n :return: bool, True if the IP address is valid, False otherwise\n >>> IpUtil.is_valid_ipv4('192.168.0.123')\n True\n >>> IpUtil.is_valid_ipv4('256.0.0.0')\n False\n\n \"\"\"", "test_class": "IpUtilTestIsValidIpv4", "test_code": "class IpUtilTestIsValidIpv4(unittest.TestCase):\n def test_is_valid_ipv4_1(self):\n result = IpUtil.is_valid_ipv4('192.168.0.123')\n self.assertEqual(result, True)\n\n def test_is_valid_ipv4_2(self):\n result = IpUtil.is_valid_ipv4('10.10.10.10')\n self.assertEqual(result, True)\n\n def test_is_valid_ipv4_3(self):\n result = IpUtil.is_valid_ipv4('0.0.0.0')\n self.assertEqual(result, True)\n\n def test_is_valid_ipv4_4(self):\n result = IpUtil.is_valid_ipv4('abc.168.0.123')\n self.assertEqual(result, False)\n\n def test_is_valid_ipv4_5(self):\n result = IpUtil.is_valid_ipv4('256.0.0.0')\n self.assertEqual(result, False)", "solution_code": "def is_valid_ipv4(ip_address):\n try:\n socket.inet_pton(socket.AF_INET, ip_address)\n return True\n except socket.error:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "socket" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "is_valid_ipv6", "method_description": "@staticmethod\n def is_valid_ipv6(ip_address):\n \"\"\"\n Check if the given IP address is a valid IPv6 address.\n :param ip_address:string, the IP address to check\n :return:bool, True if the IP address is valid, False otherwise\n >>> IpUtil.is_valid_ipv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334')\n True\n >>> IpUtil.is_valid_ipv6('2001:0db8:85a3:::8a2e:0370:7334')\n False\n\n \"\"\"", "test_class": "IpUtilTestIsValidIpv6", "test_code": "class IpUtilTestIsValidIpv6(unittest.TestCase):\n def test_is_valid_ipv6_1(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334')\n self.assertEqual(result, True)\n\n def test_is_valid_ipv6_2(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:::8a2e:0370:7334')\n self.assertEqual(result, False)\n\n def test_is_valid_ipv6_3(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:2001:llll:8a2e:0370:7334')\n self.assertEqual(result, False)\n\n def test_is_valid_ipv6_4(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:llll:llll:8a2e:0370:7334')\n self.assertEqual(result, False)\n\n def test_is_valid_ipv6_5(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3::llll:8a2e:0370:7334')\n self.assertEqual(result, False)", "solution_code": "@staticmethod\n def is_valid_ipv6(ip_address):\n try:\n socket.inet_pton(socket.AF_INET6, ip_address)\n return True\n except socket.error:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "socket" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "get_hostname", "method_description": "@staticmethod\n def get_hostname(ip_address):\n \"\"\"\n Get the hostname associated with the given IP address.\n :param ip_address:string, the IP address to get the hostname for\n :return: string, the hostname associated with the IP address\n >>> IpUtil.get_hostname('110.242.68.3')\n 'www.baidu.com'\n >>> IpUtil.get_hostname('10.0.0.1')\n\n \"\"\"", "test_class": "IpUtilTestGetHostname", "test_code": "class IpUtilTestGetHostname(unittest.TestCase):\n def test_get_hostname_1(self):\n result = IpUtil.get_hostname('110.242.68.3')\n self.assertEqual(result, None)\n\n def test_get_hostname_2(self):\n result = IpUtil.get_hostname('10.0.0.1')\n self.assertEqual(result, None)\n\n def test_get_hostname_3(self):\n result = IpUtil.get_hostname('0.0.0.0')\n self.assertEqual(result, 'LAPTOP-2CS86KUM')\n\n def test_get_hostname_4(self):\n result = IpUtil.get_hostname('0.0.0.1')\n self.assertEqual(result, None)\n\n def test_get_hostname_5(self):\n result = IpUtil.get_hostname('0.0.0.2')\n self.assertEqual(result, None)", "solution_code": "@staticmethod\n def get_hostname(ip_address):\n try:\n hostname = socket.gethostbyaddr(ip_address)[0]\n return hostname\n except socket.herror:\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [ "socket" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "IpUtilTestIsValidIpv4", "IpUtilTestIsValidIpv6", "IpUtilTestGetHostname", "IpUtilTest" ]

[]

[]

[ { "method_name": "post_job", "method_description": "def post_job(self, job_title, company, requirements):\n \"\"\"\n This function is used to publish positions,and add the position information to the job_listings list.\n :param job_title: The title of the position,str.\n :param company: The company of the position,str.\n :param requirements: The requirements of the position,list.\n :return: None\n >>> jobMarketplace = JobMarketplace()\n >>> jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n >>> jobMarketplace.job_listings\n [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}]\n\n \"\"\"", "test_class": "JobMarketplaceTestPostJob", "test_code": "class JobMarketplaceTestPostJob(unittest.TestCase):\n def test_post_job(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])\n\n def test_post_job_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}])\n\n def test_post_job_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}])\n\n def test_post_job_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}, {'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])\n\n def test_post_job_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}, {'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}])", "solution_code": "def post_job(self, job_title, company, requirements):\n # requirements = ['requirement1', 'requirement2']\n job = {\"job_title\": job_title, \"company\": company, \"requirements\": requirements}\n self.job_listings.append(job)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.job_listings" ], "method_dependencies": [] } }, { "method_name": "remove_job", "method_description": "def remove_job(self, job):\n \"\"\"\n This function is used to remove positions,and remove the position information from the job_listings list.\n :param job: The position information to be removed,dict.\n :return: None\n >>> jobMarketplace = JobMarketplace()\n >>> jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}]\n >>> jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n >>> jobMarketplace.job_listings\n []\n\n \"\"\"", "test_class": "JobMarketplaceTestRemoveJob", "test_code": "class JobMarketplaceTestRemoveJob(unittest.TestCase):\n def test_remove_job(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [])\n\n def test_remove_job_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}, {\"job_title\": \"Mechanical Engineer\", \"company\": \"XYZ Company\", \"requirements\": ['requirement3', 'requirement4']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}])\n\n def test_remove_job_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}, {\"job_title\": \"Mechanical Engineer\", \"company\": \"XYZ Company\", \"requirements\": ['requirement3', 'requirement4']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [])\n\n def test_remove_job_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}, {\"job_title\": \"Mechanical Engineer\", \"company\": \"XYZ Company\", \"requirements\": ['requirement3', 'requirement4']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])\n\n def test_remove_job_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\",\n \"requirements\": ['requirement1', 'requirement2']},\n {\"job_title\": \"Mechanical Engineer\", \"company\": \"XYZ Company\",\n \"requirements\": ['requirement3', 'requirement4']},\n {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\",\n \"requirements\": ['requirement1', 'requirement2']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}, {'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])", "solution_code": "def remove_job(self, job):\n self.job_listings.remove(job)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.job_listings" ], "method_dependencies": [] } }, { "method_name": "submit_resume", "method_description": "def submit_resume(self, name, skills, experience):\n \"\"\"\n This function is used to submit resumes,and add the resume information to the resumes list.\n :param name: The name of the resume,str.\n :param skills: The skills of the resume,list.\n :param experience: The experience of the resume,str.\n :return: None\n >>> jobMarketplace = JobMarketplace()\n >>> jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n >>> jobMarketplace.resumes\n [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}]\n\n \"\"\"", "test_class": "JobMarketplaceTestSubmitResume", "test_code": "class JobMarketplaceTestSubmitResume(unittest.TestCase):\n def test_submit_resume(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n def test_submit_resume_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}])\n\n def test_submit_resume_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}, {'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n def test_submit_resume_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}, {'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}])\n\n def test_submit_resume_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}, {'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}, {'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])", "solution_code": "def submit_resume(self, name, skills, experience):\n resume = {\"name\": name, \"skills\": skills, \"experience\": experience}\n self.resumes.append(resume)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.resumes" ], "method_dependencies": [] } }, { "method_name": "withdraw_resume", "method_description": "def withdraw_resume(self, resume):\n \"\"\"\n This function is used to withdraw resumes,and remove the resume information from the resumes list.\n :param resume: The resume information to be removed,dict.\n :return: None\n >>> jobMarketplace = JobMarketplace()\n >>> jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\n >>> jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n >>> jobMarketplace.resumes\n []\n\n \"\"\"", "test_class": "JobMarketplaceTestWithdrawResume", "test_code": "class JobMarketplaceTestWithdrawResume(unittest.TestCase):\n def test_withdraw_resume(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [])\n\n def test_withdraw_resume_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [{'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}])\n\n def test_withdraw_resume_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [])\n \n def test_withdraw_resume_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Amy\", \"skills\": ['skill3', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [])\n\n def test_withdraw_resume_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Amy\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [{'experience': 'experience', 'name': 'John', 'skills': ['skill3', 'skill4']}])", "solution_code": "def withdraw_resume(self, resume):\n self.resumes.remove(resume)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.resumes" ], "method_dependencies": [] } }, { "method_name": "search_jobs", "method_description": "def search_jobs(self, criteria):\n \"\"\"\n This function is used to search for positions,and return the position information that meets the requirements.\n :param criteria: The requirements of the position,str.\n :return: The position information that meets the requirements,list.\n >>> jobMarketplace = JobMarketplace()\n >>> jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\n >>> jobMarketplace.search_jobs(\"skill1\")\n [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}]\n\n \"\"\"", "test_class": "JobMarketplaceTestSearchJobs", "test_code": "class JobMarketplaceTestSearchJobs(unittest.TestCase):\n def test_search_jobs(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill1\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\n\n def test_search_jobs_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill1\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\n\n def test_search_jobs_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill3\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill3', 'skill4']}])\n\n def test_search_jobs_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill5\"), [])\n\n def test_search_jobs_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill6\"), [])", "solution_code": "def search_jobs(self, criteria):\n matching_jobs = []\n for job_listing in self.job_listings:\n if criteria.lower() in job_listing[\"job_title\"].lower() or criteria.lower() in [r.lower() for r in job_listing[\"requirements\"]]:\n matching_jobs.append(job_listing)\n return matching_jobs", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.job_listings" ], "method_dependencies": [] } }, { "method_name": "get_job_applicants", "method_description": "def get_job_applicants(self, job):\n \"\"\"\n This function is used to obtain candidate information,and return the candidate information that meets the requirements by calling the matches_requirements function.\n :param job: The position information,dict.\n :return: The candidate information that meets the requirements,list.\n >>> jobMarketplace = JobMarketplace()\n >>> jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\n >>> jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\n >>> jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0])\n [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}]\n\n \"\"\"", "test_class": "JobMarketplaceTestGetJobApplicants", "test_code": "class JobMarketplaceTestGetJobApplicants(unittest.TestCase):\n def test_get_job_applicants(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n def test_get_job_applicants_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n def test_get_job_applicants_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}])\n\n def test_get_job_applicants_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill5', 'skill6']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [])\n\n def test_get_job_applicants_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill6', 'skill7']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [])", "solution_code": "def get_job_applicants(self, job):\n applicants = []\n for resume in self.resumes:\n if self.matches_requirements(resume, job[\"requirements\"]):\n applicants.append(resume)\n return applicants", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.resumes" ], "method_dependencies": [] } } ]

[ "JobMarketplaceTestPostJob", "JobMarketplaceTestRemoveJob", "JobMarketplaceTestSubmitResume", "JobMarketplaceTestWithdrawResume", "JobMarketplaceTestSearchJobs", "JobMarketplaceTestGetJobApplicants", "JobMarketplaceTestMatchesRequirements", "JobMarketplaceTestMain" ]

[ "self.job_listings", "self.resumes" ]

[ "import json", "import os" ]

[ { "method_name": "read_json", "method_description": "def read_json(self, file_path):\n \"\"\"\n Read a JSON file and return the data.\n :param file_path: str, the path of the JSON file.\n :return: dict, the data from the JSON file if read successfully, or return -1 if an error occurs during the reading process.\n return 0 if the file does not exist.\n >>> json.read_json('test.json')\n {'name': 'test', 'age': 14}\n \"\"\"", "test_class": "JSONProcessorTestReadJson", "test_code": "class JSONProcessorTestReadJson(unittest.TestCase):\n def setUp(self):\n self.processor = JSONProcessor()\n self.test_data = {\n \"key1\": \"value1\",\n \"key2\": \"value2\",\n \"key3\": \"value3\"\n }\n self.file_path = \"test.json\"\n\n def tearDown(self):\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n # file exists\n def test_read_json_1(self):\n with open(self.file_path, 'w') as file:\n json.dump(self.test_data, file)\n result = self.processor.read_json(self.file_path)\n self.assertEqual(result, self.test_data)\n\n # file not exists\n def test_read_json_2(self):\n result = self.processor.read_json(self.file_path)\n self.assertEqual(result, 0)\n\n # invalid json file\n def test_read_json_3(self):\n with open(self.file_path, 'w') as file:\n file.write(\"Invalid JSON\")\n result = self.processor.read_json(self.file_path)\n self.assertEqual(result, -1)\n\n def test_read_json_4(self):\n result = self.processor.read_json('wrong')\n self.assertEqual(result, 0)\n\n def test_read_json_5(self):\n result = self.processor.read_json('abcd')\n self.assertEqual(result, 0)", "solution_code": "def read_json(self, file_path):\n if not os.path.exists(file_path):\n return 0\n try:\n with open(file_path, 'r') as file:\n data = json.load(file)\n return data\n except:\n return -1", "dependencies": { "Standalone": false, "lib_dependencies": [ "json", "os" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "write_json", "method_description": "def write_json(self, data, file_path):\n \"\"\"\n Write data to a JSON file and save it to the given path.\n\n :param data: dict, the data to be written to the JSON file.\n :param file_path: str, the path of the JSON file.\n :return: 1 if the writing process is successful, or -1, if an error occurs during the writing process.\n >>> json.write_json({'key1': 'value1', 'key2': 'value2'}, 'test.json')\n 1\n >>> json.read_json('test.json')\n {'key1': 'value1', 'key2': 'value2'}\n \"\"\"", "test_class": "JSONProcessorTestWriteJson", "test_code": "class JSONProcessorTestWriteJson(unittest.TestCase):\n def setUp(self):\n self.processor = JSONProcessor()\n self.test_data = {\n \"key1\": \"value1\",\n \"key2\": \"value2\",\n \"key3\": \"value3\"\n }\n self.file_path = \"test.json\"\n\n # create a read only file\n self.file_path_only_read = 'test_only_read.json'\n with open(self.file_path_only_read, 'w') as f:\n f.write('{\"key1\": \"value1\"}')\n\n # set file only read mode\n os.chmod(self.file_path_only_read, stat.S_IRUSR + stat.S_IRGRP + stat.S_IROTH)\n\n def tearDown(self):\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n if os.path.exists(self.file_path_only_read):\n # unset file only read mode and remove the file\n os.chmod(self.file_path_only_read,\n stat.S_IWUSR + stat.S_IRUSR + stat.S_IWGRP + stat.S_IRGRP + stat.S_IWOTH + stat.S_IROTH)\n os.remove(self.file_path_only_read)\n\n def test_write_json_1(self):\n result = self.processor.write_json(self.test_data, self.file_path)\n self.assertEqual(result, 1)\n with open(self.file_path, 'r') as file:\n written_data = json.load(file)\n self.assertEqual(written_data, self.test_data)\n\n def test_write_json_2(self):\n # Provide a read-only file path to simulate an exception\n result = self.processor.write_json(self.test_data, self.file_path_only_read)\n self.assertEqual(result, -1)\n\n def test_write_json_3(self):\n result = self.processor.write_json([], self.file_path_only_read)\n self.assertEqual(result, -1)\n\n def test_write_json_4(self):\n result = self.processor.write_json(self.test_data, '')\n self.assertEqual(result, -1)\n\n def test_write_json_5(self):\n result = self.processor.write_json([], '')\n self.assertEqual(result, -1)", "solution_code": "def write_json(self, data, file_path):\n try:\n with open(file_path, 'w') as file:\n json.dump(data, file)\n return 1\n except:\n return -1", "dependencies": { "Standalone": false, "lib_dependencies": [ "json" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "process_json", "method_description": "def process_json(self, file_path, remove_key):\n \"\"\"\n read a JSON file and process the data by removing a specified key and rewrite the modified data back to the file.\n\n :param file_path: str, the path of the JSON file.\n :param remove_key: str, the key to be removed.\n :return: 1, if the specified key is successfully removed and the data is written back.\n 0, if the file does not exist or the specified key does not exist in the data.\n >>> json.read_json('test.json')\n {'key1': 'value1', 'key2': 'value2'}\n >>> json.process_json('test.json', 'key1')\n 1\n >>> json.read_json('test.json')\n {'key2': 'value2'}\n \"\"\"", "test_class": "JSONProcessorTestProcessJsonExistingKey", "test_code": "class JSONProcessorTestProcessJsonExistingKey(unittest.TestCase):\n def setUp(self):\n self.processor = JSONProcessor()\n self.test_data = {\n \"key1\": \"value1\",\n \"key2\": \"value2\",\n \"key3\": \"value3\"\n }\n self.file_path = \"test.json\"\n\n def tearDown(self):\n if os.path.exists(self.file_path):\n os.remove(self.file_path)\n\n # key exists\n def test_process_json_1(self):\n with open(self.file_path, 'w') as file:\n json.dump(self.test_data, file)\n remove_key = \"key2\"\n self.processor.process_json(self.file_path, remove_key)\n with open(self.file_path, 'r') as file:\n processed_data = json.load(file)\n expected_data = {\n \"key1\": \"value1\",\n \"key3\": \"value3\"\n }\n self.assertEqual(processed_data, expected_data)\n\n # key not exists\n def test_process_json_2(self):\n with open(self.file_path, 'w') as file:\n json.dump(self.test_data, file)\n remove_key = \"nonexistent_key\"\n self.processor.process_json(self.file_path, remove_key)\n with open(self.file_path, 'r') as file:\n processed_data = json.load(file)\n self.assertEqual(processed_data, self.test_data)\n\n # file is empty\n def test_process_json_3(self):\n # Create an empty JSON file\n with open(self.file_path, 'w') as file:\n pass\n remove_key = \"key1\"\n self.assertEqual(self.processor.process_json(self.file_path, remove_key), 0)\n\n def test_process_json_4(self):\n with open(self.file_path, 'w') as file:\n json.dump(self.test_data, file)\n remove_key = \"aaa\"\n self.processor.process_json(self.file_path, remove_key)\n with open(self.file_path, 'r') as file:\n processed_data = json.load(file)\n self.assertEqual(processed_data, self.test_data)\n\n def test_process_json_5(self):\n with open(self.file_path, 'w') as file:\n json.dump(self.test_data, file)\n remove_key = \"bbb\"\n self.processor.process_json(self.file_path, remove_key)\n with open(self.file_path, 'r') as file:\n processed_data = json.load(file)\n self.assertEqual(processed_data, self.test_data)", "solution_code": "def process_json(self, file_path, remove_key):\n data = self.read_json(file_path)\n if data == 0 or data == -1:\n return 0\n if remove_key in data:\n del data[remove_key]\n self.write_json(data, file_path)\n return 1\n else:\n return 0", "dependencies": { "Standalone": false, "lib_dependencies": [ "json" ], "field_dependencies": [], "method_dependencies": [ "read_json", "write_json" ] } } ]

[ "JSONProcessorTestReadJson", "JSONProcessorTestWriteJson", "JSONProcessorTestProcessJsonExistingKey", "JSONProcessorTestMain" ]

[]

[ "import numpy as np" ]

[ { "method_name": "kappa", "method_description": "def kappa(testData, k):\n \"\"\"\n Calculate the cohens kappa value of a k-dimensional matrix\n :param testData: The k-dimensional matrix that needs to calculate the cohens kappa value\n :param k: int, Matrix dimension\n :return:float, the cohens kappa value of the matrix\n >>> KappaCalculator.kappa([[2, 1, 1], [1, 2, 1], [1, 1, 2]], 3)\n 0.25\n \"\"\"", "test_class": "KappaCalculatorTestKappa", "test_code": "class KappaCalculatorTestKappa(unittest.TestCase):\n def test_kappa_1(self):\n self.assertEqual(KappaCalculator.kappa([[2, 1, 1], [1, 2, 1], [1, 1, 2]], 3), 0.25)\n\n def test_kappa_2(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 2, 1], [1, 2, 1], [1, 1, 2]], 3), 0.19469026548672572)\n\n def test_kappa_3(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 1, 2], [1, 2, 1], [1, 1, 2]], 3), 0.19469026548672572)\n\n def test_kappa_4(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 1, 1], [2, 2, 1], [1, 1, 2]], 3), 0.19469026548672572)\n\n def test_kappa_5(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 1, 1], [1, 2, 2], [1, 1, 2]], 3), 0.19469026548672572)", "solution_code": "def kappa(testData, k):\n dataMat = np.mat(testData)\n P0 = 0.0\n for i in range(k):\n P0 += dataMat[i, i] * 1.0\n xsum = np.sum(dataMat, axis=1)\n ysum = np.sum(dataMat, axis=0)\n sum = np.sum(dataMat)\n Pe = float(ysum * xsum) / sum / sum\n P0 = float(P0 / sum * 1.0)\n cohens_coefficient = float((P0 - Pe) / (1 - Pe))\n return cohens_coefficient", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "fleiss_kappa", "method_description": "@staticmethod\n def fleiss_kappa(testData, N, k, n):\n \"\"\"\n Calculate the fliss kappa value of an N * k matrix\n :param testData: Input data matrix, N * k\n :param N: int, Number of samples\n :param k: int, Number of categories\n :param n: int, Number of raters\n :return: float, fleiss kappa value\n >>> KappaCalculator.fleiss_kappa([[0, 0, 0, 0, 14],\n >>> [0, 2, 6, 4, 2],\n >>> [0, 0, 3, 5, 6],\n >>> [0, 3, 9, 2, 0],\n >>> [2, 2, 8, 1, 1],\n >>> [7, 7, 0, 0, 0],\n >>> [3, 2, 6, 3, 0],\n >>> [2, 5, 3, 2, 2],\n >>> [6, 5, 2, 1, 0],\n >>> [0, 2, 2, 3, 7]], 10, 5, 14)\n 0.20993070442195522\n \"\"\"", "test_class": "KappaCalculatorTestFleissKappa", "test_code": "class KappaCalculatorTestFleissKappa(unittest.TestCase):\n def test_fleiss_kappa_1(self):\n self.assertEqual(KappaCalculator.fleiss_kappa([[0, 0, 0, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.20993070442195522)\n\n def test_fleiss_kappa_2(self):\n self.assertEqual(KappaCalculator.fleiss_kappa([[1, 0, 0, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.2115748928799344)\n\n def test_fleiss_kappa_3(self):\n self.assertEqual(KappaCalculator.fleiss_kappa([[0, 1, 0, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.21076904123090398)\n\n def test_fleiss_kappa_4(self):\n self.assertEqual(KappaCalculator.fleiss_kappa([[0, 0, 1, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.2096583016522883)\n\n def test_fleiss_kappa_5(self):\n self.assertEqual(KappaCalculator.fleiss_kappa([[0, 0, 0, 1, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.21147425143148907)", "solution_code": "@staticmethod\n def fleiss_kappa(testData, N, k, n):\n dataMat = np.mat(testData, float)\n oneMat = np.ones((k, 1))\n sum = 0.0\n P0 = 0.0\n for i in range(N):\n temp = 0.0\n for j in range(k):\n sum += dataMat[i, j]\n temp += 1.0 * dataMat[i, j] ** 2\n temp -= n\n temp /= (n - 1) * n\n P0 += temp\n P0 = 1.0 * P0 / N\n ysum = np.sum(dataMat, axis=0)\n for i in range(k):\n ysum[0, i] = (ysum[0, i] / sum) ** 2\n Pe = ysum * oneMat * 1.0\n ans = (P0 - Pe) / (1 - Pe)\n return ans[0, 0]", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "KappaCalculatorTestKappa", "KappaCalculatorTestFleissKappa", "KappaCalculatorTest" ]

[]

[ "import nltk", "from nltk.stem import WordNetLemmatizer", "from nltk import pos_tag, word_tokenize", "import string" ]

[ { "method_name": "lemmatize_sentence", "method_description": "def lemmatize_sentence(self, sentence):\n \"\"\"\n Remove punctuations of the sentence and tokenizes the input sentence, mark the part of speech tag of each word,\n lemmatizes the words with different parameters based on their parts of speech, and stores in a list.\n :param sentence: a sentence str\n :return: a list of words which have been lemmatized.\n >>> lemmatization = Lemmatization()\n >>> lemmatization.lemmatize_sentence(\"I am running in a race.\")\n ['I', 'be', 'run', 'in', 'a', 'race']\n\n \"\"\"", "test_class": "LemmatizationTestLemmatizeSentence", "test_code": "class LemmatizationTestLemmatizeSentence(unittest.TestCase):\n def test_lemmatize_sentence_1(self):\n lemmatization = Lemmatization()\n result = lemmatization.lemmatize_sentence(\"I am running in a race.\")\n expected = ['I', 'be', 'run', 'in', 'a', 'race']\n self.assertEqual(result, expected)\n\n def test_lemmatize_sentence_2(self):\n lemmatization = Lemmatization()\n result = lemmatization.lemmatize_sentence(\"Until the beating, Cantanco's eyesight had been weak, but adequate.\")\n expected = ['Until', 'the', 'beating', 'Cantancos', 'eyesight', 'have', 'be', 'weak', 'but', 'adequate']\n self.assertEqual(result, expected)\n\n def test_lammatize_sentence_3(self):\n lemmatization = Lemmatization()\n result = lemmatization.lemmatize_sentence(\"The dog's barked at the mailman.\")\n expected = ['The', 'dog', 'bark', 'at', 'the', 'mailman']\n self.assertEqual(result, expected)\n\n def test_lemmatize_sentence_4(self):\n lemmatization = Lemmatization()\n result = lemmatization.lemmatize_sentence(\"He was running and eating at same time. \")\n expected = ['He', 'be', 'run', 'and', 'eat', 'at', 'same', 'time']\n self.assertEqual(result, expected)\n\n def test_lemmatize_sentence_5(self):\n lemmatization = Lemmatization()\n result = lemmatization.lemmatize_sentence(\"I was taking a ride in the car.\")\n expected = ['I', 'be', 'take', 'a', 'ride', 'in', 'the', 'car']\n self.assertEqual(result, expected)", "solution_code": "def lemmatize_sentence(self, sentence):\n lemmatized_words = []\n sentence = self.remove_punctuation(sentence)\n words = word_tokenize(sentence)\n tagged_words = pos_tag(words)\n for word, tag in tagged_words:\n if tag.startswith('V'):\n lemmatized_word = self.lemmatizer.lemmatize(word, pos='v')\n elif tag.startswith('J'):\n lemmatized_word = self.lemmatizer.lemmatize(word, pos='a')\n elif tag.startswith('R'):\n lemmatized_word = self.lemmatizer.lemmatize(word, pos='r')\n else:\n lemmatized_word = self.lemmatizer.lemmatize(word)\n lemmatized_words.append(lemmatized_word)\n return lemmatized_words", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.lemmatizer" ], "method_dependencies": [ "remove_punctuation" ] } }, { "method_name": "get_pos_tag", "method_description": "def get_pos_tag(self, sentence):\n \"\"\"\n Remove punctuations of the sentence and tokenizes the input sentence, mark the part of speech tag of each word.\n :param sentence: a sentence str\n :return: list, part of speech tag of each word in the sentence.\n >>> lemmatization = Lemmatization()\n >>> lemmatization.get_pos_tag(\"I am running in a race.\")\n ['PRP', 'VBP', 'VBG', 'IN', 'DT', 'NN']\n\n \"\"\"", "test_class": "LemmatizationTestGetPosTag", "test_code": "class LemmatizationTestGetPosTag(unittest.TestCase):\n def test_get_pos_tag_1(self):\n lemmatization = Lemmatization()\n result = lemmatization.get_pos_tag(\"I am running in a race.\")\n expected = ['PRP', 'VBP', 'VBG', 'IN', 'DT', 'NN']\n self.assertEqual(result, expected)\n\n def test_get_pos_tag_2(self):\n lemmatization = Lemmatization()\n result = lemmatization.get_pos_tag(\"Cantanco's eyesight had been weak, but adequate.\")\n expected = ['NNP', 'NN', 'VBD', 'VBN', 'JJ', 'CC', 'JJ']\n self.assertEqual(result, expected)\n\n def test_get_pos_tag_3(self):\n lemmatization = Lemmatization()\n result = lemmatization.get_pos_tag(\"The dog's barked at the mailman.\")\n expected = ['DT', 'NNS', 'VBD', 'IN', 'DT', 'NN']\n self.assertEqual(result, expected)\n\n def test_get_pos_tag_4(self):\n lemmatization = Lemmatization()\n result = lemmatization.get_pos_tag(\"He was running and eating at same time. \")\n expected = ['PRP', 'VBD', 'VBG', 'CC', 'VBG', 'IN', 'JJ', 'NN']\n self.assertEqual(result, expected)\n\n def test_get_pos_tag_5(self):\n lemmatization = Lemmatization()\n result = lemmatization.get_pos_tag(\"I was taking a ride in the car.\")\n expected = ['PRP', 'VBD', 'VBG', 'DT', 'NN', 'IN', 'DT', 'NN']\n self.assertEqual(result, expected)", "solution_code": "def get_pos_tag(self, sentence):\n pos_tags = []\n sentence = self.remove_punctuation(sentence)\n words = word_tokenize(sentence)\n tagged_words = pos_tag(words)\n for tagged_word in tagged_words:\n pos_tags.append(tagged_word[1])\n return pos_tags", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "remove_punctuation" ] } }, { "method_name": "remove_punctuation", "method_description": "def remove_punctuation(self, sentence):\n \"\"\"\n Removes punctuation from the input text.\n :param sentence: a sentence str\n :return: str, sentence without any punctuation\n >>> lemmatization = Lemmatization()\n >>> lemmatization.remove_punctuation(\"I am running in a race.\")\n 'I am running in a race'\n\n \"\"\"", "test_class": "LemmatizationTestRemovePunctuation", "test_code": "class LemmatizationTestRemovePunctuation(unittest.TestCase):\n def test_remove_punctuation_1(self):\n lemmatization = Lemmatization()\n result = lemmatization.remove_punctuation(\"I am running in a race.\")\n expected = \"I am running in a race\"\n self.assertEqual(result, expected)\n\n def test_remove_punctuation_2(self):\n lemmatization = Lemmatization()\n result = lemmatization.remove_punctuation(\"Until the beating, Cantanco's eyesight had been weak, but adequate.\")\n expected = 'Until the beating Cantancos eyesight had been weak but adequate'\n self.assertEqual(result, expected)\n\n def test_remove_punctuation_3(self):\n lemmatization = Lemmatization()\n result = lemmatization.remove_punctuation(\"The dog's barked at the mailman!!!\")\n expected = 'The dogs barked at the mailman'\n self.assertEqual(result, expected)\n\n def test_remove_punctuation_4(self):\n lemmatization = Lemmatization()\n result = lemmatization.remove_punctuation(\"He was running and eating at same time... \")\n expected = 'He was running and eating at same time '\n self.assertEqual(result, expected)\n\n def test_remove_punctuation_5(self):\n lemmatization = Lemmatization()\n result = lemmatization.remove_punctuation(\"Is this a test? I hope it is...\")\n expected = 'Is this a test I hope it is'\n self.assertEqual(result, expected)", "solution_code": "def remove_punctuation(self, sentence):\n return sentence.translate(str.maketrans('', '', string.punctuation))", "dependencies": { "Standalone": false, "lib_dependencies": [ "string" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "LemmatizationTestLemmatizeSentence", "LemmatizationTestGetPosTag", "LemmatizationTestRemovePunctuation", "LemmatizationTestMain" ]

[ "self.lemmatizer" ]

[ "import re", "import string" ]

[ { "method_name": "add_word", "method_description": "def add_word(self, word):\n \"\"\"\n append the input word into self.word_list\n :param word: str, input word\n \"\"\"", "test_class": "LongestWordTestAddWord", "test_code": "class LongestWordTestAddWord(unittest.TestCase):\n def test_add_word_1(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n self.assertEqual(['hello'], longestWord.word_list)\n\n def test_add_word_2(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n longestWord.add_word(\"world\")\n self.assertEqual(['hello', 'world'], longestWord.word_list)\n\n def test_add_word_3(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n longestWord.add_word(\"world\")\n longestWord.add_word(\"!\")\n self.assertEqual(['hello', 'world', '!'], longestWord.word_list)\n\n def test_add_word_4(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n longestWord.add_word(\"world\")\n longestWord.add_word(\"!\")\n longestWord.add_word(\"!\")\n self.assertEqual(['hello', 'world', '!', '!'], longestWord.word_list)\n\n def test_add_word_5(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n longestWord.add_word(\"world\")\n longestWord.add_word(\"!\")\n longestWord.add_word(\"!\")\n longestWord.add_word(\"!\")\n self.assertEqual(['hello', 'world', '!', '!', '!'], longestWord.word_list)", "solution_code": "def add_word(self, word):\n self.word_list.append(word)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.word_list" ], "method_dependencies": [] } }, { "method_name": "find_longest_word", "method_description": "def find_longest_word(self, sentence):\n \"\"\"\n Remove punctuation marks and split a sentence into a list of word. Find the longest splited word that is in the self.word_list.\n Words are strictly case sensitive.\n :param sentence: a sentence str\n :return str: longest splited word that is in the self.word_list. return '' if self.word_list is empty.\n >>> longestWord = LongestWord()\n >>> longestWord.add_word('A')\n >>> longestWord.add_word('aM')\n >>> longestWord.find_longest_word('I am a student.')\n 'a'\n \"\"\"", "test_class": "LongestWordTestFindLongestWord", "test_code": "class LongestWordTestFindLongestWord(unittest.TestCase):\n def test_find_longest_word_1(self):\n longestWord = LongestWord()\n longestWord.add_word(\"a\")\n sentence = 'I am a student.'\n self.assertEqual('a', longestWord.find_longest_word(sentence))\n\n def test_find_longest_word_2(self):\n longestWord = LongestWord()\n sentence = 'I am a student.'\n self.assertEqual('', longestWord.find_longest_word(sentence))\n\n def test_find_longest_word_3(self):\n longestWord = LongestWord()\n longestWord.add_word(\"student\")\n sentence = 'I am a student.'\n self.assertEqual('student', longestWord.find_longest_word(sentence))\n\n def test_find_longest_word_4(self):\n longestWord = LongestWord()\n longestWord.add_word(\"apple\")\n sentence = 'Apple is red.'\n self.assertEqual('apple', longestWord.find_longest_word(sentence))\n\n def test_find_longest_word_5(self):\n longestWord = LongestWord()\n longestWord.add_word(\"apple\")\n longestWord.add_word(\"red\")\n sentence = 'Apple is red.'\n self.assertEqual('apple', longestWord.find_longest_word(sentence))", "solution_code": "def find_longest_word(self, sentence):\n longest_word = \"\"\n sentence = sentence.lower()\n sentence = re.sub('[%s]' % re.escape(string.punctuation), '', sentence)\n sentence = re.split(' ', sentence)\n for word in sentence:\n if word in self.word_list and len(word) > len(longest_word):\n longest_word = word\n return longest_word", "dependencies": { "Standalone": false, "lib_dependencies": [ "re", "string" ], "field_dependencies": [ "self.word_list" ], "method_dependencies": [] } } ]

[ "LongestWordTestAddWord", "LongestWordTestFindLongestWord" ]

[ "self.word_list" ]

[ "import random" ]

[ { "method_name": "create_board", "method_description": "def create_board(self):\n \"\"\"\n create the game board with the given board size and icons\n :return: 2-dimensional list, the game board\n >>> mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n >>> mc.create_board()\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n \"\"\"", "test_class": "MahjongConnectTestCreateBoard", "test_code": "class MahjongConnectTestCreateBoard(unittest.TestCase):\n def test_create_board_1(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n self.assertEqual(mc.BOARD_SIZE, [4, 4])\n self.assertEqual(mc.ICONS, ['a', 'b', 'c'])\n for row in mc.board:\n for icon in row:\n self.assertIn(icon, mc.ICONS)\n\n def test_create_board_2(self):\n mc = MahjongConnect([2, 2], ['a', 'b', 'c'])\n self.assertEqual(mc.BOARD_SIZE, [2, 2])\n self.assertEqual(mc.ICONS, ['a', 'b', 'c'])\n for row in mc.board:\n for icon in row:\n self.assertIn(icon, mc.ICONS)\n\n def test_create_board_3(self):\n mc = MahjongConnect([3, 3], ['a', 'b', 'c'])\n self.assertEqual(mc.BOARD_SIZE, [3, 3])\n self.assertEqual(mc.ICONS, ['a', 'b', 'c'])\n for row in mc.board:\n for icon in row:\n self.assertIn(icon, mc.ICONS)\n\n def test_create_board_4(self):\n mc = MahjongConnect([1, 1], ['a', 'b', 'c'])\n self.assertEqual(mc.BOARD_SIZE, [1, 1])\n self.assertEqual(mc.ICONS, ['a', 'b', 'c'])\n for row in mc.board:\n for icon in row:\n self.assertIn(icon, mc.ICONS)\n\n def test_create_board_5(self):\n mc = MahjongConnect([5, 5], ['a', 'b', 'c'])\n self.assertEqual(mc.BOARD_SIZE, [5, 5])\n self.assertEqual(mc.ICONS, ['a', 'b', 'c'])\n for row in mc.board:\n for icon in row:\n self.assertIn(icon, mc.ICONS)", "solution_code": "def create_board(self):\n board = [[random.choice(self.ICONS) for _ in range(self.BOARD_SIZE[1])] for _ in range(self.BOARD_SIZE[0])]\n return board", "dependencies": { "Standalone": false, "lib_dependencies": [ "random" ], "field_dependencies": [ "self.BOARD_SIZE", "self.ICONS" ], "method_dependencies": [] } }, { "method_name": "is_valid_move", "method_description": "def is_valid_move(self, pos1, pos2):\n \"\"\"\n check if the move of two icons is valid (i.e. positions are within the game board range, the two positions are not the same, the two positions have the same icon, and there is a valid path between the two positions)\n :param pos1: position tuple(x, y) of the first icon\n :param pos2: position tuple(x, y) of the second icon\n :return:True or False ,representing whether the move of two icons is valid\n >>> mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n >>> mc.is_valid_move((0, 0), (1, 0))\n True\n \"\"\"", "test_class": "MahjongConnectTestIsValidMove", "test_code": "class MahjongConnectTestIsValidMove(unittest.TestCase):\n def test_is_valid_move_1(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.is_valid_move((0, 0), (1, 0))\n self.assertEqual(res, True)\n\n def test_is_valid_move_2(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.is_valid_move((0, 0), (0, 1))\n self.assertEqual(res, False)\n\n def test_is_valid_move_3(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.is_valid_move((-1, 0), (0, 1))\n self.assertEqual(res, False)\n\n def test_is_valid_move_4(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.is_valid_move((0, 0), (0, 0))\n self.assertEqual(res, False)\n\n def test_is_valid_move_5(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.is_valid_move((300, 0), (0, 0))\n self.assertEqual(res, False)\n\n def test_is_valid_move_6(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'a', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.is_valid_move((0, 2), (0, 0))\n self.assertEqual(res, False)", "solution_code": "def is_valid_move(self, pos1, pos2):\n x1, y1 = pos1\n x2, y2 = pos2\n\n # Check if positions are within the game board range\n if not (0 <= x1 < self.BOARD_SIZE[0] and 0 <= y1 < self.BOARD_SIZE[1] and 0 <= x2 < self.BOARD_SIZE[\n 0] and 0 <= y2 <\n self.BOARD_SIZE[1]):\n return False\n\n # Check if the two positions are the same\n if pos1 == pos2:\n return False\n\n # Check if the two positions have the same icon\n if self.board[x1][y1] != self.board[x2][y2]:\n return False\n\n # Check if there is a valid path between the two positions\n if not self.has_path(pos1, pos2):\n return False\n\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.BOARD_SIZE", "self.board" ], "method_dependencies": [ "has_path" ] } }, { "method_name": "has_path", "method_description": "def has_path(self, pos1, pos2):\n \"\"\"\n check if there is a path between two icons\n :param pos1: position tuple(x, y) of the first icon\n :param pos2: position tuple(x, y) of the second icon\n :return: True or False ,representing whether there is a path between two icons\n >>> mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n >>> mc.is_valid_move((0, 0), (1, 0))\n True\n \"\"\"", "test_class": "MahjongConnectTestHasPath", "test_code": "class MahjongConnectTestHasPath(unittest.TestCase):\n def test_has_path_1(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.has_path((0, 0), (1, 0))\n self.assertEqual(res, True)\n\n def test_has_path_2(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.has_path((0, 0), (0, 0))\n self.assertEqual(res, True)\n\n def test_has_path_3(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.has_path((0, 0), (3, 0))\n self.assertEqual(res, True)\n\n def test_has_path_4(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.has_path((0, 0), (1, 1))\n self.assertEqual(res, False)\n\n def test_has_path_5(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n res = mc.has_path((300, 0), (1, 1))\n self.assertEqual(res, False)\n\n def test_has_path_6(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'a', 'a', 'a'],\n ['a', 'a', 'a', 'a'],\n ['a', 'a', 'a', 'a'],\n ['a', 'a', 'a', 'a']]\n res = mc.has_path((0, 0), (3, 3))\n self.assertEqual(res, True)", "solution_code": "def has_path(self, pos1, pos2):\n visited = set()\n stack = [pos1]\n\n while stack:\n current_pos = stack.pop()\n if current_pos == pos2:\n return True\n\n if current_pos in visited:\n continue\n\n visited.add(current_pos)\n x, y = current_pos\n\n # Check adjacent positions (up, down, left, right)\n for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:\n new_x, new_y = x + dx, y + dy\n if 0 <= new_x < self.BOARD_SIZE[0] and 0 <= new_y < self.BOARD_SIZE[1]:\n if (new_x, new_y) not in visited and self.board[new_x][new_y] == self.board[x][y]:\n stack.append((new_x, new_y))\n\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.BOARD_SIZE", "self.board" ], "method_dependencies": [] } }, { "method_name": "remove_icons", "method_description": "def remove_icons(self, pos1, pos2):\n \"\"\"\n remove the connected icons on the game board\n :param pos1: position tuple(x, y) of the first icon to be removed\n :param pos2: position tuple(x, y) of the second icon to be removed\n :return: None\n >>> mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n >>> mc.remove_icons((0, 0), (1, 0))\n mc.board = [[' ', 'b', 'c', 'a'],\n [' ', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n \"\"\"", "test_class": "MahjongConnectTestRemoveIcons", "test_code": "class MahjongConnectTestRemoveIcons(unittest.TestCase):\n def test_remove_icons_1(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n mc.remove_icons((0, 0), (1, 0))\n self.assertEqual(mc.board, [[' ', 'b', 'c', 'a'],\n [' ', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']])\n\n def test_remove_icons_2(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n mc.remove_icons((2, 0), (1, 0))\n self.assertEqual(mc.board, [['a', 'b', 'c', 'a'],\n [' ', 'b', 'c', 'a'],\n [' ', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']])\n\n def test_remove_icons_3(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n mc.remove_icons((1, 1), (0, 1))\n self.assertEqual(mc.board, [['a', ' ', 'c', 'a'],\n ['a', ' ', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']])\n\n def test_remove_icons_4(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n mc.remove_icons((3, 0), (2, 0))\n self.assertEqual(mc.board, [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n [' ', 'b', 'c', 'a'],\n [' ', 'b', 'c', 'a']])\n\n def test_remove_icons_5(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a']]\n mc.remove_icons((3, 3), (2, 3))\n self.assertEqual(mc.board, [['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', 'a'],\n ['a', 'b', 'c', ' '],\n ['a', 'b', 'c', ' ']])", "solution_code": "def remove_icons(self, pos1, pos2):\n x1, y1 = pos1\n x2, y2 = pos2\n self.board[x1][y1] = ' '\n self.board[x2][y2] = ' '", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.board" ], "method_dependencies": [] } }, { "method_name": "is_game_over", "method_description": "def is_game_over(self):\n \"\"\"\n Check if the game is over (i.e., if there are no more icons on the game board)\n :return: True or False ,representing whether the game is over\n >>> mc = MahjongConnect([4, 4] ['a', 'b', 'c'])\n >>> mc.board = [[' ', ' ', ' ', ' '],\n >>> [' ', ' ', ' ', ' '],\n >>> [' ', ' ', ' ', ' '],\n >>> [' ', ' ', ' ', ' ']]\n >>> mc.is_game_over()\n True\n \"\"\"", "test_class": "MahjongConnectTestIsGameOver", "test_code": "class MahjongConnectTestIsGameOver(unittest.TestCase):\n def test_is_game_over_1(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [[' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' ']]\n res = mc.is_game_over()\n self.assertEqual(res, True)\n\n def test_is_game_over_2(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', ' ', ' ', ' '],\n ['a', ' ', ' ', ' '],\n [' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' ']]\n res = mc.is_game_over()\n self.assertEqual(res, False)\n\n def test_is_game_over_3(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [[' ', ' ', ' ', ' '],\n ['a', ' ', ' ', ' '],\n [' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' ']]\n res = mc.is_game_over()\n self.assertEqual(res, False)\n\n def test_is_game_over_4(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['1', ' ', ' ', ' '],\n [' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' ']]\n res = mc.is_game_over()\n self.assertEqual(res, False)\n\n def test_is_game_over_5(self):\n mc = MahjongConnect([4, 4], ['a', 'b', 'c'])\n mc.board = [['a', ' ', ' ', ' '],\n [' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' '],\n [' ', ' ', ' ', ' ']]\n res = mc.is_game_over()\n self.assertEqual(res, False)", "solution_code": "def is_game_over(self):\n for row in self.board:\n if any(icon != ' ' for icon in row):\n return False\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.board" ], "method_dependencies": [] } } ]

[ "MahjongConnectTestCreateBoard", "MahjongConnectTestIsValidMove", "MahjongConnectTestHasPath", "MahjongConnectTestRemoveIcons", "MahjongConnectTestIsGameOver", "MahjongConnectTest" ]

[ "self.BOARD_SIZE", "self.ICONS", "self.board" ]

[]

[ { "method_name": "palindromic_length", "method_description": "def palindromic_length(self, center, diff, string):\n \"\"\"\n Recursively calculates the length of the palindromic substring based on a given center, difference value, and input string.\n :param center: The center of the palindromic substring, int.\n :param diff: The difference between the center and the current position, int.\n :param string: The string to be searched, str.\n :return: The length of the palindromic substring, int.\n >>> manacher = Manacher('ababa')\n >>> manacher.palindromic_length(2, 1, 'a|b|a|b|a')\n 2\n\n \"\"\"", "test_class": "ManacherTestPalindromicLength", "test_code": "class ManacherTestPalindromicLength(unittest.TestCase):\n def test_palindromic_length(self):\n manacher = Manacher('ababa')\n self.assertEqual(manacher.palindromic_length(2, 1, 'a|b|a|b|a'), 2)\n def test_palindromic_length_2(self):\n manacher = Manacher('ababaxse')\n self.assertEqual(manacher.palindromic_length(2, 1, 'a|b|a|b|a|x|s|e'), 2)\n\n def test_palindromic_length_3(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_length(2, 3, 'a|b|a|b|a|x'), 0)\n\n def test_palindromic_length_4(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_length(9, 2, 'a|b|a|b|a|x'), 0)\n\n def test_palindromic_length_5(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_length(4, 1, 'a|b|a|b|a|x'), 4)", "solution_code": "def palindromic_length(self, center, diff, string):\n if (center - diff == -1 or center + diff == len(string)\n or string[center - diff] != string[center + diff]):\n return 0\n return 1 + self.palindromic_length(center, diff + 1, string)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "palindromic_string", "method_description": "def palindromic_string(self):\n \"\"\"\n Finds the longest palindromic substring in the given string.\n :return: The longest palindromic substring, str.\n >>> manacher = Manacher('ababaxse')\n >>> manacher.palindromic_string()\n 'ababa'\n\n \"\"\"", "test_class": "ManacherTestPalindromicString", "test_code": "class ManacherTestPalindromicString(unittest.TestCase):\n def test_palindromic_string(self):\n manacher = Manacher('ababaxse')\n self.assertEqual(manacher.palindromic_string(), 'ababa')\n\n def test_palindromic_string_2(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_string(), 'ababa')\n\n def test_palindromic_string_3(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_string(), 'ababa')\n\n def test_palindromic_string_4(self):\n manacher = Manacher('ababaxssss')\n self.assertEqual(manacher.palindromic_string(), 'ababa')\n\n def test_palindromic_string_5(self):\n manacher = Manacher('abab')\n self.assertEqual(manacher.palindromic_string(), 'aba')", "solution_code": "def palindromic_string(self):\n max_length = 0\n\n new_input_string = \"\"\n output_string = \"\"\n\n for i in self.input_string[:len(self.input_string) - 1]:\n new_input_string += i + \"|\"\n new_input_string += self.input_string[-1]\n\n for i in range(len(new_input_string)):\n\n length =self.palindromic_length(i, 1, new_input_string)\n\n if max_length < length:\n max_length = length\n start = i\n\n for i in new_input_string[start - max_length:start + max_length + 1]:\n if i != \"|\":\n output_string += i\n\n return output_string", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.input_string" ], "method_dependencies": [ "palindromic_length" ] } } ]

[ "ManacherTestPalindromicLength", "ManacherTestPalindromicString", "ManacherTestMain" ]

[ "self.input_string" ]

[]

[ { "method_name": "update", "method_description": "def update(self, predicted_labels, true_labels):\n \"\"\"\n Update the number of all four samples(true_positives, false_positives, false_negatives, true_negatives)\n :param predicted_labels: list, predicted results\n :param true_labels: list, true labels\n :return: None, change the number of corresponding samples\n >>> mc = MetricsCalculator()\n >>> mc.update([1, 1, 0, 0], [1, 0, 0, 1])\n (self.true_positives, self.false_positives, self.false_negatives, self.true_negatives) = (1, 1, 1, 1)\n \"\"\"", "test_class": "MetricsCalculatorTestUpdate", "test_code": "class MetricsCalculatorTestUpdate(unittest.TestCase):\n def test_update_1(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 1, 1, 1))\n\n def test_update_2(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 1, 0], [1, 0, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 2, 1, 0))\n\n def test_update_3(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (2, 1, 0, 1))\n\n def test_update_4(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (2, 0, 1, 1))\n\n def test_update_5(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 1, 2, 0))", "solution_code": "def update(self, predicted_labels, true_labels):\n for predicted, true in zip(predicted_labels, true_labels):\n if predicted == 1 and true == 1:\n self.true_positives += 1\n elif predicted == 1 and true == 0:\n self.false_positives += 1\n elif predicted == 0 and true == 1:\n self.false_negatives += 1\n elif predicted == 0 and true == 0:\n self.true_negatives += 1", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.false_negatives", "self.false_positives", "self.true_negatives", "self.true_positives" ], "method_dependencies": [] } }, { "method_name": "precision", "method_description": "def precision(self, predicted_labels, true_labels):\n \"\"\"\n Calculate precision\n :param predicted_labels: list, predicted results\n :param true_labels: list, true labels\n :return: float\n >>> mc = MetricsCalculator()\n >>> mc.precision([1, 1, 0, 0], [1, 0, 0, 1])\n 0.5\n \"\"\"", "test_class": "MetricsCalculatorTestPrecision", "test_code": "class MetricsCalculatorTestPrecision(unittest.TestCase):\n def test_precision_1(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_precision_2(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 1, 0], [1, 0, 0, 1])\n self.assertAlmostEqual(temp, 0.3333333333333333)\n\n def test_precision_3(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertAlmostEqual(temp, 0.6666666666666666)\n\n def test_precision_4(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertAlmostEqual(temp, 1.0)\n\n def test_precision_5(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertAlmostEqual(temp, 0.5)\n\n def test_precision_6(self):\n mc = MetricsCalculator()\n temp = mc.precision([0, 0, 0, 0], [1, 0, 1, 1])\n self.assertAlmostEqual(temp, 0.0)", "solution_code": "def precision(self, predicted_labels, true_labels):\n self.update(predicted_labels, true_labels)\n if self.true_positives + self.false_positives == 0:\n return 0.0\n return self.true_positives / (self.true_positives + self.false_positives)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.false_positives", "self.true_positives" ], "method_dependencies": [ "update" ] } }, { "method_name": "recall", "method_description": "def recall(self, predicted_labels, true_labels):\n \"\"\"\n Calculate recall\n :param predicted_labels: list, predicted results\n :param true_labels: list, true labels\n :return: float\n >>> mc = MetricsCalculator()\n >>> mc.recall([1, 1, 0, 0], [1, 0, 0, 1])\n 0.5\n \"\"\"", "test_class": "MetricsCalculatorTestRecall", "test_code": "class MetricsCalculatorTestRecall(unittest.TestCase):\n def test_recall_1(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_recall_2(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 1, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_recall_3(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertEqual(temp, 1.0)\n\n def test_recall_4(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertAlmostEqual(temp, 0.6666666666666666)\n\n def test_recall_5(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertAlmostEqual(temp, 0.3333333333333333)\n\n def test_recall_6(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 0], [0, 0, 0, 0])\n self.assertEqual(temp, 0.0)", "solution_code": "def recall(self, predicted_labels, true_labels):\n self.update(predicted_labels, true_labels)\n if self.true_positives + self.false_negatives == 0:\n return 0.0\n return self.true_positives / (self.true_positives + self.false_negatives)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.false_negatives", "self.true_positives" ], "method_dependencies": [ "update" ] } }, { "method_name": "f1_score", "method_description": "def f1_score(self, predicted_labels, true_labels):\n \"\"\"\n Calculate f1 score, which is the harmonic mean of precision and recall\n :param predicted_labels: list, predicted results\n :param true_labels: list, true labels\n :return: float\n >>> mc = MetricsCalculator()\n >>> mc.f1_score([1, 1, 0, 0], [1, 0, 0, 1])\n 0.5\n \"\"\"", "test_class": "MetricsCalculatorTestF1Score", "test_code": "class MetricsCalculatorTestF1Score(unittest.TestCase):\n def test_f1_score_1(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_f1_score_2(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 1, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.4)\n\n def test_f1_score_3(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertEqual(temp, 0.8)\n\n def test_f1_score_4(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertEqual(temp, 0.8)\n\n def test_f1_score_5(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertEqual(temp, 0.4)\n\n def test_f1_score_6(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([0, 0, 0, 0], [0, 0, 0, 0])\n self.assertEqual(temp, 0.0)", "solution_code": "def f1_score(self, predicted_labels, true_labels):\n self.update(predicted_labels, true_labels)\n precision = self.precision(predicted_labels, true_labels)\n recall = self.recall(predicted_labels, true_labels)\n if precision + recall == 0.0:\n return 0.0\n return (2 * precision * recall) / (precision + recall)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "update", "precision", "recall" ] } }, { "method_name": "accuracy", "method_description": "def accuracy(self, predicted_labels, true_labels):\n \"\"\"\n Calculate accuracy\n :param predicted_labels: list, predicted results\n :param true_labels: list, true labels\n :return: float\n >>> mc = MetricsCalculator()\n >>>mc.accuracy([1, 1, 0, 0], [1, 0, 0, 1])\n 0.5\n \"\"\"", "test_class": "MetricsCalculatorTestAccuracy", "test_code": "class MetricsCalculatorTestAccuracy(unittest.TestCase):\n def test_accuracy_1(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_accuracy_2(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 2, 0], [1, 0, 0, 1])\n self.assertAlmostEqual(temp, 0.3333333333333333)\n\n def test_accuracy_3(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertEqual(temp, 0.75)\n\n def test_accuracy_4(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertEqual(temp, 0.75)\n\n def test_accuracy_5(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertEqual(temp, 0.25)\n\n def test_accuracy_6(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([], [])\n self.assertEqual(temp, 0.0)", "solution_code": "def accuracy(self, predicted_labels, true_labels):\n self.update(predicted_labels, true_labels)\n total = self.true_positives + self.true_negatives + self.false_positives + self.false_negatives\n if total == 0:\n return 0.0\n return (self.true_positives + self.true_negatives) / total", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.false_negatives", "self.false_positives", "self.true_negatives", "self.true_positives" ], "method_dependencies": [ "update" ] } } ]

[ "MetricsCalculatorTestUpdate", "MetricsCalculatorTestPrecision", "MetricsCalculatorTestRecall", "MetricsCalculatorTestF1Score", "MetricsCalculatorTestAccuracy", "MetricsCalculatorTest" ]

[ "self.false_negatives", "self.false_positives", "self.true_negatives", "self.true_positives" ]

[ "import numpy as np" ]

[ { "method_name": "mrr", "method_description": "def mrr(data):\n \"\"\"\n compute the MRR of the input data. MRR is a widely used evaluation index. It is the mean of reciprocal rank.\n :param data: the data must be a tuple, list 0,1,eg.([1,0,...],5). In each tuple (actual result,ground truth num),ground truth num is the total ground num.\n ([1,0,...],5),\n or list of tuple eg. [([1,0,1,...],5),([1,0,...],6),([0,0,...],5)].\n 1 stands for a correct answer, 0 stands for a wrong answer.\n :return: if input data is list, return the recall of this list. if the input data is list of list, return the\n average recall on all list. The second return value is a list of precision for each input.\n >>> MetricsCalculator2.mrr(([1, 0, 1, 0], 4))\n >>> MetricsCalculator2.mrr([([1, 0, 1, 0], 4), ([0, 1, 0, 1], 4)])\n 1.0, [1.0]\n 0.75, [1.0, 0.5]\n \"\"\"", "test_class": "MetricsCalculator2TestMrr", "test_code": "class MetricsCalculator2TestMrr(unittest.TestCase):\n def test_mrr_1(self):\n mc2 = MetricsCalculator2()\n res1, res2 = MetricsCalculator2.mrr(([1, 0, 1, 0], 4))\n self.assertEqual(res1, 1.0)\n self.assertEqual(res2, [1.0])\n\n def test_mrr_2(self):\n res1, res2 = MetricsCalculator2.mrr(([0, 0, 0, 1], 4))\n self.assertEqual(res1, 0.25)\n self.assertEqual(res2, [0.25])\n\n def test_mrr_3(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 0, 1, 0], 4), ([0, 1, 0, 1], 4)])\n self.assertEqual(res1, 0.75)\n self.assertEqual(res2, [1.0, 0.5])\n\n def test_mrr_4(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 1, 1, 0], 4), ([0, 0, 0, 1], 4)])\n self.assertEqual(res1, 0.625)\n self.assertEqual(res2, [1.0, 0.25])\n\n def test_mrr_5(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 0, 1, 1], 4), ([0, 1, 0, 0], 4)])\n self.assertEqual(res1, 0.75)\n self.assertEqual(res2, [1.0, 0.5])\n\n def test_mrr_6(self):\n try:\n MetricsCalculator2.mrr(1)\n except:\n pass\n\n def test_mrr_7(self):\n res1, res2 = MetricsCalculator2.mrr([])\n self.assertEqual(res1, 0.0)\n self.assertEqual(res2, [0.0])\n\n def test_mrr_8(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 0, 1, 1], 0), ([0, 1, 0, 0], 0)])\n self.assertEqual(res1, 0.0)\n self.assertEqual(res2, [0.0, 0.0])", "solution_code": "def mrr(data):\n if type(data) != list and type(data) != tuple:\n raise Exception(\"the input must be a tuple([0,...,1,...],int) or a iteration of list of tuple\")\n\n if len(data) == 0:\n return 0.0, [0.0]\n if type(data) == tuple:\n (sub_list, total_num) = data\n sub_list = np.array(sub_list)\n if total_num == 0:\n return 0.0, [0.0]\n else:\n ranking_array = 1.0 / (np.array(list(range(len(sub_list)))) + 1)\n mr_np = sub_list * ranking_array\n\n mr = 0.0\n for team in mr_np:\n if team > 0:\n mr = team\n break\n return mr, [mr]\n\n if type(data) == list:\n separate_result = []\n for (sub_list, total_num) in data:\n sub_list = np.array(sub_list)\n\n if total_num == 0:\n mr = 0.0\n else:\n ranking_array = 1.0 / (np.array(list(range(len(sub_list)))) + 1)\n mr_np = sub_list * ranking_array\n\n mr = 0.0\n for team in mr_np:\n if team > 0:\n mr = team\n break\n\n separate_result.append(mr)\n return np.mean(separate_result), separate_result", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "map", "method_description": "@staticmethod\n def map(data):\n \"\"\"\n compute the MAP of the input data. MAP is a widely used evaluation index. It is the mean of AP (average precision).\n :param data: the data must be a tuple, list 0,1,eg.([1,0,...],5). In each tuple (actual result,ground truth num),ground truth num is the total ground num.\n ([1,0,...],5),\n or list of tuple eg. [([1,0,1,...],5),([1,0,...],6),([0,0,...],5)].\n 1 stands for a correct answer, 0 stands for a wrong answer.\n :return: if input data is list, return the recall of this list. if the input data is list of list, return the\n average recall on all list. The second return value is a list of precision for each input.\n >>> MetricsCalculator2.map(([1, 0, 1, 0], 4))\n >>> MetricsCalculator2.map([([1, 0, 1, 0], 4), ([0, 1, 0, 1], 4)])\n 0.41666666666666663, [0.41666666666666663]\n 0.3333333333333333, [0.41666666666666663, 0.25]\n \"\"\"", "test_class": "MetricsCalculator2TestMap", "test_code": "class MetricsCalculator2TestMap(unittest.TestCase):\n def test_map_1(self):\n res1, res2 = MetricsCalculator2.map(([1, 0, 1, 0], 4))\n self.assertEqual(res1, 0.41666666666666663)\n self.assertEqual(res2, [0.41666666666666663])\n\n def test_map_2(self):\n res1, res2 = MetricsCalculator2.map(([0, 0, 0, 1], 4))\n self.assertEqual(res1, 0.0625)\n self.assertEqual(res2, [0.0625])\n\n def test_map_3(self):\n res1, res2 = MetricsCalculator2.map([([1, 0, 1, 0], 4), ([0, 1, 0, 1], 4)])\n self.assertEqual(res1, 0.3333333333333333)\n self.assertEqual(res2, [0.41666666666666663, 0.25])\n\n def test_map_4(self):\n res1, res2 = MetricsCalculator2.map([([1, 1, 1, 0], 4), ([0, 0, 0, 1], 4)])\n self.assertEqual(res1, 0.40625)\n self.assertEqual(res2, [0.75, 0.0625])\n\n def test_map_5(self):\n res1, res2 = MetricsCalculator2.map([([1, 0, 1, 1], 4), ([0, 1, 0, 0], 4)])\n self.assertEqual(res1, 0.3645833333333333)\n self.assertEqual(res2, [0.6041666666666666, 0.125])\n\n def test_map_6(self):\n try:\n MetricsCalculator2.map(1)\n except:\n pass\n\n def test_map_7(self):\n res1, res2 = MetricsCalculator2.map([])\n self.assertEqual(res1, 0.0)\n self.assertEqual(res2, [0.0])\n\n def test_map_8(self):\n res1, res2 = MetricsCalculator2.map([([1, 0, 1, 1], 0), ([0, 1, 0, 0], 0)])\n self.assertEqual(res1, 0.0)\n self.assertEqual(res2, [0.0, 0.0])", "solution_code": "@staticmethod\n def map(data):\n if type(data) != list and type(data) != tuple:\n raise Exception(\"the input must be a tuple([0,...,1,...],int) or a iteration of list of tuple\")\n\n if len(data) == 0:\n return 0.0, [0.0]\n if type(data) == tuple:\n (sub_list, total_num) = data\n sub_list = np.array(sub_list)\n if total_num == 0:\n return 0.0, [0.0]\n else:\n ranking_array = 1.0 / (np.array(list(range(len(sub_list)))) + 1)\n\n right_ranking_list = []\n count = 1\n for t in sub_list:\n if t == 0:\n right_ranking_list.append(0)\n else:\n right_ranking_list.append(count)\n count += 1\n\n ap = np.sum(np.array(right_ranking_list) * ranking_array) / total_num\n return ap, [ap]\n\n if type(data) == list:\n separate_result = []\n for (sub_list, total_num) in data:\n sub_list = np.array(sub_list)\n\n if total_num == 0:\n ap = 0.0\n else:\n ranking_array = 1.0 / (np.array(list(range(len(sub_list)))) + 1)\n\n right_ranking_list = []\n count = 1\n for t in sub_list:\n if t == 0:\n right_ranking_list.append(0)\n else:\n right_ranking_list.append(count)\n count += 1\n\n ap = np.sum(np.array(right_ranking_list) * ranking_array) / total_num\n\n separate_result.append(ap)\n return np.mean(separate_result), separate_result", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "MetricsCalculator2TestMrr", "MetricsCalculator2TestMap", "MetricsCalculator2Test" ]

[]

[ "import random" ]

[ { "method_name": "generate_mine_sweeper_map", "method_description": "def generate_mine_sweeper_map(self):\n \"\"\"\n Generates a minesweeper map with the given size of the board and the number of mines,the given parameter n is the size of the board,the size of the board is n*n,the parameter k is the number of mines,'X' represents the mine,other numbers represent the number of mines around the position.\n :return: The minesweeper map, list.\n >>> minesweeper_game = MinesweeperGame(3, 1)\n >>> minesweeper_game.generate_mine_sweeper_map()\n [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n\n \"\"\"", "test_class": "MinesweeperGameTestGenerateMineSweeperMap", "test_code": "class MinesweeperGameTestGenerateMineSweeperMap(unittest.TestCase):\n def test_generate_mine_sweeper_map(self):\n minesweeper_game = MinesweeperGame(3, 2)\n length = len(minesweeper_game.minesweeper_map)\n mine_num = 0\n for row in minesweeper_game.minesweeper_map:\n for cell in row:\n if cell == 'X':\n mine_num += 1\n self.assertEqual(3, length)\n self.assertEqual(2, mine_num)\n\n def test_generate_mine_sweeper_map_2(self):\n minesweeper_game = MinesweeperGame(3, 1)\n length = len(minesweeper_game.minesweeper_map)\n mine_num = 0\n for row in minesweeper_game.minesweeper_map:\n for cell in row:\n if cell == 'X':\n mine_num += 1\n self.assertEqual(3, length)\n self.assertEqual(1, mine_num)\n\n def test_generate_mine_sweeper_map_3(self):\n minesweeper_game = MinesweeperGame(3, 0)\n length = len(minesweeper_game.minesweeper_map)\n mine_num = 0\n for row in minesweeper_game.minesweeper_map:\n for cell in row:\n if cell == 'X':\n mine_num += 1\n self.assertEqual(3, length)\n self.assertEqual(0, mine_num)\n\n def test_generate_mine_sweeper_map_4(self):\n minesweeper_game = MinesweeperGame(5, 1)\n length = len(minesweeper_game.minesweeper_map)\n mine_num = 0\n for row in minesweeper_game.minesweeper_map:\n for cell in row:\n if cell == 'X':\n mine_num += 1\n self.assertEqual(length,5)\n self.assertEqual(mine_num, 1)\n\n def test_generate_mine_sweeper_map_5(self):\n minesweeper_game = MinesweeperGame(4, 1)\n length = len(minesweeper_game.minesweeper_map)\n mine_num = 0\n for row in minesweeper_game.minesweeper_map:\n for cell in row:\n if cell == 'X':\n mine_num += 1\n self.assertEqual(length, 4)\n self.assertEqual(mine_num, 1)", "solution_code": "def generate_mine_sweeper_map(self):\n arr = [[0 for row in range(self.n)] for column in range(self.n)]\n for num in range(self.k):\n x = random.randint(0, self.n-1)\n y = random.randint(0, self.n-1)\n arr[y][x] = 'X'\n if (x >=0 and x <= self.n-2) and (y >= 0 and y <= self.n-1):\n if arr[y][x+1] != 'X':\n arr[y][x+1] += 1\n if (x >=1 and x <= self.n-1) and (y >= 0 and y <= self.n-1):\n if arr[y][x-1] != 'X':\n arr[y][x-1] += 1\n if (x >= 1 and x <= self.n-1) and (y >= 1 and y <= self.n-1):\n if arr[y-1][x-1] != 'X':\n arr[y-1][x-1] += 1\n \n if (x >= 0 and x <= self.n-2) and (y >= 1 and y <= self.n-1):\n if arr[y-1][x+1] != 'X':\n arr[y-1][x+1] += 1 \n if (x >= 0 and x <= self.n-1) and (y >= 1 and y <= self.n-1):\n if arr[y-1][x] != 'X':\n arr[y-1][x] += 1\n \n if (x >=0 and x <= self.n-2) and (y >= 0 and y <= self.n-2):\n if arr[y+1][x+1] != 'X':\n arr[y+1][x+1] += 1\n if (x >= 1 and x <= self.n-1) and (y >= 0 and y <= self.n-2):\n if arr[y+1][x-1] != 'X':\n arr[y+1][x-1] += 1\n if (x >= 0 and x <= self.n-1) and (y >= 0 and y <= self.n-2):\n if arr[y+1][x] != 'X':\n arr[y+1][x] += 1\n return arr", "dependencies": { "Standalone": false, "lib_dependencies": [ "random" ], "field_dependencies": [ "self.k", "self.n" ], "method_dependencies": [] } }, { "method_name": "generate_playerMap", "method_description": "def generate_playerMap(self):\n \"\"\"\n Generates a player map with the given size of the board, the given parameter n is the size of the board,the size of the board is n*n,the parameter k is the number of mines,'-' represents the unknown position.\n :return: The player map, list.\n >>> minesweeper_game = MinesweeperGame(3, 1)\n >>> minesweeper_game.generate_playerMap()\n [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]\n\n \"\"\"", "test_class": "MinesweeperGameTestGeneratePlayerMap", "test_code": "class MinesweeperGameTestGeneratePlayerMap(unittest.TestCase):\n def test_generate_playerMap(self):\n minesweeper_game = MinesweeperGame(3, 2)\n self.assertEqual(minesweeper_game.generate_playerMap(), [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']])\n\n def test_generate_playerMap_2(self):\n minesweeper_game = MinesweeperGame(3, 1)\n self.assertEqual(minesweeper_game.generate_playerMap(), [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']])\n\n def test_generate_playerMap_3(self):\n minesweeper_game = MinesweeperGame(4, 2)\n self.assertEqual(minesweeper_game.generate_playerMap(),[['-', '-', '-', '-'],['-', '-', '-', '-'],['-', '-', '-', '-'],['-', '-', '-', '-']])\n\n def test_generate_playerMap_4(self):\n minesweeper_game = MinesweeperGame(1, 4)\n self.assertEqual(minesweeper_game.generate_playerMap(), [['-']])\n\n def test_generate_playerMap_5(self):\n minesweeper_game = MinesweeperGame(2, 5)\n self.assertEqual(minesweeper_game.generate_playerMap(), [['-', '-'], ['-', '-']])", "solution_code": "def generate_playerMap(self):\n arr = [['-' for row in range(self.n)] for column in range(self.n)]\n return arr", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.n" ], "method_dependencies": [] } }, { "method_name": "check_won", "method_description": "def check_won(self,map):\n \"\"\"\n Checks whether the player has won the game,if there are just mines in the player map,return True,otherwise return False.\n :return: True if the player has won the game, False otherwise.\n >>> minesweeper_game = MinesweeperGame(3, 1)\n >>> minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n >>> minesweeper_game.player_map = [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]\n >>> minesweeper_game.check_won(minesweeper_game.player_map)\n False\n\n \"\"\"", "test_class": "MinesweeperGameTestCheckWon", "test_code": "class MinesweeperGameTestCheckWon(unittest.TestCase):\n def test_check_won(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]\n self.assertEqual(minesweeper_game.check_won(minesweeper_game.player_map), False)\n\n def test_check_won_2(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '-', '-'], ['-', 1, '-'], ['-', '-', '-']]\n self.assertEqual(minesweeper_game.check_won(minesweeper_game.player_map), False)\n\n def test_check_won_3(self):\n minesweeper_game = MinesweeperGame(3, 0)\n minesweeper_game.minesweeper_map = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '-', '-'], ['-', 1, '-'], ['-', '-', '-']]\n self.assertEqual(minesweeper_game.check_won(minesweeper_game.player_map), False)\n\n def test_check_won_4(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '1', '0'], ['1', 1, '0'], ['0', '0', '0']]\n self.assertEqual(minesweeper_game.check_won(minesweeper_game.player_map), True)\n\n def test_check_won_5(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['X', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]\n self.assertEqual(minesweeper_game.check_won(minesweeper_game.player_map), False)", "solution_code": "def check_won(self, map):\n for i in range(self.n):\n for j in range(self.n):\n if map[i][j] == '-' and self.minesweeper_map[i][j] != 'X':\n return False\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.minesweeper_map", "self.n" ], "method_dependencies": [ "sweep" ] } }, { "method_name": "sweep", "method_description": "def sweep(self, x, y):\n \"\"\"\n Sweeps the given position.\n :param x: The x coordinate of the position, int.\n :param y: The y coordinate of the position, int.\n :return: True if the player has won the game, False otherwise,if the game still continues, return the player map, list.\n >>> minesweeper_game = MinesweeperGame(3, 1)\n >>> minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n >>> minesweeper_game.player_map = [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]\n >>> minesweeper_game.sweep(1, 1)\n [['-', '-', '-'], ['-', 1, '-'], ['-', '-', '-']]\n\n \"\"\"", "test_class": "MinesweeperGameTestSweep", "test_code": "class MinesweeperGameTestSweep(unittest.TestCase):\n def test_sweep(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]\n self.assertEqual(minesweeper_game.sweep(1,1), [['-', '-', '-'], ['-', 1, '-'], ['-', '-', '-']])\n self.assertEqual(minesweeper_game.score, 1)\n\n def test_sweep_2(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '-', '-'], ['-', '-', '-'], ['-', '-', '-']]\n self.assertEqual(minesweeper_game.sweep(0,0), False)\n self.assertEqual(minesweeper_game.score, 0)\n\n def test_sweep_3(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '-', '0'], ['1', '1', '0'], ['0', '0', '0']]\n self.assertEqual(minesweeper_game.sweep(0,1), True)\n self.assertEqual(minesweeper_game.score, 1)\n\n def test_sweep_4(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '-', '-'], ['-', '-', '0'], ['0', '0', '0']]\n self.assertEqual(minesweeper_game.sweep(0,2), [['-', '-', 0], ['-', '-', '0'], ['0', '0', '0']])\n self.assertEqual(minesweeper_game.score, 1)\n\n def test_sweep_5(self):\n minesweeper_game = MinesweeperGame(3, 1)\n minesweeper_game.minesweeper_map = [['X', 1, 0], [1, 1, 0], [0, 0, 0]]\n minesweeper_game.player_map = [['-', '-', '0'], ['-', '1', '0'], ['0', '0', '0']]\n self.assertEqual(minesweeper_game.sweep(1,0), [['-', '-', '0'], [1, '1', '0'], ['0', '0', '0']])\n self.assertEqual(minesweeper_game.score, 1)", "solution_code": "def sweep(self, x, y):\n\n if (self.minesweeper_map[x][y] == 'X'):\n return False\n else:\n self.player_map[x][y] = self.minesweeper_map[x][y]\n self.score += 1\n if self.check_won(self.player_map) == True:\n return True\n return self.player_map", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.minesweeper_map", "self.player_map", "self.score" ], "method_dependencies": [ "check_won" ] } } ]

[ "MinesweeperGameTestGenerateMineSweeperMap", "MinesweeperGameTestGeneratePlayerMap", "MinesweeperGameTestCheckWon", "MinesweeperGameTestSweep", "MinesweeperGameTestMain" ]

[ "self.k", "self.minesweeper_map", "self.n", "self.player_map", "self.score" ]

[ "from datetime import datetime", "import numpy as np" ]

[ { "method_name": "add_movie", "method_description": "def add_movie(self, name, price, start_time, end_time, n):\n \"\"\"\n Add a new movie into self.movies\n :param name: str, movie name\n :param price: float, price for one ticket\n :param start_time: str\n :param end_time: str\n :param n: int, the size of seats(n*n)\n >>> system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n >>> system.movies\n [{'name': 'Batman', 'price': 49.9, 'start_time': datetime.datetime(1900, 1, 1, 17, 5), 'end_time': datetime.datetime(1900, 1, 1, 19, 25),\n 'seats': array([[0., 0., 0.],\n [0., 0., 0.],\n [0., 0., 0.]])}]\n \"\"\"", "test_class": "MovieBookingSystemTestAddMovie", "test_code": "class MovieBookingSystemTestAddMovie(unittest.TestCase):\n def setUp(self):\n self.system = MovieBookingSystem()\n\n def tearDown(self):\n self.system = None\n\n def test_add_movie_1(self):\n self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 1)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[0]['price'], 49.9)\n self.assertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(self.system.movies[0]['seats'].shape, (3, 3))\n\n def test_add_movie_2(self):\n self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n self.system.add_movie('Superman', 49.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 2)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[1]['name'], 'Superman')\n\n def test_add_movie_3(self):\n self.system.add_movie('Batman', 39.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 1)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[0]['price'], 39.9)\n self.assertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(self.system.movies[0]['seats'].shape, (3, 3))\n\n def test_add_movie_4(self):\n self.system.add_movie('Batman', 29.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 1)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[0]['price'], 29.9)\n self.assertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(self.system.movies[0]['seats'].shape, (3, 3))\n\n def test_add_movie_5(self):\n self.system.add_movie('Batman', 19.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 1)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[0]['price'], 19.9)\n self.assertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(self.system.movies[0]['seats'].shape, (3, 3))", "solution_code": "def add_movie(self, name, price, start_time, end_time, n):\n movie = {\n 'name': name,\n 'price': price,\n 'start_time': datetime.strptime(start_time, '%H:%M'),\n 'end_time': datetime.strptime(end_time, '%H:%M'),\n 'seats': np.zeros((n, n))\n }\n self.movies.append(movie)", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime" ], "field_dependencies": [ "self.movies" ], "method_dependencies": [] } }, { "method_name": "book_ticket", "method_description": "def book_ticket(self, name, seats_to_book):\n \"\"\"\n Book tickets for a movie. Change the seats value in self.movies if book successfully.\n :param name: str, movie name\n :param seats_to_book: list of tuples, representing seats to book [(row1, col1), (row2, col2), ...]\n :return: str, booking status message. \"Movie not found.\" for no such movie.\n \"Booking success.\" for successfully booking, or \"Booking failed.\" otherwise\n >>> system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n >>> system.book_ticket('Batman', [(0, 0), (0, 1)])\n 'Booking success.'\n >>> system.book_ticket('Batman', [(0, 0)])\n 'Booking failed.'\n >>> system.book_ticket('batman', [(0, 0)])\n 'Movie not found.'\n \"\"\"", "test_class": "MovieBookingSystemTestBookTicket", "test_code": "class MovieBookingSystemTestBookTicket(unittest.TestCase):\n def setUp(self):\n self.system = MovieBookingSystem()\n self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n\n # book successfully\n def test_book_ticket_1(self):\n result = self.system.book_ticket('Batman', [(0, 0), (1, 1), (2, 2)])\n self.assertEqual(result, 'Booking success.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 1)\n self.assertEqual(self.system.movies[0]['seats'][1][1], 1)\n self.assertEqual(self.system.movies[0]['seats'][2][2], 1)\n\n # seat is not available\n def test_book_ticket_2(self):\n self.system.book_ticket('Batman', [(0, 0)])\n result = self.system.book_ticket('Batman', [(0, 0)])\n self.assertEqual(result, 'Booking failed.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 1)\n\n def test_book_ticket_3(self):\n result = self.system.book_ticket('batman', [(0, 0)])\n self.assertEqual(result, 'Movie not found.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 0)\n\n def test_book_ticket_4(self):\n result = self.system.book_ticket('Batman', [(0, 0), (1, 1)])\n self.assertEqual(result, 'Booking success.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 1)\n self.assertEqual(self.system.movies[0]['seats'][1][1], 1)\n\n def test_book_ticket_5(self):\n result = self.system.book_ticket('Batman', [(0, 0)])\n self.assertEqual(result, 'Booking success.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 1)", "solution_code": "def book_ticket(self, name, seats_to_book):\n for movie in self.movies:\n if movie['name'] == name:\n for seat in seats_to_book:\n if movie['seats'][seat[0]][seat[1]] == 0:\n movie['seats'][seat[0]][seat[1]] = 1\n else:\n return \"Booking failed.\"\n return \"Booking success.\"\n return \"Movie not found.\"", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.movies" ], "method_dependencies": [] } }, { "method_name": "available_movies", "method_description": "def available_movies(self, start_time, end_time):\n \"\"\"\n Get a list of available movies within the specified time range\n :param start_time: str, start time in HH:MM format\n :param end_time: str, end time in HH:MM format\n :return: list of str, names of available movies\n >>> system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n >>> system.available_movies('12:00', '22:00')\n ['Batman']\n \"\"\"", "test_class": "MovieBookingSystemTestAvailableMovies", "test_code": "class MovieBookingSystemTestAvailableMovies(unittest.TestCase):\n def setUp(self):\n self.system = MovieBookingSystem()\n self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n self.system.add_movie('Spiderman', 59.9, '20:00', '22:30', 4)\n\n def test_available_movies_1(self):\n result = self.system.available_movies('16:00', '23:00')\n self.assertEqual(result, ['Batman', 'Spiderman'])\n\n def test_available_movies_2(self):\n result = self.system.available_movies('23:00', '23:59')\n self.assertEqual(result, [])\n\n def test_available_movies_3(self):\n result = self.system.available_movies('17:00', '20:00')\n self.assertEqual(result, ['Batman'])\n\n def test_available_movies_4(self):\n result = self.system.available_movies('10:00', '23:00')\n self.assertEqual(result, ['Batman', 'Spiderman'])\n\n def test_available_movies_5(self):\n result = self.system.available_movies('20:00', '23:00')\n self.assertEqual(result, ['Spiderman'])", "solution_code": "def available_movies(self, start_time, end_time):\n start_time = datetime.strptime(start_time, '%H:%M')\n end_time = datetime.strptime(end_time, '%H:%M')\n\n available_movies = []\n for movie in self.movies:\n if start_time <= movie['start_time'] and movie['end_time'] <= end_time:\n available_movies.append(movie['name'])\n\n return available_movies", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime" ], "field_dependencies": [ "self.movies" ], "method_dependencies": [] } } ]

[ "MovieBookingSystemTestAddMovie", "MovieBookingSystemTestBookTicket", "MovieBookingSystemTestAvailableMovies", "MovieBookingSystemTestMain" ]

[ "self.movies" ]

[ "import sqlite3" ]

[ { "method_name": "create_table", "method_description": "def create_table(self):\n \"\"\"\n Creates a \"tickets\" table in the database if it does not exist already.Fields include ID of type int, movie name of type str, theater name of type str, seat number of type str, and customer name of type str\n :return: None\n \"\"\"", "test_class": "MovieTicketDBTestInsertTicket", "test_code": "class MovieTicketDBTestInsertTicket(unittest.TestCase):\n def setUp(self):\n self.db_name = 'test_database.db'\n self.db = MovieTicketDB(self.db_name)\n\n def tearDown(self):\n self.db.connection.close()\n os.remove(self.db_name)\n\n def test_insert_ticket_1(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'John Doe')\n tickets = self.db.search_tickets_by_customer('John Doe')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'John Doe')\n\n def test_insert_ticket_2(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'aaa')\n tickets = self.db.search_tickets_by_customer('aaa')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'aaa')\n\n def test_insert_ticket_3(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'bbb')\n tickets = self.db.search_tickets_by_customer('bbb')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'bbb')\n\n def test_insert_ticket_4(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'ccc')\n tickets = self.db.search_tickets_by_customer('ccc')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'ccc')\n\n def test_insert_ticket_5(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'ddd')\n tickets = self.db.search_tickets_by_customer('ddd')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'ddd')", "solution_code": "def create_table(self):\n self.cursor.execute('''\n CREATE TABLE IF NOT EXISTS tickets (\n id INTEGER PRIMARY KEY,\n movie_name TEXT,\n theater_name TEXT,\n seat_number TEXT,\n customer_name TEXT\n )\n ''')\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "insert_ticket", "method_description": "def insert_ticket(self, movie_name, theater_name, seat_number, customer_name):\n \"\"\"\n Inserts a new ticket into the \"tickets\" table.\n :param movie_name: str, the name of the movie.\n :param theater_name: str, the name of the theater.\n :param seat_number: str, the seat number.\n :param customer_name: str, the name of the customer.\n :return: None\n \"\"\"", "test_class": "MovieTicketDBTestSearchTicketsByCustomer", "test_code": "class MovieTicketDBTestSearchTicketsByCustomer(unittest.TestCase):\n def setUp(self):\n self.db_name = 'test_database.db'\n self.db = MovieTicketDB(self.db_name)\n\n def tearDown(self):\n self.db.connection.close()\n os.remove(self.db_name)\n\n def test_search_tickets_by_customer_1(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'John Doe')\n tickets = self.db.search_tickets_by_customer('John Doe')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'John Doe')\n\n def test_search_tickets_by_customer_2(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'aaa')\n tickets = self.db.search_tickets_by_customer('aaa')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'aaa')\n\n def test_search_tickets_by_customer_3(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'bbb')\n tickets = self.db.search_tickets_by_customer('bbb')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'bbb')\n\n def test_search_tickets_by_customer_4(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'ccc')\n tickets = self.db.search_tickets_by_customer('ccc')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'ccc')\n\n def test_search_tickets_by_customer_5(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'ddd')\n tickets = self.db.search_tickets_by_customer('ddd')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'ddd')", "solution_code": "def insert_ticket(self, movie_name, theater_name, seat_number, customer_name):\n self.cursor.execute('''\n INSERT INTO tickets (movie_name, theater_name, seat_number, customer_name)\n VALUES (?, ?, ?, ?)\n ''', (movie_name, theater_name, seat_number, customer_name))\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "search_tickets_by_customer", "method_description": "def search_tickets_by_customer(self, customer_name):\n \"\"\"\n Searches for tickets in the \"tickets\" table by customer name.\n :param customer_name: str, the name of the customer to search for.\n :return: list of tuples, the rows from the \"tickets\" table that match the search criteria.\n >>> ticket_db = MovieTicketDB(\"ticket_database.db\")\n >>> ticket_db.create_table()\n >>> ticket_db.insert_ticket(\"Movie A\", \"Theater 1\", \"A1\", \"John Doe\")\n >>> result = ticket_db.search_tickets_by_customer(\"John Doe\")\n len(result) = 1\n \"\"\"", "test_class": "MovieTicketDBTestDeleteTicket", "test_code": "class MovieTicketDBTestDeleteTicket(unittest.TestCase):\n def setUp(self):\n self.db_name = 'test_database.db'\n self.db = MovieTicketDB(self.db_name)\n\n def tearDown(self):\n self.db.connection.close()\n os.remove(self.db_name)\n\n def test_delete_ticket_1(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'John Doe')\n tickets = self.db.search_tickets_by_customer('John Doe')\n self.assertEqual(len(tickets), 1)\n ticket_id = tickets[0][0]\n self.db.delete_ticket(ticket_id)\n tickets = self.db.search_tickets_by_customer('John Doe')\n self.assertEqual(len(tickets), 0)\n\n def test_delete_ticket_2(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'aaa')\n tickets = self.db.search_tickets_by_customer('aaa')\n self.assertEqual(len(tickets), 1)\n ticket_id = tickets[0][0]\n self.db.delete_ticket(ticket_id)\n tickets = self.db.search_tickets_by_customer('aaa')\n self.assertEqual(len(tickets), 0)\n\n def test_delete_ticket_3(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'bbb')\n tickets = self.db.search_tickets_by_customer('bbb')\n self.assertEqual(len(tickets), 1)\n ticket_id = tickets[0][0]\n self.db.delete_ticket(ticket_id)\n tickets = self.db.search_tickets_by_customer('bbb')\n self.assertEqual(len(tickets), 0)\n\n def test_delete_ticket_4(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'ccc')\n tickets = self.db.search_tickets_by_customer('ccc')\n self.assertEqual(len(tickets), 1)\n ticket_id = tickets[0][0]\n self.db.delete_ticket(ticket_id)\n tickets = self.db.search_tickets_by_customer('ccc')\n self.assertEqual(len(tickets), 0)\n\n def test_delete_ticket_5(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'ddd')\n tickets = self.db.search_tickets_by_customer('ddd')\n self.assertEqual(len(tickets), 1)\n ticket_id = tickets[0][0]\n self.db.delete_ticket(ticket_id)\n tickets = self.db.search_tickets_by_customer('ddd')\n self.assertEqual(len(tickets), 0)", "solution_code": "def search_tickets_by_customer(self, customer_name):\n self.cursor.execute('''\n SELECT * FROM tickets WHERE customer_name = ?\n ''', (customer_name,))\n tickets = self.cursor.fetchall()\n return tickets", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.cursor" ], "method_dependencies": [] } }, { "method_name": "delete_ticket", "method_description": "def delete_ticket(self, ticket_id):\n \"\"\"\n Deletes a ticket from the \"tickets\" table by ticket ID.\n :param ticket_id: int, the ID of the ticket to delete.\n :return: None\n \"\"\"", "test_class": "MovieTicketDBTest", "test_code": "class MovieTicketDBTest(unittest.TestCase):\n def setUp(self):\n self.db_name = 'test_database.db'\n self.db = MovieTicketDB(self.db_name)\n\n def tearDown(self):\n self.db.connection.close()\n os.remove(self.db_name)\n\n def test_MovieTicketDB(self):\n self.db.insert_ticket('Avengers: Endgame', 'Cinema 1', 'A1', 'John Doe')\n tickets = self.db.search_tickets_by_customer('John Doe')\n self.assertEqual(len(tickets), 1)\n ticket = tickets[0]\n self.assertEqual(ticket[1], 'Avengers: Endgame')\n self.assertEqual(ticket[2], 'Cinema 1')\n self.assertEqual(ticket[3], 'A1')\n self.assertEqual(ticket[4], 'John Doe')\n ticket_id = tickets[0][0]\n self.db.delete_ticket(ticket_id)\n tickets = self.db.search_tickets_by_customer('John Doe')\n self.assertEqual(len(tickets), 0)", "solution_code": "def delete_ticket(self, ticket_id):\n self.cursor.execute('''\n DELETE FROM tickets WHERE id = ?\n ''', (ticket_id,))\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } } ]

[ "MovieTicketDBTestInsertTicket", "MovieTicketDBTestSearchTicketsByCustomer", "MovieTicketDBTestDeleteTicket", "MovieTicketDBTest" ]

[ "self.connection", "self.cursor" ]

[ "import random" ]

[ { "method_name": "add_song", "method_description": "def add_song(self, song):\n \"\"\"\n Adds a song to the playlist.\n :param song: The song to add to the playlist, str.\n >>> musicPlayer = MusicPlayer()\n >>> musicPlayer.add_song(\"song1\")\n >>> musicPlayer.playlist\n ['song1']\n\n \"\"\"", "test_class": "MusicPlayerTestAddSong", "test_code": "class MusicPlayerTestAddSong(unittest.TestCase):\n def test_add_song(self):\n musicPlayer = MusicPlayer()\n musicPlayer.add_song(\"song1\")\n self.assertEqual(musicPlayer.playlist, [\"song1\"])\n\n def test_add_song2(self):\n musicPlayer = MusicPlayer()\n musicPlayer.add_song(\"song1\")\n musicPlayer.add_song(\"song2\")\n self.assertEqual(musicPlayer.playlist, [\"song1\", \"song2\"])\n\n def test_add_song3(self):\n musicPlayer = MusicPlayer()\n musicPlayer.add_song(\"song1\")\n musicPlayer.add_song(\"song2\")\n musicPlayer.add_song(\"song3\")\n self.assertEqual(musicPlayer.playlist, [\"song1\", \"song2\", \"song3\"])\n\n def test_add_song4(self):\n musicPlayer = MusicPlayer()\n musicPlayer.add_song(\"song1\")\n musicPlayer.add_song(\"song2\")\n musicPlayer.add_song(\"song3\")\n musicPlayer.add_song(\"song4\")\n self.assertEqual(musicPlayer.playlist, [\"song1\", \"song2\", \"song3\", \"song4\"])\n\n def test_add_song5(self):\n musicPlayer = MusicPlayer()\n musicPlayer.add_song(\"song1\")\n musicPlayer.add_song(\"song2\")\n musicPlayer.add_song(\"song3\")\n musicPlayer.add_song(\"song4\")\n musicPlayer.add_song(\"song5\")\n self.assertEqual(musicPlayer.playlist, [\"song1\", \"song2\", \"song3\", \"song4\", \"song5\"])", "solution_code": "def add_song(self, song):\n self.playlist.append(song)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.playlist" ], "method_dependencies": [ "play" ] } }, { "method_name": "remove_song", "method_description": "def remove_song(self, song):\n \"\"\"\n Removes a song from the playlist.\n :param song: The song to remove from the playlist, str.\n >>> musicPlayer = MusicPlayer()\n >>> musicPlayer.playlist = [\"song1\", \"song2\"]\n >>> musicPlayer.remove_song(\"song1\")\n >>> musicPlayer.playlist\n ['song2']\n\n \"\"\"", "test_class": "MusicPlayerTestRemoveSong", "test_code": "class MusicPlayerTestRemoveSong(unittest.TestCase):\n def test_remove_song(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.remove_song(\"song1\")\n self.assertEqual(musicPlayer.playlist, [\"song2\"])\n\n def test_remove_song2(self):\n musicPlayer = MusicPlayer()\n musicPlayer.current_song = \"song1\"\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\"]\n musicPlayer.remove_song(\"song1\")\n self.assertEqual(musicPlayer.playlist, [\"song2\", \"song3\"])\n\n def test_remove_song3(self):\n musicPlayer = MusicPlayer()\n musicPlayer.current_song = \"song1\"\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\", \"song4\"]\n musicPlayer.remove_song(\"song1\")\n self.assertEqual(musicPlayer.playlist, [\"song2\", \"song3\", \"song4\"])\n\n def test_remove_song4(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\", \"song4\", \"song5\"]\n musicPlayer.remove_song(\"song1\")\n self.assertEqual(musicPlayer.playlist, [\"song2\", \"song3\", \"song4\", \"song5\"])\n\n def test_remove_song5(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\", \"song4\", \"song5\"]\n musicPlayer.remove_song(\"song1\")\n musicPlayer.remove_song(\"song2\")\n self.assertEqual(musicPlayer.playlist, [\"song3\", \"song4\", \"song5\"])\n\n def test_remove_song6(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = []\n musicPlayer.remove_song(\"song1\")\n self.assertEqual(musicPlayer.playlist, [])", "solution_code": "def remove_song(self, song):\n if song in self.playlist:\n self.playlist.remove(song)\n if self.current_song == song:\n self.stop()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.current_song", "self.playlist" ], "method_dependencies": [ "play", "stop" ] } }, { "method_name": "play", "method_description": "def play(self):\n \"\"\"\n Plays the current song in the playlist.\n :return: The current song in the playlist, or False if there is no current song.\n >>> musicPlayer = MusicPlayer()\n >>> musicPlayer.playlist = [\"song1\", \"song2\"]\n >>> musicPlayer.current_song = \"song1\"\n >>> musicPlayer.play()\n 'song1'\n\n \"\"\"", "test_class": "MusicPlayerTestPlay", "test_code": "class MusicPlayerTestPlay(unittest.TestCase):\n def test_play(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.play(), \"song1\")\n\n def test_play_2(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = []\n musicPlayer.current_song = \"song2\"\n self.assertEqual(musicPlayer.play(), None)\n\n def test_play_3(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n self.assertEqual(musicPlayer.play(),False)\n\n def test_play_4(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song3\"\n self.assertEqual(musicPlayer.play(), \"song1\")\n\n def test_play_5(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.play(), \"song1\")", "solution_code": "def play(self):\n if self.playlist and self.current_song:\n return self.playlist[0]\n elif len(self.playlist): \n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.current_song", "self.playlist" ], "method_dependencies": [] } }, { "method_name": "stop", "method_description": "def stop(self):\n \"\"\"\n Stops the current song in the playlist.\n :return: True if the current song was stopped, False if there was no current song.\n >>> musicPlayer = MusicPlayer()\n >>> musicPlayer.playlist = [\"song1\", \"song2\"]\n >>> musicPlayer.current_song = \"song1\"\n >>> musicPlayer.stop()\n True\n\n \"\"\"", "test_class": "MusicPlayerTestStop", "test_code": "class MusicPlayerTestStop(unittest.TestCase):\n def test_stop(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.stop(), True)\n\n def test_stop_2(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = []\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.stop(), True)\n\n def test_stop_3(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n self.assertEqual(musicPlayer.stop(), False)\n\n def test_stop_4(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.stop(), True)\n\n def test_stop_5(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song2\"\n self.assertEqual(musicPlayer.stop(), True)", "solution_code": "def stop(self):\n if self.current_song:\n self.current_song = None\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.current_song" ], "method_dependencies": [] } }, { "method_name": "switch_song", "method_description": "def switch_song(self):\n \"\"\"\n Switches to the next song in the playlist.\n :return: True if the next song was switched to, False if there was no next song.\n >>> musicPlayer = MusicPlayer()\n >>> musicPlayer.playlist = [\"song1\", \"song2\"]\n >>> musicPlayer.current_song = \"song1\"\n >>> musicPlayer.switch_song()\n True\n\n \"\"\"", "test_class": "MusicPlayerTestSwitchSong", "test_code": "class MusicPlayerTestSwitchSong(unittest.TestCase):\n def test_switch_song(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.switch_song(), True)\n\n def test_switch_song2(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song2\"\n self.assertEqual(musicPlayer.switch_song(), False)\n\n def test_switch_song3(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\"]\n musicPlayer.current_song = \"song3\"\n self.assertEqual(musicPlayer.switch_song(), False)\n\n def test_switch_song4(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n self.assertEqual(musicPlayer.switch_song(), False)\n\n def test_switch_song5(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = []\n self.assertEqual(musicPlayer.switch_song(), False)", "solution_code": "def switch_song(self):\n if self.current_song:\n current_index = self.playlist.index(self.current_song)\n if current_index < len(self.playlist) - 1:\n self.current_song = self.playlist[current_index + 1]\n return True\n else:\n return False\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.current_song", "self.playlist" ], "method_dependencies": [ "play" ] } }, { "method_name": "previous_song", "method_description": "def previous_song(self):\n \"\"\"\n Switches to the previous song in the playlist.\n :return: True if the previous song was switched to, False if there was no previous song.\n >>> musicPlayer = MusicPlayer()\n >>> musicPlayer.playlist = [\"song1\", \"song2\"]\n >>> musicPlayer.current_song = \"song2\"\n >>> musicPlayer.previous_song()\n True\n\n \"\"\"", "test_class": "MusicPlayerTestPreviousSong", "test_code": "class MusicPlayerTestPreviousSong(unittest.TestCase):\n def test_previous_song(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\"]\n musicPlayer.current_song = \"song2\"\n self.assertEqual(musicPlayer.previous_song(), True)\n\n def test_previous_song2(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\"]\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.previous_song(), False)\n\n def test_previous_song3(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\"]\n musicPlayer.current_song = \"song3\"\n self.assertEqual(musicPlayer.previous_song(), True)\n\n def test_previous_song4(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\", \"song3\"]\n self.assertEqual(musicPlayer.previous_song(), False)\n\n def test_previous_song5(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = []\n self.assertEqual(musicPlayer.previous_song(), False)", "solution_code": "def previous_song(self):\n if self.current_song:\n current_index = self.playlist.index(self.current_song)\n if current_index > 0:\n self.current_song = self.playlist[current_index - 1]\n return True\n else:\n return False\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.current_song", "self.playlist" ], "method_dependencies": [ "play" ] } }, { "method_name": "set_volume", "method_description": "def set_volume(self, volume):\n \"\"\"\n Sets the volume of the music player,ifthe volume is between 0 and 100 is valid.\n :param volume: The volume to set the music player to,int.\n :return: True if the volume was set, False if the volume was invalid.\n >>> musicPlayer = MusicPlayer()\n >>> musicPlayer.set_volume(50)\n >>> musicPlayer.volume\n 50\n\n \"\"\"", "test_class": "MusicPlayerTestSetVolume", "test_code": "class MusicPlayerTestSetVolume(unittest.TestCase):\n def test_set_volume(self):\n musicPlayer = MusicPlayer()\n self.assertEqual(musicPlayer.set_volume(50), None)\n self.assertEqual(musicPlayer.volume, 50)\n\n def test_set_volume2(self):\n musicPlayer = MusicPlayer()\n self.assertEqual(musicPlayer.set_volume(100), None)\n self.assertEqual(musicPlayer.volume, 100)\n\n def test_set_volume3(self):\n musicPlayer = MusicPlayer()\n self.assertEqual(musicPlayer.set_volume(0), None)\n self.assertEqual(musicPlayer.volume, 0)\n\n def test_set_volume4(self):\n musicPlayer = MusicPlayer()\n self.assertEqual(musicPlayer.set_volume(101), False)\n self.assertEqual(musicPlayer.volume, 50)\n\n def test_set_volume5(self):\n musicPlayer = MusicPlayer()\n self.assertEqual(musicPlayer.set_volume(-1), False)\n self.assertEqual(musicPlayer.volume, 50)", "solution_code": "def set_volume(self, volume):\n if 0 <= volume <= 100:\n self.volume = volume\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.volume" ], "method_dependencies": [] } }, { "method_name": "shuffle", "method_description": "def shuffle(self):\n \"\"\"\n Shuffles the playlist.\n :return: True if the playlist was shuffled, False if the playlist was empty.\n >>> musicPlayer = MusicPlayer()\n >>> musicPlayer.playlist = [\"song1\", \"song2\"]\n >>> musicPlayer.shuffle()\n True\n\n \"\"\"", "test_class": "MusicPlayerTestShuffle", "test_code": "class MusicPlayerTestShuffle(unittest.TestCase):\n def test_shuffle(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n self.assertEqual(musicPlayer.shuffle(), True)\n\n def test_shuffle_2(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = []\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.shuffle(), False)\n\n def test_shuffle_3(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song2\"\n self.assertEqual(musicPlayer.shuffle(), True)\n\n def test_shuffle_4(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song3\"\n self.assertEqual(musicPlayer.shuffle(), True)\n\n def test_shuffle_5(self):\n musicPlayer = MusicPlayer()\n musicPlayer.playlist = [\"song1\", \"song2\"]\n musicPlayer.current_song = \"song1\"\n self.assertEqual(musicPlayer.shuffle(), True)", "solution_code": "def shuffle(self):\n if self.playlist:\n import random\n random.shuffle(self.playlist)\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "random" ], "field_dependencies": [ "self.playlist" ], "method_dependencies": [ "play" ] } } ]

[ "MusicPlayerTestAddSong", "MusicPlayerTestRemoveSong", "MusicPlayerTestPlay", "MusicPlayerTestStop", "MusicPlayerTestSwitchSong", "MusicPlayerTestPreviousSong", "MusicPlayerTestSetVolume", "MusicPlayerTestShuffle", "MusicPlayerTestMain" ]

[ "self.current_song", "self.playlist", "self.volume" ]

[]

[ { "method_name": "construct_stop_word_list", "method_description": "def construct_stop_word_list(self):\n \"\"\"\n Construct a stop word list including 'a', 'an', 'the'.\n :return: a list of stop words\n >>> NLPDataProcessor.construct_stop_word_list()\n ['a', 'an', 'the']\n \"\"\"", "test_class": "NLPDataProcessorTestConstruct", "test_code": "class NLPDataProcessorTestConstruct(unittest.TestCase):\n def setUp(self):\n self.processor = NLPDataProcessor()\n\n def test_construct_stop_word_list(self):\n stop_word_list = self.processor.construct_stop_word_list()\n expected_stop_words = ['a', 'an', 'the']\n self.assertEqual(stop_word_list, expected_stop_words)", "solution_code": "def construct_stop_word_list(self):\n stop_word_list = ['a', 'an', 'the']\n return stop_word_list", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "remove_stop_words", "method_description": "def remove_stop_words(self, string_list, stop_word_list):\n \"\"\"\n Remove all the stop words from the list of strings.\n :param string_list: a list of strings\n :param stop_word_list: a list of stop words\n :return: a list of words without stop words\n >>> NLPDataProcessor.process(['This is a test.'])\n [['This', 'is', 'test.']]\n \"\"\"", "test_class": "NLPDataProcessorTestRemove", "test_code": "class NLPDataProcessorTestRemove(unittest.TestCase):\n def setUp(self):\n self.processor = NLPDataProcessor()\n\n def test_remove_stop_words(self):\n string_list = ['This is a test', 'This is an apple', 'This is the dog']\n stop_word_list = ['a', 'an', 'the']\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n expected_words_list = [['This', 'is', 'test'], ['This', 'is', 'apple'], ['This', 'is', 'dog']]\n self.assertEqual(words_list, expected_words_list)\n\n def test_remove_stop_words_2(self):\n string_list = ['a', 'an', 'the']\n stop_word_list = ['a', 'an', 'the']\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n self.assertEqual(words_list, [[], [], []])\n\n def test_remove_stop_words_3(self):\n string_list = []\n stop_word_list = ['a', 'an', 'the']\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n self.assertEqual(words_list, [])\n\n def test_remove_stop_words_4(self):\n string_list = ['This is a test', 'This is an apple', 'This is the dog']\n stop_word_list = []\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n expected_words_list = [['This', 'is', 'a', 'test'], ['This', 'is', 'an', 'apple'], ['This', 'is', 'the', 'dog']]\n self.assertEqual(words_list, expected_words_list)\n\n def test_remove_stop_words_5(self):\n string_list = ['This is a test', 'This is an apple', 'This is the dog']\n stop_word_list = ['a', 'an', 'the', 'This', 'is']\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n expected_words_list = [['is', 'test'], ['is', 'apple'], ['is', 'dog']]\n self.assertEqual(words_list, expected_words_list)", "solution_code": "def remove_stop_words(self, string_list, stop_word_list):\n answer = []\n for string in string_list:\n string_split = string.split()\n for word in string_split:\n if word in stop_word_list:\n string_split.remove(word)\n answer.append(string_split)\n return answer", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "process", "method_description": "def process(self, string_list):\n \"\"\"\n Construct a stop word list including 'a', 'an', 'the', and remove all the stop words from the list of strings.\n :param string_list: a list of strings\n :return: a list of words without stop words\n >>> NLPDataProcessor.process(['This is a test.'])\n [['This', 'is', 'test.']]\n \"\"\"", "test_class": "NLPDataProcessorTestProcess", "test_code": "class NLPDataProcessorTestProcess(unittest.TestCase):\n def setUp(self):\n self.processor = NLPDataProcessor()\n\n def test_process(self):\n string_list = ['This is a test.', 'This is an apple.', 'This is the dog.']\n words_list = self.processor.process(string_list)\n expected_words_list = [['This', 'is', 'test.'], ['This', 'is', 'apple.'], ['This', 'is', 'dog.']]\n self.assertEqual(words_list, expected_words_list)\n\n def test_process_with_empty_string_list(self):\n string_list = []\n words_list = self.processor.process(string_list)\n self.assertEqual(words_list, [])\n\n def test_process_with_single_word_sentences(self):\n string_list = ['Hello aa', 'World']\n words_list = self.processor.process(string_list)\n expected_words_list = [['Hello', 'aa'], ['World']]\n self.assertEqual(words_list, expected_words_list)\n\n def test_process_with_stop_words_only(self):\n string_list = ['a', 'an', 'the']\n words_list = self.processor.process(string_list)\n self.assertEqual(words_list, [[], [], []])\n\n def test_process_with_stop_words_only_2(self):\n string_list = ['a', 'an', 'the','This']\n words_list = self.processor.process(string_list)\n self.assertEqual(words_list,[[], [], [], ['This']])", "solution_code": "def process(self, string_list):\n stop_word_list = self.construct_stop_word_list()\n words_list = self.remove_stop_words(string_list, stop_word_list)\n return words_list", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "construct_stop_word_list", "remove_stop_words" ] } } ]

[ "NLPDataProcessorTestConstruct", "NLPDataProcessorTestRemove", "NLPDataProcessorTestProcess" ]

[]

[ "from collections import Counter", "import re" ]

[ { "method_name": "process_data", "method_description": "def process_data(self, string_list):\n \"\"\"\n keep only English letters and spaces in the string, then convert the string to lower case, and then split the string into a list of words.\n :param string_list: a list of strings\n :return: words_list: a list of words lists\n >>> NLPDataProcessor.process_data(['This is a test.'])\n [['this', 'is', 'a', 'test']]\n \"\"\"", "test_class": "NLPDataProcessorTestProcessData", "test_code": "class NLPDataProcessorTestProcessData(unittest.TestCase):\n\n def setUp(self):\n self.processor = NLPDataProcessor2()\n\n def test_process_data(self):\n string_list = [\"Hello World!\", \"This is a test.\"]\n expected_output = [['hello', 'world'], ['this', 'is', 'a', 'test']]\n self.assertEqual(self.processor.process_data(string_list), expected_output)\n\n def test_process_data2(self):\n string_list = [\"12345\", \"Special@Characters\"]\n expected_output = [[], ['specialcharacters']]\n self.assertEqual(self.processor.process_data(string_list), expected_output)\n\n def test_process_data3(self):\n string_list = []\n expected_output = []\n self.assertEqual(self.processor.process_data(string_list), expected_output)\n\n def test_process_data4(self):\n string_list = [\"Hello World!\", \"This is a test.\", \"12345\", \"Special@Characters\"]\n expected_output = [['hello', 'world'], ['this', 'is', 'a', 'test'], [], ['specialcharacters']]\n self.assertEqual(self.processor.process_data(string_list), expected_output)\n\n def test_process_data5(self):\n string_list = [\"Hello World!\", \"This is a test.\", \"12345\", \"Special@Characters\", \"Hello World!\", \"This is a test.\", \"12345\", \"Special@Characters\"]\n expected_output = [['hello', 'world'], ['this', 'is', 'a', 'test'], [], ['specialcharacters'], ['hello', 'world'], ['this', 'is', 'a', 'test'], [], ['specialcharacters']]\n self.assertEqual(self.processor.process_data(string_list), expected_output)", "solution_code": "def process_data(self, string_list):\n words_list = []\n for string in string_list:\n # Remove non-English letters and convert to lowercase\n processed_string = re.sub(r'[^a-zA-Z\\s]', '', string.lower())\n # Split the string into words\n words = processed_string.split()\n words_list.append(words)\n return words_list", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [ "process" ] } }, { "method_name": "calculate_word_frequency", "method_description": "def calculate_word_frequency(self, words_list):\n \"\"\"\n Calculate the word frequency of each word in the list of words list, and sort the word frequency dictionary by value in descending order.\n :param words_list: a list of words lists\n :return: top 5 word frequency dictionary, a dictionary of word frequency, key is word, value is frequency\n >>> NLPDataProcessor.calculate_word_frequency([['this', 'is', 'a', 'test'], ['this', 'is', 'another', 'test']])\n {'this': 2, 'is': 2, 'test': 2, 'a': 1, 'another': 1}\n \"\"\"", "test_class": "NLPDataProcessorTestCalculate", "test_code": "class NLPDataProcessorTestCalculate(unittest.TestCase):\n\n def setUp(self):\n self.processor = NLPDataProcessor2()\n\n def test_calculate_word_frequency(self):\n words_list = [['hello', 'world'], ['this', 'is', 'a', 'test'], ['hello', 'world', 'this', 'is', 'another', 'test'],\n ['hello', 'hello', 'world']]\n expected_output = {'hello': 4, 'world': 3, 'this': 2, 'is': 2, 'test': 2}\n self.assertEqual(self.processor.calculate_word_frequency(words_list), expected_output)\n\n def test_calculate_word_frequency2(self):\n words_list = [['hello', 'world'], ['this', 'is', 'a', 'test'], ['hello', 'world', 'this', 'is', 'another', 'test'],\n ['hello', 'hello', 'world'], ['world', 'world', 'world']]\n expected_output = {'world': 6, 'hello': 4, 'this': 2, 'is': 2, 'test': 2}\n self.assertEqual(self.processor.calculate_word_frequency(words_list), expected_output)\n\n def test_calculate_word_frequency3(self):\n words_list = [['hello', 'world'], ['hello', 'hello', 'world'], ['world', 'world']]\n expected_output = {'world': 4, 'hello': 3}\n self.assertEqual(self.processor.calculate_word_frequency(words_list), expected_output)\n\n def test_calculate_word_frequency4(self):\n words_list = [['hello', 'world'], ['this', 'is', 'a', '%%%'], ['hello', 'world', 'this', 'is', 'another', '%%%'],\n ['hello', 'hello', 'world'], ['%%%', 'world', 'a', '%%%'], ['%%%', 'hello', '%%%']]\n expected_output = {'%%%': 6, 'hello': 5, 'world': 4, 'is': 2, 'this': 2}\n self.assertEqual(self.processor.calculate_word_frequency(words_list), expected_output)\n\n def test_calculate_word_frequency5(self):\n words_list = [['hello', 'world'], ['this', 'is', 'a', '%%%'], ['hello', 'world', 'this', 'is', 'another', '%%%'],\n ['hello', 'hello', 'world'], ['%%%', 'world', 'a', '%%%'], ['%%%', 'hello', '%%%'], ['hello', 'world'], ['this', 'is', 'a', '%%%'], ['hello', 'world', 'this', 'is', 'another', '%%%'],\n ['hello', 'hello', 'world'], ['%%%', 'world', 'a', '%%%'], ['%%%', 'hello', '%%%']]\n expected_output = {'%%%': 12, 'hello': 10, 'world': 8, 'is': 4, 'this': 4}\n self.assertEqual(self.processor.calculate_word_frequency(words_list), expected_output)", "solution_code": "def calculate_word_frequency(self, words_list):\n word_frequency = Counter()\n for words in words_list:\n word_frequency.update(words)\n sorted_word_frequency = dict(sorted(word_frequency.items(), key=lambda x: x[1], reverse=True))\n top_5_word_frequency = dict(list(sorted_word_frequency.items())[:5])\n return top_5_word_frequency", "dependencies": { "Standalone": false, "lib_dependencies": [ "Counter" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "process", "method_description": "def process(self, string_list):\n \"\"\"\n keep only English letters and spaces in the string, then convert the string to lower case, and then split the string into a list of words. Calculate the word frequency of each word in the list of words list, and sort the word frequency dictionary by value in descending order.\n :param string_list: a list of strings\n :return: top 5 word frequency dictionary, a dictionary of word frequency, key is word, value is frequency\n >>> NLPDataProcessor.process(['This is a test.', 'This is another test.'])\n {'this': 2, 'is': 2, 'test': 2, 'a': 1, 'another': 1}\n \"\"\"", "test_class": "NLPDataProcessorTestProcess", "test_code": "class NLPDataProcessorTestProcess(unittest.TestCase):\n\n def setUp(self):\n self.processor = NLPDataProcessor2()\n\n def test_process(self):\n string_list = [\"Hello World!\", \"This is a test.\", \"Hello World, this is a test.\"]\n expected_output = {'hello': 2, 'world': 2, 'this': 2, 'is': 2, 'a': 2}\n self.assertEqual(self.processor.process(string_list), expected_output)\n\n def test_process2(self):\n string_list = []\n expected_output = []\n self.assertEqual(self.processor.process_data(string_list), expected_output)\n\n def test_calculate3(self):\n words_list = []\n expected_output = {}\n self.assertEqual(self.processor.calculate_word_frequency(words_list), expected_output)\n\n def test_process4(self):\n string_list = [\"@#$%^&*\", \"Special_Characters\", \"12345\"]\n expected_output = [[], ['specialcharacters'], []]\n self.assertEqual(self.processor.process_data(string_list), expected_output)\n\n def test_process5(self):\n string_list = [\"Hello World! %%%\", \"This is a %%% test. %%% \", \"Hello World, this is a test. %%%\"]\n expected_output = {'hello': 2, 'world': 2, 'this': 2, 'is': 2, 'a': 2}\n self.assertEqual(self.processor.process(string_list), expected_output)\n\n def test_process6(self):\n string_list = [\"12345\", \"67890\", \"98765\"]\n expected_output = [[], [], []]\n self.assertEqual(self.processor.process_data(string_list), expected_output)", "solution_code": "def process(self, string_list):\n words_list = self.process_data(string_list)\n word_frequency_dict = self.calculate_word_frequency(words_list)\n return word_frequency_dict", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "process_data", "calculate_word_frequency" ] } } ]

[ "NLPDataProcessorTestProcessData", "NLPDataProcessorTestCalculate", "NLPDataProcessorTestProcess" ]

[]

[]

[ { "method_name": "decimal_to_binary", "method_description": "def decimal_to_binary(decimal_num):\n \"\"\"\n Convert a number from decimal format to binary format.\n :param decimal_num: int, decimal number\n :return: str, the binary representation of an integer.\n >>> NumberConverter.decimal_to_binary(42423)\n '1010010110110111'\n \"\"\"", "test_class": "NumberConverterTestDecimalToBinary", "test_code": "class NumberConverterTestDecimalToBinary(unittest.TestCase):\n def test_decimal_to_binary(self):\n self.assertEqual('1010010110110111', NumberConverter.decimal_to_binary(42423))\n\n def test_decimal_to_binary_2(self):\n self.assertEqual('101001100010111', NumberConverter.decimal_to_binary(21271))\n\n def test_decimal_to_binary_3(self):\n self.assertEqual('1010010111010111', NumberConverter.decimal_to_binary(42455))\n\n def test_decimal_to_binary_4(self):\n self.assertEqual('10100101110101011', NumberConverter.decimal_to_binary(84907))\n\n def test_decimal_to_binary_5(self):\n self.assertEqual('101001011101010111', NumberConverter.decimal_to_binary(169815))", "solution_code": "def decimal_to_binary(decimal_num):\n binary_num = bin(decimal_num)[2:]\n return binary_num", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "binary_to_decimal", "method_description": "@staticmethod\n def binary_to_decimal(binary_num):\n \"\"\"\n Convert a number from binary format to decimal format.\n :param binary_num: str, binary number\n :return: int, the decimal representation of binary number str.\n >>> NumberConverter.binary_to_decimal('1010010110110111')\n 42423\n \"\"\"", "test_class": "NumberConverterTestBinaryToDecimal", "test_code": "class NumberConverterTestBinaryToDecimal(unittest.TestCase):\n def test_binary_to_decimal(self):\n self.assertEqual(42423, NumberConverter.binary_to_decimal('1010010110110111'))\n\n def test_binary_to_decimal_2(self):\n self.assertEqual(10615, NumberConverter.binary_to_decimal('10100101110111'))\n\n def test_binary_to_decimal_3(self):\n self.assertEqual(42455, NumberConverter.binary_to_decimal('1010010111010111'))\n\n def test_binary_to_decimal_4(self):\n self.assertEqual(169819, NumberConverter.binary_to_decimal('101001011101011011'))\n\n def test_binary_to_decimal_5(self):\n self.assertEqual(339639, NumberConverter.binary_to_decimal('1010010111010110111'))", "solution_code": "@staticmethod\n def binary_to_decimal(binary_num):\n decimal_num = int(binary_num, 2)\n return decimal_num", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "decimal_to_octal", "method_description": "@staticmethod\n def decimal_to_octal(decimal_num):\n \"\"\"\n Convert a number from decimal format to octal format.\n :param decimal_num: int, decimal number\n :return: str, the octal representation of an integer.\n >>> NumberConverter.decimal_to_octal(42423)\n '122667'\n \"\"\"", "test_class": "NumberConvertTestDecimalToOctal", "test_code": "class NumberConvertTestDecimalToOctal(unittest.TestCase):\n def test_decimal_to_octal(self):\n self.assertEqual('122667', NumberConverter.decimal_to_octal(42423))\n\n def test_decimal_to_octal_2(self):\n self.assertEqual('51427', NumberConverter.decimal_to_octal(21271))\n\n def test_decimal_to_octal_3(self):\n self.assertEqual('245653', NumberConverter.decimal_to_octal(84907))\n\n def test_decimal_to_octal_4(self):\n self.assertEqual('513527', NumberConverter.decimal_to_octal(169815))\n\n def test_decimal_to_octal_5(self):\n self.assertEqual('1227256', NumberConverter.decimal_to_octal(339630))", "solution_code": "@staticmethod\n def decimal_to_octal(decimal_num):\n octal_num = oct(decimal_num)[2:]\n return octal_num", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "octal_to_decimal", "method_description": "@staticmethod\n def octal_to_decimal(octal_num):\n \"\"\"\n Convert a number from octal format to decimal format.\n :param octal_num: str, octal num\n :return: int, the decimal representation of octal number str.\n >>> NumberConverter.octal_to_decimal('122667')\n 42423\n \"\"\"", "test_class": "NumberConvertTestOctalToDecimal", "test_code": "class NumberConvertTestOctalToDecimal(unittest.TestCase):\n def test_octal_to_decimal(self):\n self.assertEqual(42423, NumberConverter.octal_to_decimal('122667'))\n\n def test_octal_to_decimal_2(self):\n self.assertEqual(21271, NumberConverter.octal_to_decimal('51427'))\n\n def test_octal_to_decimal_3(self):\n self.assertEqual(84907, NumberConverter.octal_to_decimal('245653'))\n\n def test_octal_to_decimal_4(self):\n self.assertEqual(169815, NumberConverter.octal_to_decimal('513527'))\n\n def test_octal_to_decimal_5(self):\n self.assertEqual(339630, NumberConverter.octal_to_decimal('1227256'))", "solution_code": "@staticmethod\n def octal_to_decimal(octal_num):\n decimal_num = int(octal_num, 8)\n return decimal_num", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "decimal_to_hex", "method_description": "@staticmethod\n def decimal_to_hex(decimal_num):\n \"\"\"\n Convert a number from decimal format to hex format.\n :param decimal_num: int, decimal number\n :return hex_num: str, the hex representation of an integer.\n >>> NumberConverter.decimal_to_hex(42423)\n 'a5b7'\n \"\"\"", "test_class": "NumberConvertTestDecimalToHex", "test_code": "class NumberConvertTestDecimalToHex(unittest.TestCase):\n def test_decimal_to_hex(self):\n self.assertEqual('a5b7', NumberConverter.decimal_to_hex(42423))\n\n def test_decimal_to_hex_2(self):\n self.assertEqual('5317', NumberConverter.decimal_to_hex(21271))\n\n def test_decimal_to_hex_3(self):\n self.assertEqual('14bab', NumberConverter.decimal_to_hex(84907))\n\n def test_decimal_to_hex_4(self):\n self.assertEqual('29757', NumberConverter.decimal_to_hex(169815))\n\n def test_decimal_to_hex_5(self):\n self.assertEqual('52eb7', NumberConverter.decimal_to_hex(339639))", "solution_code": "@staticmethod\n def decimal_to_hex(decimal_num):\n hex_num = hex(decimal_num)[2:]\n return hex_num", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "hex_to_decimal", "method_description": "@staticmethod\n def hex_to_decimal(hex_num):\n \"\"\"\n Convert a number from hex format to decimal format.\n :param hex_num: str, hex num\n :return: int, the decimal representation of hex number str.\n >>> NumberConverter.hex_to_decimal('a5b7')\n 42423\n \"\"\"", "test_class": "NumberConvertTestHexToDecimal", "test_code": "class NumberConvertTestHexToDecimal(unittest.TestCase):\n def test_hex_to_decimal(self):\n self.assertEqual(42423, NumberConverter.hex_to_decimal('a5b7'))\n\n def test_hex_to_decimal_2(self):\n self.assertEqual(21207, NumberConverter.hex_to_decimal('52d7'))\n\n def test_hex_to_decimal_3(self):\n self.assertEqual(84627, NumberConverter.hex_to_decimal('14a93'))\n\n def test_hex_to_decimal_4(self):\n self.assertEqual(170615, NumberConverter.hex_to_decimal('29a77'))\n\n def test_hex_to_decimal_5(self):\n self.assertEqual(342647, NumberConverter.hex_to_decimal('53a77'))", "solution_code": "@staticmethod\n def hex_to_decimal(hex_num):\n decimal_num = int(hex_num, 16)\n return decimal_num", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "NumberConverterTestDecimalToBinary", "NumberConverterTestBinaryToDecimal", "NumberConvertTestDecimalToOctal", "NumberConvertTestOctalToDecimal", "NumberConvertTestDecimalToHex", "NumberConvertTestHexToDecimal", "NumberConvertTestMain" ]

[]

[]

[ { "method_name": "format", "method_description": "def format(self, x):\n \"\"\"\n Converts a number into words format\n :param x: int or float, the number to be converted into words format\n :return: str, the number in words format\n >>> formatter = NumberWordFormatter()\n >>> formatter.format(123456)\n \"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\"\n \"\"\"", "test_class": "NumberWordFormatterTestFormat", "test_code": "class NumberWordFormatterTestFormat(unittest.TestCase):\n def test_format_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(123456),\n \"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\n\n def test_format_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(1000), \"ONE THOUSAND ONLY\")\n\n def test_format_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(1000000), \"ONE MILLION ONLY\")\n\n def test_format_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(1.23), \"ONE AND CENTS TWENTY THREE ONLY\")\n\n def test_format_5(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(0), \"ZERO ONLY\")\n\n def test_format_6(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(None), \"\")", "solution_code": "def format(self, x):\n if x is not None:\n return self.format_string(str(x))\n else:\n return \"\"", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "format_string" ] } }, { "method_name": "format_string", "method_description": "def format_string(self, x):\n \"\"\"\n Converts a string representation of a number into words format\n :param x: str, the string representation of a number\n :return: str, the number in words format\n >>> formatter = NumberWordFormatter()\n >>> formatter.format_string(\"123456\")\n \"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\"\n \"\"\"", "test_class": "NumberWordFormatterTestFormatString", "test_code": "class NumberWordFormatterTestFormatString(unittest.TestCase):\n def test_format_string_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('123456'),\n \"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\n\n def test_format_string_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('1000'), \"ONE THOUSAND ONLY\")\n\n def test_format_string_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('1000000'), \"ONE MILLION ONLY\")\n\n def test_format_string_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('1.23'), \"ONE AND CENTS TWENTY THREE ONLY\")\n\n def test_format_string_5(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('0'), \"ZERO ONLY\")\n\n def test_format_string_6(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('10'), \"TEN ONLY\")", "solution_code": "def format_string(self, x):\n lstr, rstr = (x.split('.') + [''])[:2]\n lstrrev = lstr[::-1]\n a = [''] * 5\n\n if len(lstrrev) % 3 == 1:\n lstrrev += \"00\"\n elif len(lstrrev) % 3 == 2:\n lstrrev += \"0\"\n\n lm = \"\"\n for i in range(len(lstrrev) // 3):\n a[i] = lstrrev[3 * i:3 * i + 3][::-1]\n if a[i] != \"000\":\n lm = self.trans_three(a[i]) + \" \" + self.parse_more(i) + \" \" + lm\n else:\n lm += self.trans_three(a[i])\n\n xs = f\"AND CENTS {self.trans_two(rstr)} \" if rstr else \"\"\n if not lm.strip():\n return \"ZERO ONLY\"\n else:\n return f\"{lm.strip()} {xs}ONLY\"", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "trans_two", "trans_three", "parse_more" ] } }, { "method_name": "trans_two", "method_description": "def trans_two(self, s):\n \"\"\"\n Converts a two-digit number into words format\n :param s: str, the two-digit number\n :return: str, the number in words format\n >>> formatter = NumberWordFormatter()\n >>> formatter.trans_two(\"23\")\n \"TWENTY THREE\"\n \"\"\"", "test_class": "NumberWordFormatterTestTransTwo", "test_code": "class NumberWordFormatterTestTransTwo(unittest.TestCase):\n def test_trans_two_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"23\"), \"TWENTY THREE\")\n\n def test_trans_two_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"10\"), \"TEN\")\n\n def test_trans_two_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"05\"), \"FIVE\")\n\n def test_trans_two_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"00\"), \"\")\n\n def test_trans_two_5(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"01\"), \"ONE\")\n\n def test_trans_two_6(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"80\"), \"EIGHTY\")", "solution_code": "def trans_two(self, s):\n s = s.zfill(2)\n if s[0] == \"0\":\n return self.NUMBER[int(s[-1])]\n elif s[0] == \"1\":\n return self.NUMBER_TEEN[int(s) - 10]\n elif s[1] == \"0\":\n return self.NUMBER_TEN[int(s[0]) - 1]\n else:\n return self.NUMBER_TEN[int(s[0]) - 1] + \" \" + self.NUMBER[int(s[-1])]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.NUMBER", "self.NUMBER_TEEN", "self.NUMBER_TEN" ], "method_dependencies": [] } }, { "method_name": "trans_three", "method_description": "def trans_three(self, s):\n \"\"\"\n Converts a three-digit number into words format\n :param s: str, the three-digit number\n :return: str, the number in words format\n >>> formatter = NumberWordFormatter()\n >>> formatter.trans_three(\"123\")\n \"ONE HUNDRED AND TWENTY THREE\"\n \"\"\"", "test_class": "NumberWordFormatterTestTransThree", "test_code": "class NumberWordFormatterTestTransThree(unittest.TestCase):\n def test_trans_three_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"123\"), \"ONE HUNDRED AND TWENTY THREE\")\n\n def test_trans_three_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"900\"), \"NINE HUNDRED\")\n\n def test_trans_three_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"007\"), \"SEVEN\")\n\n def test_trans_three_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"001\"), \"ONE\")\n\n def test_trans_three_5(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"006\"), \"SIX\")", "solution_code": "def trans_three(self, s):\n if s[0] == \"0\":\n return self.trans_two(s[1:])\n elif s[1:] == \"00\":\n return f\"{self.NUMBER[int(s[0])]} HUNDRED\"\n else:\n return f\"{self.NUMBER[int(s[0])]} HUNDRED AND {self.trans_two(s[1:])}\"", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.NUMBER" ], "method_dependencies": [ "trans_two" ] } }, { "method_name": "parse_more", "method_description": "def parse_more(self, i):\n \"\"\"\n Parses the thousand/million/billion suffix based on the index\n :param i: int, the index representing the magnitude (thousand, million, billion)\n :return: str, the corresponding suffix for the magnitude\n >>> formatter = NumberWordFormatter()\n >>> formatter.parse_more(1)\n \"THOUSAND\"\n \"\"\"", "test_class": "NumberWordFormatterTestParseMore", "test_code": "class NumberWordFormatterTestParseMore(unittest.TestCase):\n def test_parse_more_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(0), \"\")\n\n def test_parse_more_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(1), \"THOUSAND\")\n\n def test_parse_more_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(2), \"MILLION\")\n\n def test_parse_more_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(3), \"BILLION\")", "solution_code": "def parse_more(self, i):\n return self.NUMBER_MORE[i]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.NUMBER", "self.NUMBER_MORE" ], "method_dependencies": [] } } ]

[ "NumberWordFormatterTestFormat", "NumberWordFormatterTestFormatString", "NumberWordFormatterTestTransTwo", "NumberWordFormatterTestTransThree", "NumberWordFormatterTestParseMore", "NumberWordFormatterTest" ]

[ "self.NUMBER", "self.NUMBER_MORE", "self.NUMBER_SUFFIX", "self.NUMBER_TEEN", "self.NUMBER_TEN" ]

[]

[ { "method_name": "replace", "method_description": "def replace(self, string):\n \"\"\"\n Replaces numeric character references (HTML entities) in the input string with their corresponding Unicode characters.\n :param string: str, the input string containing numeric character references.\n :return: str, the input string with numeric character references replaced with their corresponding Unicode characters.\n >>> unescaper = NumericEntityUnescaper()\n >>> unescaper.replace(\"&#65;&#66;&#67;\")\n 'ABC'\n\n \"\"\"", "test_class": "NumericEntityUnescaperTestReplace", "test_code": "class NumericEntityUnescaperTestReplace(unittest.TestCase):\n def test_replace_1(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#65;&#66;&#67;\")\n self.assertEqual(res, \"ABC\")\n\n def test_replace_2(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#65;&#65;&#65;\")\n self.assertEqual(res, \"AAA\")\n\n def test_replace_3(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#66;&#66;&#66;\")\n self.assertEqual(res, \"BBB\")\n\n def test_replace_4(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#67;&#67;&#67;\")\n self.assertEqual(res, \"CCC\")\n\n def test_replace_5(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"\")\n self.assertEqual(res, \"\")\n\n def test_replace_6(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#\")\n self.assertEqual(res, \"\")\n\n def test_replace_7(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#X65;&#66;&#67;\")\n self.assertEqual(res, \"eBC\")\n\n def test_replace_8(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#???;&#66;&#67;\")\n self.assertEqual(res, \"&#???;BC\")\n\n def test_replace_9(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#67;&#67;&#67;;\")\n self.assertEqual(res, \"CCC\")\n\n def test_replace_10(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#X\")\n self.assertEqual(res, \"\")\n\n def test_replace_11(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#c1d;&#66;&#67;\")\n self.assertEqual(res, \"\")", "solution_code": "def replace(self, string):\n out = []\n pos = 0\n length = len(string)\n\n while pos < length - 2:\n if string[pos] == '&' and string[pos + 1] == '#':\n start = pos + 2\n is_hex = False\n first_char = string[start]\n\n if first_char == 'x' or first_char == 'X':\n start += 1\n is_hex = True\n\n if start == length:\n return ''.join(out)\n\n end = start\n while end < length and self.is_hex_char(string[end]):\n end += 1\n\n if end < length and string[end] == ';':\n try:\n entity_value = int(string[start:end], 16 if is_hex else 10)\n except:\n return ''.join(out)\n\n out.append(chr(entity_value))\n pos = end + 1\n continue\n\n out.append(string[pos])\n pos += 1\n\n return ''.join(out)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "is_hex_char" ] } }, { "method_name": "is_hex_char", "method_description": "@staticmethod\n def is_hex_char(char):\n \"\"\"\n Determines whether a given character is a hexadecimal digit.\n :param char: str, the character to check.\n :return: bool, True if the character is a hexadecimal digit, False otherwise.\n >>> NumericEntityUnescaper.is_hex_char('a')\n True\n\n \"\"\"", "test_class": "NumericEntityUnescaperTestIsHexChar", "test_code": "class NumericEntityUnescaperTestIsHexChar(unittest.TestCase):\n def test_is_hex_char_1(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('0')\n self.assertEqual(res, True)\n\n def test_is_hex_char_2(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('F')\n self.assertEqual(res, True)\n\n def test_is_hex_char_3(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('G')\n self.assertEqual(res, False)\n\n def test_is_hex_char_4(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('X')\n self.assertEqual(res, False)\n\n def test_is_hex_char_5(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('Z')\n self.assertEqual(res, False)", "solution_code": "@staticmethod\n def is_hex_char(char):\n return char.isdigit() or ('a' <= char.lower() <= 'f')", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "NumericEntityUnescaperTestReplace", "NumericEntityUnescaperTestIsHexChar", "unescaperTest" ]

[]

[]

[ { "method_name": "add_dish", "method_description": "def add_dish(self, dish):\n \"\"\"\n Check the self.menu and add into self.selected_dish if the dish count is valid.\n And if the dish has successfully been added, change the count in self.menu.\n :param dish: dict, the information of dish. dish = {\"dish\": dish name, \"count\": count, price: price}\n :return: True if successfully added, or False otherwise.\n >>> order = Order()\n >>> order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n >>> order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 3})\n True\n \"\"\"", "test_class": "OrderTestAddDish", "test_code": "class OrderTestAddDish(unittest.TestCase):\n def setUp(self):\n self.order = Order()\n\n self.order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.menu.append({\"dish\": \"dish2\", \"price\": 15, \"count\": 3})\n self.order.menu.append({\"dish\": \"dish3\", \"price\": 20, \"count\": 7})\n self.order.sales = {\"dish1\": 0.9, \"dish2\": 1, \"dish3\": 0.8}\n\n # add dish in menu\n def test_add_dish_1(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 4})\n self.assertTrue(result)\n\n # test the status of self.menu and self.selected_dishes\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 3)\n self.assertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 4}])\n\n # add dish when dish count exceeds the remaining count\n def test_add_dish_2(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 8})\n self.assertFalse(result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 7)\n self.assertEqual(self.order.selected_dishes, [])\n\n def test_add_dish_3(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 7})\n self.assertTrue(result)\n\n # test the status of self.menu and self.selected_dishes\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 0)\n self.assertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 7}])\n\n def test_add_dish_4(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 6})\n self.assertTrue(result)\n\n # test the status of self.menu and self.selected_dishes\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 1)\n self.assertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 6}])\n\n def test_add_dish_5(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 5})\n self.assertTrue(result)\n\n # test the status of self.menu and self.selected_dishes\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 2)\n self.assertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 5}])\n\n def test_add_dish_6(self):\n self.order.menu = []\n result = self.order.add_dish({})\n self.assertTrue(result)", "solution_code": "def add_dish(self, dish):\n for menu_dish in self.menu:\n if dish[\"dish\"] == menu_dish[\"dish\"]:\n if menu_dish[\"count\"] < dish[\"count\"]:\n return False\n else:\n menu_dish[\"count\"] -= dish[\"count\"]\n break\n self.selected_dishes.append(dish)\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.menu", "self.selected_dishes" ], "method_dependencies": [] } }, { "method_name": "calculate_total", "method_description": "def calculate_total(self):\n \"\"\"\n Calculate the total price of dishes that have been ordered. Multiply the count, price and sales.\n :return total: float, the final total price.\n >>> order = Order()\n >>> order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n >>> order.sales = {\"dish1\": 0.8}\n >>> order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 4})\n True\n >>> order.calculate_total()\n 32.0\n \"\"\"", "test_class": "OrderTestCalculateTotal", "test_code": "class OrderTestCalculateTotal(unittest.TestCase):\n def setUp(self):\n self.order = Order()\n self.order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.menu.append({\"dish\": \"dish2\", \"price\": 15, \"count\": 3})\n self.order.menu.append({\"dish\": \"dish3\", \"price\": 20, \"count\": 7})\n self.order.sales = {\"dish1\": 0.9, \"dish2\": 1, \"dish3\": 0.8}\n\n def test_calculate_total_1(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 2})\n result = self.order.calculate_total()\n self.assertEqual(50, result)\n\n def test_calculate_total_2(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\n self.order.add_dish({\"dish\": \"dish2\", \"price\": 15, \"count\": 2})\n result = self.order.calculate_total()\n self.assertEqual(48, result)\n\n def test_calculate_total_3(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 1})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 1})\n result = self.order.calculate_total()\n self.assertEqual(25, result)\n\n def test_calculate_total_4(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 3})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 3})\n result = self.order.calculate_total()\n self.assertEqual(75, result)\n\n def test_calculate_total_5(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 4})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 4})\n result = self.order.calculate_total()\n self.assertEqual(100, result)", "solution_code": "def calculate_total(self):\n total = 0\n for dish in self.selected_dishes:\n total += dish[\"price\"] * dish[\"count\"] * self.sales[dish[\"dish\"]]\n return total", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.sales", "self.selected_dishes" ], "method_dependencies": [] } }, { "method_name": "checkout", "method_description": "def checkout(self):\n \"\"\"\n Check out the dished ordered. IF the self.selected_dishes is not empty, invoke the calculate_total\n method to check out.\n :return Flase if the self.selected_dishes is empty, or total(return value of calculate_total) otherwise.\n >>> order = Order()\n >>> order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n >>> order.sales = {\"dish1\": 0.8}\n >>> order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 4})\n True\n >>> order.checkout()\n 32.0\n \"\"\"", "test_class": "OrderTestCheckout", "test_code": "class OrderTestCheckout(unittest.TestCase):\n def setUp(self):\n self.order = Order()\n self.order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.menu.append({\"dish\": \"dish2\", \"price\": 15, \"count\": 3})\n self.order.menu.append({\"dish\": \"dish3\", \"price\": 20, \"count\": 7})\n self.order.sales = {\"dish1\": 0.9, \"dish2\": 1, \"dish3\": 0.8}\n\n # as test_main\n def test_checkout_1(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 2})\n result = self.order.checkout()\n self.assertEqual(50, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 5)\n self.assertEqual([], self.order.selected_dishes)\n\n # haven't ordered dishes.\n # self.selected_dishes is empty\n def test_checkout_2(self):\n result = self.order.checkout()\n self.assertFalse(result)\n\n def test_checkout_3(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 1})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 1})\n result = self.order.checkout()\n self.assertEqual(25, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 4)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 6)\n self.assertEqual([], self.order.selected_dishes)\n\n def test_checkout_4(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 3})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 3})\n result = self.order.checkout()\n self.assertEqual(75, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 2)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 4)\n self.assertEqual([], self.order.selected_dishes)\n\n def test_checkout_5(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 5})\n result = self.order.checkout()\n self.assertEqual(125, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 0)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 2)\n self.assertEqual([], self.order.selected_dishes)", "solution_code": "def checkout(self):\n if len(self.selected_dishes) == 0:\n return False\n total = self.calculate_total()\n self.selected_dishes = []\n return total", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.selected_dishes" ], "method_dependencies": [ "calculate_total" ] } } ]

[ "OrderTestAddDish", "OrderTestCalculateTotal", "OrderTestCheckout", "OrderTest" ]

[ "self.menu", "self.sales", "self.selected_dishes" ]

[]

[ { "method_name": "get_page", "method_description": "def get_page(self, page_number):\n \"\"\"\n Retrieve a specific page of data.\n :param page_number: int, the page number to fetch\n :return: list, the data on the specified page\n >>> page_util = PageUtil([1, 2, 3, 4], 1)\n >>> page_util.get_page(1)\n [1]\n\n \"\"\"", "test_class": "PageUtilTestGetPage", "test_code": "class PageUtilTestGetPage(unittest.TestCase):\n def setUp(self):\n self.data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n self.page_size = 3\n self.page_util = PageUtil(self.data, self.page_size)\n\n def test_get_page_1(self):\n page_number = 1\n expected_page = [1, 2, 3]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n def test_get_page_2(self):\n page_number = 2\n expected_page = [4, 5, 6]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n def test_get_page_3(self):\n page_number = 3\n expected_page = [7, 8, 9]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n def test_get_page_4(self):\n page_number = 4\n expected_page = [10]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n def test_get_page_5(self):\n invalid_page_number = 0\n empty_page = []\n actual_page = self.page_util.get_page(invalid_page_number)\n self.assertEqual(actual_page, empty_page)", "solution_code": "def get_page(self, page_number):\n if page_number < 1 or page_number > self.total_pages:\n return []\n\n start_index = (page_number - 1) * self.page_size\n end_index = start_index + self.page_size\n return self.data[start_index:end_index]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data", "self.page_size", "self.total_pages" ], "method_dependencies": [] } }, { "method_name": "get_page_info", "method_description": "def get_page_info(self, page_number):\n \"\"\"\n Retrieve information about a specific page.\n :param page_number: int, the page number to fetch information about\n :return: dict, containing page information such as current page number, total pages, etc.\n >>> page_util = PageUtil([1, 2, 3, 4], 1)\n >>> page_util.get_page_info(1)\n >>> {\n >>> \"current_page\": 1,\n >>> \"per_page\": 1,\n >>> \"total_pages\": 4,\n >>> \"total_items\": 4,\n >>> \"has_previous\": False,\n >>> \"has_next\": True,\n >>> \"data\": [1]\n >>> }\n\n \"\"\"", "test_class": "PageUtilTestGetPageInfo", "test_code": "class PageUtilTestGetPageInfo(unittest.TestCase):\n def setUp(self):\n self.data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n self.page_size = 3\n self.page_util = PageUtil(self.data, self.page_size)\n\n def test_get_page_info_1(self):\n page_number = 2\n expected_info = {\n \"current_page\": 2,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": True,\n \"has_next\": True,\n \"data\": [4, 5, 6]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n def test_get_page_info_2(self):\n page_number = 1\n expected_info = {\n \"current_page\": 1,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": False,\n \"has_next\": True,\n \"data\": [1, 2, 3]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n def test_get_page_info_3(self):\n page_number = 3\n expected_info = {\n \"current_page\": 3,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": True,\n \"has_next\": True,\n \"data\": [7, 8, 9]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n def test_get_page_info_4(self):\n page_number = 4\n expected_info = {\n \"current_page\": 4,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": True,\n \"has_next\": False,\n \"data\": [10]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n def test_get_page_info_5(self):\n invalid_page_number = 5\n empty_info = {}\n actual_info = self.page_util.get_page_info(invalid_page_number)\n self.assertEqual(actual_info, empty_info)", "solution_code": "def get_page_info(self, page_number):\n if page_number < 1 or page_number > self.total_pages:\n return {}\n\n start_index = (page_number - 1) * self.page_size\n end_index = min(start_index + self.page_size, self.total_items)\n page_data = self.data[start_index:end_index]\n\n page_info = {\n \"current_page\": page_number,\n \"per_page\": self.page_size,\n \"total_pages\": self.total_pages,\n \"total_items\": self.total_items,\n \"has_previous\": page_number > 1,\n \"has_next\": page_number < self.total_pages,\n \"data\": page_data\n }\n return page_info", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data", "self.page_size", "self.total_items", "self.total_pages" ], "method_dependencies": [] } }, { "method_name": "search", "method_description": "def search(self, keyword):\n \"\"\"\n Search for items in the data that contain the given keyword.\n :param keyword: str, the keyword to search for\n :return: dict, containing search information such as total results and matching items\n >>> page_util = PageUtil([1, 2, 3, 4], 1)\n >>> page_util.search(\"1\")\n >>> search_info = {\n >>> \"keyword\": \"1\",\n >>> \"total_results\": 1,\n >>> \"total_pages\": 1,\n >>> \"results\": [1]\n >>> }\n \"\"\"", "test_class": "PageUtilTestSearch", "test_code": "class PageUtilTestSearch(unittest.TestCase):\n def setUp(self):\n self.data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n self.page_size = 3\n self.page_util = PageUtil(self.data, self.page_size)\n\n def test_search_1(self):\n keyword = \"1\"\n expected_results = {\n \"keyword\": \"1\",\n \"total_results\": 2,\n \"total_pages\": 1,\n \"results\": [1, 10]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n def test_search_2(self):\n keyword = \"2\"\n expected_results = {\n \"keyword\": \"2\",\n \"total_results\": 1,\n \"total_pages\": 1,\n \"results\": [2]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n def test_search_3(self):\n keyword = \"3\"\n expected_results = {\n \"keyword\": \"3\",\n \"total_results\": 1,\n \"total_pages\": 1,\n \"results\": [3]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n def test_search_4(self):\n keyword = \"4\"\n expected_results = {\n \"keyword\": \"4\",\n \"total_results\": 1,\n \"total_pages\": 1,\n \"results\": [4]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n def test_search_5(self):\n keyword = \"11\"\n expected_results = {\n \"keyword\": \"11\",\n \"total_results\": 0,\n \"total_pages\": 0,\n \"results\": []\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)", "solution_code": "def search(self, keyword):\n results = [item for item in self.data if keyword in str(item)]\n num_results = len(results)\n num_pages = (num_results + self.page_size - 1) // self.page_size\n\n search_info = {\n \"keyword\": keyword,\n \"total_results\": num_results,\n \"total_pages\": num_pages,\n \"results\": results\n }\n return search_info", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.data", "self.page_size" ], "method_dependencies": [] } } ]

[ "PageUtilTestGetPage", "PageUtilTestGetPageInfo", "PageUtilTestSearch", "PageUtilTest" ]

[ "self.data", "self.page_size", "self.total_items", "self.total_pages" ]

[ "import PyPDF2" ]

[ { "method_name": "merge_pdfs", "method_description": "def merge_pdfs(self, output_filepath):\n \"\"\"\n Read files in self.readers which stores handles to multiple PDF files.\n Merge them to one pdf and update the page number, then save in disk.\n :param output_filepath: str, ouput file path to save to\n :return: str, \"Merged PDFs saved at {output_filepath}\" if successfully merged\n >>> handler = PDFHandler(['a.pdf', 'b.pdf'])\n >>> handler.merge_pdfs('out.pdf')\n Merged PDFs saved at out.pdf\n \"\"\"", "test_class": "TestPDFHandler", "test_code": "class TestPDFHandler(unittest.TestCase):\n @classmethod\n def setUpClass(cls):\n cls.test_files = [\"test1.pdf\", \"test2.pdf\"]\n cls.test_text = [\"This is a test1.\", \"This is a test2.\"]\n for i in range(2):\n c = canvas.Canvas(cls.test_files[i])\n c.drawString(100, 100, cls.test_text[i])\n c.showPage()\n c.save()\n\n @classmethod\n def tearDownClass(cls):\n for filename in cls.test_files:\n os.remove(filename)\n os.remove(\"merged.pdf\")", "solution_code": "def merge_pdfs(self, output_filepath):\n pdf_writer = PyPDF2.PdfWriter()\n\n for reader in self.readers:\n # reader.getNumPages is deprecated and was removed in PyPDF2 3.0.0. Use len(reader.pages) instead.\n for page_num in range(len(reader.pages)):\n # reader.getPage(pageNumber) is deprecated and was removed in PyPDF2 3.0.0. Use reader.pages[page_number] instead.\n page = reader.pages[page_num]\n # addPage is deprecated and was removed in PyPDF2 3.0.0. Use add_page instead.\n pdf_writer.add_page(page)\n\n with open(output_filepath, 'wb') as out:\n pdf_writer.write(out)\n return f\"Merged PDFs saved at {output_filepath}\"", "dependencies": { "Standalone": false, "lib_dependencies": [ "PyPDF2" ], "field_dependencies": [ "self.readers" ], "method_dependencies": [] } }, { "method_name": "extract_text_from_pdfs", "method_description": "def extract_text_from_pdfs(self):\n \"\"\"\n Extract text from pdf files in self.readers\n :return pdf_texts: list of str, each element is the text of one pdf file\n >>> handler = PDFHandler(['a.pdf', 'b.pdf'])\n >>> handler.extract_text_from_pdfs()\n ['Test a.pdf', 'Test b.pdf']\n \"\"\"", "test_class": "PDFHandlerTestMergePdfs", "test_code": "class PDFHandlerTestMergePdfs(unittest.TestCase):\n def setUp(self) -> None:\n TestPDFHandler.setUpClass()\n\n def tearDown(self) -> None:\n TestPDFHandler.tearDownClass()\n\n def test_merge_pdfs(self):\n TestPDFHandler.setUpClass()\n handler = PDFHandler(TestPDFHandler.test_files)\n result = handler.merge_pdfs(\"merged.pdf\")\n self.assertEqual(\"Merged PDFs saved at merged.pdf\", result)\n self.assertTrue(os.path.exists(\"merged.pdf\"))", "solution_code": "def extract_text_from_pdfs(self):\n pdf_texts = []\n for reader in self.readers:\n for page_num in range(len(reader.pages)):\n page = reader.pages[page_num]\n pdf_texts.append(page.extract_text())\n return pdf_texts", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.readers" ], "method_dependencies": [] } } ]

[ "TestPDFHandler", "PDFHandlerTestMergePdfs", "PDFHandlerTestExtractTextFromPdfs", "PDFHandlerTestMain" ]

[ "self.filepaths", "self.readers" ]

[]

[ { "method_name": "_validate_name", "method_description": "def _validate_name(self, name: str) -> str:\n \"\"\"\n Validate the name and return it. If name is empty or exceeds 33 characters in length, set to None.\n :param name: str, the name to validate\n :return: str, the validated name or None if invalid\n \"\"\"", "test_class": "PersonRequestTestValidateName", "test_code": "class PersonRequestTestValidateName(unittest.TestCase):\n def test_validate_name_1(self):\n pr = PersonRequest(\"\", \"Man\", \"12345678901\")\n self.assertIsNone(pr.name)\n\n def test_validate_name_2(self):\n pr = PersonRequest(\"This is a very long name that exceeds the character limit\", \"Man\",\n \"12345678901\")\n self.assertIsNone(pr.name)\n\n def test_validate_name_3(self):\n pr = PersonRequest(\"aaa\", \"Man\", \"12345678901\")\n self.assertEqual(pr.name, 'aaa')\n\n def test_validate_name_4(self):\n pr = PersonRequest(\"bbb\", \"Man\", \"12345678901\")\n self.assertEqual(pr.name, 'bbb')\n\n def test_validate_name_5(self):\n pr = PersonRequest(\"ccc\", \"Man\", \"12345678901\")\n self.assertEqual(pr.name, 'ccc')", "solution_code": "def _validate_name(self, name: str) -> str:\n if not name:\n return None\n if len(name) > 33:\n return None\n return name", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "_validate_sex", "method_description": "def _validate_sex(self, sex: str) -> str:\n \"\"\"\n Validate the sex and return it. If sex is not Man, Woman, or UGM, set to None.\n :param sex: str, the sex to validate\n :return: str, the validated sex or None if invalid\n \"\"\"", "test_class": "PersonRequestTestValidateSex", "test_code": "class PersonRequestTestValidateSex(unittest.TestCase):\n def test_validate_sex_1(self):\n pr = PersonRequest(\"John Doe\", \"Unknown\", \"12345678901\")\n self.assertIsNone(pr.sex)\n\n def test_validate_sex_2(self):\n pr = PersonRequest(\"John Doe\", \"UGM\", \"12345678901\")\n self.assertEqual(pr.sex, \"UGM\")\n\n def test_validate_sex_3(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"12345678901\")\n self.assertEqual(pr.sex, \"Man\")\n\n def test_validate_sex_4(self):\n pr = PersonRequest(\"John Doe\", \"Woman\", \"12345678901\")\n self.assertEqual(pr.sex, \"Woman\")\n\n def test_validate_sex_5(self):\n pr = PersonRequest(\"John Doe\", \"khsigy\", \"12345678901\")\n self.assertIsNone(pr.sex)", "solution_code": "def _validate_sex(self, sex: str) -> str:\n if sex not in [\"Man\", \"Woman\", \"UGM\"]:\n return None\n return sex", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "_validate_phoneNumber", "method_description": "def _validate_phoneNumber(self, phoneNumber: str) -> str:\n \"\"\"\n Validate the phone number and return it. If phoneNumber is empty or not an 11 digit number, set to None.\n :param phoneNumber: str, the phone number to validate\n :return: str, the validated phone number or None if invalid\n \"\"\"", "test_class": "PersonRequestTestValidatePhoneNumber", "test_code": "class PersonRequestTestValidatePhoneNumber(unittest.TestCase):\n def test_validate_phoneNumber_1(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"\")\n self.assertIsNone(pr.phoneNumber)\n\n def test_validate_phoneNumber_2(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"12345\")\n self.assertIsNone(pr.phoneNumber)\n\n def test_validate_phoneNumber_3(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"jgdjrj\")\n self.assertIsNone(pr.phoneNumber)\n\n def test_validate_phoneNumber_4(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"12345678901\")\n self.assertEqual(pr.phoneNumber, \"12345678901\")\n\n def test_validate_phoneNumber_5(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"11111111111\")\n self.assertEqual(pr.phoneNumber, \"11111111111\")", "solution_code": "def _validate_phoneNumber(self, phoneNumber: str) -> str:\n if not phoneNumber:\n return None\n if len(phoneNumber) != 11 or not phoneNumber.isdigit():\n return None\n return phoneNumber", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "PersonRequestTestValidateName", "PersonRequestTestValidateSex", "PersonRequestTestValidatePhoneNumber", "PersonRequestTest" ]

[ "self.name", "self.phoneNumber", "self.sex" ]

[]

[ { "method_name": "init_game", "method_description": "def init_game(self):\n \"\"\"\n Initialize the game by setting the positions of the player, targets, and boxes based on the map.\n >>> game = PushBoxGame([\"#####\", \"#O #\", \"# X #\", \"# G#\", \"#####\"]) \n >>> game.targets\n [(3, 3)]\n >>> game.boxes\n [(2, 2)]\n >>> game.player_row\n 1\n >>> game.player_col\n 1\n \"\"\"", "test_class": "PushBoxGameTestInitGame", "test_code": "class PushBoxGameTestInitGame(unittest.TestCase):\n def setUp(self) -> None:\n self.game_map = [\n \"#####\",\n \"#O #\",\n \"# X #\",\n \"# G#\",\n \"#####\"\n ]\n self.game = PushBoxGame(self.game_map)\n\n def test_init_game_1(self):\n self.assertEqual(self.game.map, self.game_map)\n\n def test_init_game_2(self):\n self.assertEqual(self.game.is_game_over, False)\n\n def test_init_game_3(self):\n self.assertEqual(self.game.player_col, 1)\n\n def test_init_game_4(self):\n self.assertEqual(self.game.player_row, 1)\n\n def test_init_game_5(self):\n self.assertEqual(self.game.targets, [(3, 3)])\n\n def test_init_game_6(self):\n self.assertEqual(self.game.boxes, [(2, 2)])\n\n def test_init_game_7(self):\n self.assertEqual(self.game.target_count, 1)", "solution_code": "def init_game(self):\n for row in range(len(self.map)):\n for col in range(len(self.map[row])):\n if self.map[row][col] == \"O\":\n self.player_row = row\n self.player_col = col\n elif self.map[row][col] == \"G\":\n self.targets.append((row, col))\n self.target_count += 1\n elif self.map[row][col] == \"X\":\n self.boxes.append((row, col))", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.boxes", "self.map", "self.player_col", "self.player_row", "self.target_count", "self.targets" ], "method_dependencies": [] } }, { "method_name": "check_win", "method_description": "def check_win(self):\n \"\"\"\n Check if the game is won. The game is won when all the boxes are placed on target positions.\n And update the value of self.is_game_over.\n :return self.is_game_over: True if all the boxes are placed on target positions, or False otherwise.\n >>> game = PushBoxGame([\"#####\", \"#O #\", \"# X #\", \"# G#\", \"#####\"]) \n >>> game.check_win()\n \"\"\"", "test_class": "PushBoxGameTestCheckWin", "test_code": "class PushBoxGameTestCheckWin(unittest.TestCase):\n def setUp(self) -> None:\n self.game_map = [\n \"#####\",\n \"#O #\",\n \"# X #\",\n \"# G#\",\n \"#####\"\n ]\n self.game = PushBoxGame(self.game_map)\n\n def test_check_win_1(self):\n self.assertFalse(self.game.check_win())\n\n def test_check_win_2(self):\n moves = ['d', 's', 'a', 's', 'd']\n for move in moves:\n self.game.move(move)\n self.assertTrue(self.game.check_win())", "solution_code": "def check_win(self):\n box_on_target_count = 0\n for box in self.boxes:\n if box in self.targets:\n box_on_target_count += 1\n if box_on_target_count == self.target_count:\n self.is_game_over = True\n return self.is_game_over", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.boxes", "self.is_game_over", "self.target_count", "self.targets" ], "method_dependencies": [] } }, { "method_name": "move", "method_description": "def move(self, direction):\n \"\"\"\n Move the player based on the specified direction and check if the game is won.\n :param direction: str, the direction of the player's movement. \n It can be 'w', 's', 'a', or 'd' representing up, down, left, or right respectively.\n\n :return: True if the game is won, False otherwise.\n >>> game = PushBoxGame([\"#####\", \"#O #\", \"# X #\", \"# G#\", \"#####\"]) \n >>> game.print_map()\n # # # # # \n # O #\n # X #\n # G #\n # # # # #\n >>> game.move('d')\n False\n >>> game.move('s') \n False\n >>> game.move('a') \n False\n >>> game.move('s') \n False\n >>> game.move('d') \n True\n \"\"\"", "test_class": "PushBoxGameTestMove", "test_code": "class PushBoxGameTestMove(unittest.TestCase):\n def setUp(self) -> None:\n self.game_map = [\n \"#####\",\n \"#O #\",\n \"# X #\",\n \"# G#\",\n \"#####\"\n ]\n self.game = PushBoxGame(self.game_map)\n\n def test_move_1(self):\n moves = ['d', 's', 'a', 's']\n for move in moves:\n self.assertFalse(self.game.move(move))\n self.assertTrue(self.game.move('d'))\n\n def test_move_2(self):\n self.game.move('a')\n self.assertEqual(self.game.player_col, 1)\n self.assertEqual(self.game.player_row, 1)\n self.assertFalse(self.game.is_game_over)\n\n def test_move_3(self):\n self.game.move('d')\n self.assertEqual(self.game.player_col, 2)\n self.assertEqual(self.game.player_row, 1)\n self.assertFalse(self.game.is_game_over)\n\n def test_move_4(self):\n self.game.move('s')\n self.assertEqual(self.game.player_col, 1)\n self.assertEqual(self.game.player_row, 2)\n self.assertFalse(self.game.is_game_over)\n\n def test_move_5(self):\n self.game.move('w')\n self.assertEqual(self.game.player_col, 1)\n self.assertEqual(self.game.player_row, 1)\n self.assertFalse(self.game.is_game_over)\n\n def test_move_6(self):\n self.game.move('?')\n self.assertFalse(self.game.is_game_over)\n\n def test_move_7(self):\n self.game_map = [\n \"#####\",\n \"# X #\",\n \"# O #\",\n \"# G#\",\n \"#####\"\n ]\n self.game = PushBoxGame(self.game_map)\n self.game.move('w')\n self.assertEqual(self.game.player_col, 2)\n self.assertEqual(self.game.player_row, 2)\n self.assertFalse(self.game.is_game_over)", "solution_code": "def move(self, direction):\n new_player_row = self.player_row\n new_player_col = self.player_col\n\n if direction == \"w\":\n new_player_row -= 1\n elif direction == \"s\":\n new_player_row += 1\n elif direction == \"a\":\n new_player_col -= 1\n elif direction == \"d\":\n new_player_col += 1\n\n if self.map[new_player_row][new_player_col] != \"#\":\n if (new_player_row, new_player_col) in self.boxes:\n new_box_row = new_player_row + (new_player_row - self.player_row)\n new_box_col = new_player_col + (new_player_col - self.player_col)\n\n if self.map[new_box_row][new_box_col] != \"#\":\n self.boxes.remove((new_player_row, new_player_col))\n self.boxes.append((new_box_row, new_box_col))\n self.player_row = new_player_row\n self.player_col = new_player_col\n else:\n self.player_row = new_player_row\n self.player_col = new_player_col\n\n return self.check_win()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.boxes", "self.map", "self.player_col", "self.player_row" ], "method_dependencies": [ "check_win" ] } } ]

[ "PushBoxGameTestInitGame", "PushBoxGameTestCheckWin", "PushBoxGameTestMove" ]

[ "self.boxes", "self.is_game_over", "self.map", "self.player_col", "self.player_row", "self.target_count", "self.targets" ]

[ "import re" ]

[ { "method_name": "match", "method_description": "def match(self, pattern, text):\n \"\"\"\n Check if the text matches the regular expression\n :param pattern: string, Regular expression pattern\n :param text: string, Text to match\n :return: True or False, representing whether the text matches the regular expression or not\n >>> ru = RegexUtils()\n >>> ru.match(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-7890\")\n True\n \"\"\"", "test_class": "RegexUtilsTestMatch", "test_code": "class RegexUtilsTestMatch(unittest.TestCase):\n def test_match_1(self):\n ru = RegexUtils()\n res = ru.match(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-7890\")\n self.assertEqual(res, True)\n\n def test_match_2(self):\n ru = RegexUtils()\n res = ru.match(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"1234567890\")\n self.assertEqual(res, False)\n\n def test_match_3(self):\n ru = RegexUtils()\n res = ru.match(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"111-111-1111\")\n self.assertEqual(res, True)\n\n def test_match_4(self):\n ru = RegexUtils()\n res = ru.match(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-789\")\n self.assertEqual(res, False)\n\n def test_match_5(self):\n ru = RegexUtils()\n res = ru.match(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-789a\")\n self.assertEqual(res, False)", "solution_code": "def match(self, pattern, text):\n ans = re.match(pattern, text)\n if ans:\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "findall", "method_description": "def findall(self, pattern, text):\n \"\"\"\n Find all matching substrings and return a list of all matching substrings\n :param pattern: string, Regular expression pattern\n :param text: string, Text to match\n :return: list of string, List of all matching substrings\n >>> ru = RegexUtils()\n >>> ru.findall(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-7890 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n ['123-456-7890', '876-286-9876', '987-762-9767']\n \"\"\"", "test_class": "RegexUtilsTestFindall", "test_code": "class RegexUtilsTestFindall(unittest.TestCase):\n def test_findall_1(self):\n ru = RegexUtils()\n res = ru.findall(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-7890 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, ['123-456-7890', '876-286-9876', '987-762-9767'])\n\n def test_findall_2(self):\n ru = RegexUtils()\n res = ru.findall(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"abiguygusu kjgufwycs 987-762-9767\")\n self.assertEqual(res, ['987-762-9767'])\n\n def test_findall_3(self):\n ru = RegexUtils()\n res = ru.findall(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"abiguygusu kjgufwycs \")\n self.assertEqual(res, [])\n\n def test_findall_4(self):\n ru = RegexUtils()\n res = ru.findall(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"abiguygusu 111-111-1111 kjgufwycs 987-762-9767\")\n self.assertEqual(res, ['111-111-1111', '987-762-9767'])\n\n def test_findall_5(self):\n ru = RegexUtils()\n res = ru.findall(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"abiguygusu 111-111-111a kjgufwycs 987-762-9767\")\n self.assertEqual(res, ['987-762-9767'])", "solution_code": "def findall(self, pattern, text):\n return re.findall(pattern, text)", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "split", "method_description": "def split(self, pattern, text):\n \"\"\"\n Split text based on regular expression patterns and return a list of substrings\n :param pattern: string, Regular expression pattern\n :param text: string, Text to be split\n :return: list of string, List of substrings after splitting\n >>> ru = RegexUtils()\n >>> ru.split(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-7890 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n ['', ' abiguygusu ', ' kjgufwycs ', '']\n \"\"\"", "test_class": "RegexUtilsTestSplit", "test_code": "class RegexUtilsTestSplit(unittest.TestCase):\n def test_split_1(self):\n ru = RegexUtils()\n res = ru.split(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-7890 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, ['', ' abiguygusu ', ' kjgufwycs ', ''])\n\n def test_split_2(self):\n ru = RegexUtils()\n res = ru.split(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"1234567890 abiguygusu 8762869876 kjgufwycs 9877629767\")\n self.assertEqual(res, ['1234567890 abiguygusu 8762869876 kjgufwycs 9877629767'])\n\n def test_split_3(self):\n ru = RegexUtils()\n res = ru.split(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"111-111-1111 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, ['', ' abiguygusu ', ' kjgufwycs ', ''])\n\n def test_split_4(self):\n ru = RegexUtils()\n res = ru.split(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123456-7890 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, ['123456-7890 abiguygusu ', ' kjgufwycs ', ''])\n\n def test_split_5(self):\n ru = RegexUtils()\n res = ru.split(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', \"123-456-789a abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, ['123-456-789a abiguygusu ', ' kjgufwycs ', ''])", "solution_code": "def split(self, pattern, text):\n return re.split(pattern, text)", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "sub", "method_description": "def sub(self, pattern, replacement, text):\n \"\"\"\n Replace the substring matched by a regular expression with the specified string\n :param pattern: string, Regular expression pattern\n :param replacement: Text to replace with\n :param text: string, Text to be replaced\n :return: string, Text after replacement\n >>> ru = RegexUtils()\n >>> ru.sub(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', 'phone num', \"123-456-7890 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n 'phone num abiguygusu phone num kjgufwycs phone num'\n \"\"\"", "test_class": "RegexUtilsTestSub", "test_code": "class RegexUtilsTestSub(unittest.TestCase):\n def test_sub_1(self):\n ru = RegexUtils()\n res = ru.sub(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', 'phone num',\n \"123-456-7890 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, 'phone num abiguygusu phone num kjgufwycs phone num')\n\n def test_sub_2(self):\n ru = RegexUtils()\n res = ru.sub(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', 'phone num',\n \"1234567890 abiguygusu 8762869876 kjgufwycs 9877629767\")\n self.assertEqual(res, \"1234567890 abiguygusu 8762869876 kjgufwycs 9877629767\")\n\n def test_sub_3(self):\n ru = RegexUtils()\n res = ru.sub(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', 'phone num',\n \"123456-7890 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, '123456-7890 abiguygusu phone num kjgufwycs phone num')\n\n def test_sub_4(self):\n ru = RegexUtils()\n res = ru.sub(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', 'phone num',\n \"123-456-789a abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, '123-456-789a abiguygusu phone num kjgufwycs phone num')\n\n def test_sub_5(self):\n ru = RegexUtils()\n res = ru.sub(r'\\b\\d{3}-\\d{3}-\\d{4}\\b', 'phone num',\n \"123-456-780 abiguygusu 876-286-9876 kjgufwycs 987-762-9767\")\n self.assertEqual(res, '123-456-780 abiguygusu phone num kjgufwycs phone num')", "solution_code": "def sub(self, pattern, replacement, text):\n return re.sub(pattern, replacement, text)", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "generate_email_pattern", "method_description": "def generate_email_pattern(self):\n \"\"\"\n Generate regular expression patterns that match email addresses\n :return: string, regular expression patterns that match email addresses\n >>> ru = RegexUtils()\n >>> ru.generate_email_pattern()\n '\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b'\n \"\"\"", "test_class": "RegexUtilsTestGenerateEmailPattern", "test_code": "class RegexUtilsTestGenerateEmailPattern(unittest.TestCase):\n def test_generate_email_pattern_1(self):\n ru = RegexUtils()\n pat = ru.generate_email_pattern()\n res = ru.match(pat, '[email protected]')\n self.assertEqual(res, True)\n\n def test_generate_email_pattern_2(self):\n ru = RegexUtils()\n pat = ru.generate_email_pattern()\n res = ru.match(pat, 'iustd87t2euhifg.com')\n self.assertEqual(res, False)\n\n def test_generate_email_pattern_3(self):\n ru = RegexUtils()\n pat = ru.generate_email_pattern()\n res = ru.match(pat, '[email protected]')\n self.assertEqual(res, False)\n\n def test_generate_email_pattern_4(self):\n ru = RegexUtils()\n pat = ru.generate_email_pattern()\n res = ru.match(pat, 'iustd87t2euhifg@.')\n self.assertEqual(res, False)\n\n def test_generate_email_pattern_5(self):\n ru = RegexUtils()\n pat = ru.generate_email_pattern()\n res = ru.match(pat, 'iustd87t2euhifg@com.')\n self.assertEqual(res, False)", "solution_code": "def generate_email_pattern(self):\n pattern = r'\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b'\n return pattern", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "generate_phone_number_pattern", "method_description": "def generate_phone_number_pattern(self):\n \"\"\"\n Generate regular expression patterns that match phone numbers\n :return: string, regular expression patterns that match phone numbers\n >>> ru = RegexUtils()\n >>> ru.generate_phone_number_pattern()\n '\\b\\d{3}-\\d{3}-\\d{4}\\b'\n \"\"\"", "test_class": "RegexUtilsTestGeneratePhoneNumberPattern", "test_code": "class RegexUtilsTestGeneratePhoneNumberPattern(unittest.TestCase):\n def test_generate_phone_number_pattern_1(self):\n ru = RegexUtils()\n pat = ru.generate_phone_number_pattern()\n res = ru.match(pat, '123-456-7890')\n self.assertEqual(res, True)\n\n def test_generate_phone_number_pattern_2(self):\n ru = RegexUtils()\n pat = ru.generate_phone_number_pattern()\n res = ru.match(pat, '1234567890')\n self.assertEqual(res, False)\n\n def test_generate_phone_number_pattern_3(self):\n ru = RegexUtils()\n pat = ru.generate_phone_number_pattern()\n res = ru.match(pat, '123-456-789')\n self.assertEqual(res, False)\n\n def test_generate_phone_number_pattern_4(self):\n ru = RegexUtils()\n pat = ru.generate_phone_number_pattern()\n res = ru.match(pat, 'a23-456-7890')\n self.assertEqual(res, False)\n\n def test_generate_phone_number_pattern_5(self):\n ru = RegexUtils()\n pat = ru.generate_phone_number_pattern()\n res = ru.match(pat, '1234-56-7890')\n self.assertEqual(res, False)", "solution_code": "def generate_phone_number_pattern(self):\n pattern = r'\\b\\d{3}-\\d{3}-\\d{4}\\b'\n return pattern", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "generate_split_sentences_pattern", "method_description": "def generate_split_sentences_pattern(self):\n \"\"\"\n Generate regular expression patterns that match the middle characters of two sentences\n :return: string, regular expression patterns that match the middle characters of two sentences\n >>> ru = RegexUtils()\n >>> ru.generate_split_sentences_pattern()\n '[.!?][\\s]{1,2}(?=[A-Z])'\n \"\"\"", "test_class": "RegexUtilsTestGenerateSplitSentencesPattern", "test_code": "class RegexUtilsTestGenerateSplitSentencesPattern(unittest.TestCase):\n def test_generate_split_sentences_pattern_1(self):\n ru = RegexUtils()\n pat = ru.generate_split_sentences_pattern()\n res = ru.match(pat, '? Y')\n self.assertEqual(res, True)\n\n def test_generate_split_sentences_pattern_2(self):\n ru = RegexUtils()\n pat = ru.generate_split_sentences_pattern()\n res = ru.match(pat, '! Y')\n self.assertEqual(res, True)\n\n def test_generate_split_sentences_pattern_3(self):\n ru = RegexUtils()\n pat = ru.generate_split_sentences_pattern()\n res = ru.match(pat, '? ')\n self.assertEqual(res, False)\n\n def test_generate_split_sentences_pattern_4(self):\n ru = RegexUtils()\n pat = ru.generate_split_sentences_pattern()\n res = ru.match(pat, '?Y')\n self.assertEqual(res, False)\n\n def test_generate_split_sentences_pattern_5(self):\n ru = RegexUtils()\n pat = ru.generate_split_sentences_pattern()\n res = ru.match(pat, '.Y')\n self.assertEqual(res, False)", "solution_code": "def generate_split_sentences_pattern(self):\n pattern = r'[.!?][\\s]{1,2}(?=[A-Z])'\n return pattern", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "split_sentences", "method_description": "def split_sentences(self, text):\n \"\"\"\n Split the text into a list of sentences without Punctuation except the last sentence\n :param text: Text to be split\n :return: Split Text List\n >>> ru = RegexUtils()\n >>> ru.split_sentences(\"Aaa. Bbbb? Ccc!\")\n ['Aaa', 'Bbbb', 'Ccc!']\n \"\"\"", "test_class": "RegexUtilsTestSplitSentences", "test_code": "class RegexUtilsTestSplitSentences(unittest.TestCase):\n def test_split_sentences_1(self):\n ru = RegexUtils()\n res = ru.split_sentences(\"Aaa. Bbbb? Ccc!\")\n self.assertEqual(res, ['Aaa', 'Bbbb', 'Ccc!'])\n\n def test_split_sentences_2(self):\n ru = RegexUtils()\n res = ru.split_sentences(\"Aaa.Bbbb? Ccc!\")\n self.assertEqual(res, ['Aaa.Bbbb', 'Ccc!'])\n\n def test_split_sentences_3(self):\n ru = RegexUtils()\n res = ru.split_sentences(\"Aaa. bbbb? Ccc!\")\n self.assertEqual(res, ['Aaa. bbbb', 'Ccc!'])\n\n def test_split_sentences_4(self):\n ru = RegexUtils()\n res = ru.split_sentences(\"Aaa. bbbb, Ccc!\")\n self.assertEqual(res, ['Aaa. bbbb, Ccc!'])\n\n def test_split_sentences_5(self):\n ru = RegexUtils()\n res = ru.split_sentences(\"Aaa, Bbbb? Ccc!\")\n self.assertEqual(res, ['Aaa, Bbbb', 'Ccc!'])", "solution_code": "def split_sentences(self, text):\n pattern = self.generate_split_sentences_pattern()\n return self.split(pattern, text)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "split", "generate_split_sentences_pattern" ] } }, { "method_name": "validate_phone_number", "method_description": "def validate_phone_number(self, phone_number):\n \"\"\"\n Verify if the phone number is valid\n :param phone_number: Phone number to be verified\n :return: True or False, indicating whether the phone number is valid\n >>> ru = RegexUtils()\n >>> ru.validate_phone_number(\"123-456-7890\")\n True\n \"\"\"", "test_class": "RegexUtilsTestValidatePhoneNumber", "test_code": "class RegexUtilsTestValidatePhoneNumber(unittest.TestCase):\n def test_validate_phone_number_1(self):\n ru = RegexUtils()\n res = ru.validate_phone_number(\"123-456-7890\")\n self.assertEqual(res, True)\n\n def test_validate_phone_number_2(self):\n ru = RegexUtils()\n res = ru.validate_phone_number(\"1234567890\")\n self.assertEqual(res, False)\n\n def test_validate_phone_number_3(self):\n ru = RegexUtils()\n res = ru.validate_phone_number(\"a23-456-7890\")\n self.assertEqual(res, False)\n\n def test_validate_phone_number_4(self):\n ru = RegexUtils()\n res = ru.validate_phone_number(\"123-456-789\")\n self.assertEqual(res, False)\n\n def test_validate_phone_number_5(self):\n ru = RegexUtils()\n res = ru.validate_phone_number(\"1234-56-789\")\n self.assertEqual(res, False)", "solution_code": "def validate_phone_number(self, phone_number):\n pattern = self.generate_phone_number_pattern()\n return self.match(pattern, phone_number)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "match", "generate_phone_number_pattern" ] } }, { "method_name": "extract_email", "method_description": "def extract_email(self, text):\n \"\"\"\n Extract all email addresses from the text\n :param text: string, input text\n :return: list of string, All extracted email addresses\n >>> ru = RegexUtils()\n >>> ru.extract_email(\"[email protected] [email protected] [email protected]\")\n ['[email protected]', '[email protected]', '[email protected]']\n \"\"\"", "test_class": "RegexUtilsTestExtractEmail", "test_code": "class RegexUtilsTestExtractEmail(unittest.TestCase):\n def test_extract_email_1(self):\n ru = RegexUtils()\n res = ru.extract_email(\"[email protected] [email protected] [email protected]\")\n self.assertEqual(res, ['[email protected]', '[email protected]', '[email protected]'])\n\n def test_extract_email_2(self):\n ru = RegexUtils()\n res = ru.extract_email(\"[email protected] [email protected] [email protected]\")\n self.assertEqual(res, ['[email protected]', '[email protected]'])\n\n def test_extract_email_3(self):\n ru = RegexUtils()\n res = ru.extract_email(\"abcdefgiscom [email protected] [email protected]\")\n self.assertEqual(res, ['[email protected]', '[email protected]'])\n\n def test_extract_email_4(self):\n ru = RegexUtils()\n res = ru.extract_email(\"abcdefgiscom ygusyfysy126.com [email protected]\")\n self.assertEqual(res, ['[email protected]'])\n\n def test_extract_email_5(self):\n ru = RegexUtils()\n res = ru.extract_email(\"abcdefgiscom [email protected] [email protected]\")\n self.assertEqual(res, ['[email protected]'])", "solution_code": "def extract_email(self, text):\n pattern = self.generate_email_pattern()\n return self.findall(pattern, text)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "findall", "generate_email_pattern" ] } } ]

[ "RegexUtilsTestMatch", "RegexUtilsTestFindall", "RegexUtilsTestSplit", "RegexUtilsTestSub", "RegexUtilsTestGenerateEmailPattern", "RegexUtilsTestGeneratePhoneNumberPattern", "RegexUtilsTestGenerateSplitSentencesPattern", "RegexUtilsTestSplitSentences", "RegexUtilsTestValidatePhoneNumber", "RegexUtilsTestExtractEmail", "RegexUtilsTest" ]

[]

[]

[ { "method_name": "attack", "method_description": "def attack(self, other_character):\n \"\"\"\n Attack another character. The damage caused needs to offset the defense value.\n :param other_character: str, The character being attacked.\n >>> player_1 = RPGCharacter('player 1', 100, 10, 3)\n >>> player_2 = RPGCharacter('player 2', 100, 7, 2)\n >>> player_1.attack(player_2)\n >>> player_2.hp\n 92\n \"\"\"", "test_class": "RPGCharacterTestAttack", "test_code": "class RPGCharacterTestAttack(unittest.TestCase):\n def test_attack(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n self.assertEqual(character2.hp, 85)\n\n def test_attack_2(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character2.attack(character1)\n self.assertEqual(character1.hp, 95)\n\n def test_attack_3(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n character2.attack(character1)\n self.assertEqual(character1.hp, 95)\n self.assertEqual(character2.hp, 85)\n\n def test_attack_4(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n character1.attack(character2)\n self.assertEqual(character2.hp, 70)\n\n def test_attack_5(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n character1.attack(character2)\n character1.attack(character2)\n self.assertEqual(character2.hp, 55)", "solution_code": "def attack(self, other_character):\n damage = max(self.attack_power - other_character.defense, 1)\n other_character.hp -= damage", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.attack_power" ], "method_dependencies": [] } }, { "method_name": "heal", "method_description": "def heal(self):\n \"\"\"\n Heal the character with 10 hp and the max hp is 100.\n :return: int, the current health points after healing.\n >>> player_1 = RPGCharacter('player 1', 93, 10, 3)\n >>> player_1.heal()\n 100\n \"\"\"", "test_class": "RPGCharacterTestHeal", "test_code": "class RPGCharacterTestHeal(unittest.TestCase):\n def test_heal_1(self):\n character = RPGCharacter(\"John\", 90, 20, 10)\n character.heal()\n self.assertEqual(character.hp, 100)\n\n # overflow healing \n def test_heal_2(self):\n character = RPGCharacter(\"John\", 97, 20, 10)\n character.heal()\n self.assertEqual(character.hp, 100)\n\n def test_heal_3(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.heal()\n self.assertEqual(character.hp, 100)\n\n def test_heal_4(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.hp = 50\n character.heal()\n self.assertEqual(character.hp, 60)\n\n def test_heal_5(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.hp = 10\n character.heal()\n self.assertEqual(character.hp, 20)", "solution_code": "def heal(self):\n self.hp += 10\n if self.hp > 100:\n self.hp = 100\n return self.hp", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.hp" ], "method_dependencies": [] } }, { "method_name": "gain_exp", "method_description": "def gain_exp(self, amount):\n \"\"\"\n Gain experience points for the character and level_up when the exp has reached the values that is 100 times the current level\n The experience that overflows should be used to calculate the next leve up untill exhausts\n :param amount: int, the amount of experience points to gain.\n >>> player_1 = RPGCharacter('player 1', 100, 10, 3)\n >>> player_1.gain_exp(1100)\n >>> player_1.exp\n 100\n >>> player_1.level\n 5\n \"\"\"", "test_class": "RPGCharacterTestGainExp", "test_code": "class RPGCharacterTestGainExp(unittest.TestCase):\n\n # exp not overflow\n def test_gain_exp_1(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(100)\n self.assertEqual(character.level, 2)\n self.assertEqual(character.exp, 0)\n\n # exp overflow\n def test_gain_exp_2(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(1100)\n self.assertEqual(character.level, 5)\n self.assertEqual(character.exp, 100)\n\n def test_gain_exp_3(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(200)\n self.assertEqual(character.level, 2)\n self.assertEqual(character.exp, 100)\n\n def test_gain_exp_4(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(300)\n self.assertEqual(character.level, 3)\n self.assertEqual(character.exp, 0)\n\n def test_gain_exp_5(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(400)\n self.assertEqual(character.level, 3)\n self.assertEqual(character.exp, 100)", "solution_code": "def gain_exp(self, amount):\n while amount != 0:\n if self.exp + amount >= self.level * 100:\n amount -= (self.level * 100 - self.exp)\n self.level_up()\n else:\n self.exp += amount\n amount = 0", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.exp", "self.level" ], "method_dependencies": [ "level_up" ] } }, { "method_name": "level_up", "method_description": "def level_up(self):\n \"\"\"\n Level up the character and return to zero experience points, increase hp by 20 points, attack power and defense points by 5 points.\n max level is 100\n :return: tuple[int, int, int, int], the new level, health points, attack power, and defense points after leveling up.\n >>> player_1 = RPGCharacter('player 1', 100, 10, 3)\n >>> player_1.level_up()\n (2, 120, 15, 8)\n \"\"\"", "test_class": "RPGCharacterTestLevelUp", "test_code": "class RPGCharacterTestLevelUp(unittest.TestCase):\n def test_level_up_1(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.level_up()\n self.assertEqual(character.level, 2)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 120)\n self.assertEqual(character.attack_power, 25)\n self.assertEqual(character.defense, 15)\n\n # full level\n def test_level_up_2(self):\n character = RPGCharacter(\"John\", 100, 20, 10, 100)\n character.level_up()\n self.assertEqual(character.level, 100)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 100)\n self.assertEqual(character.attack_power, 20)\n self.assertEqual(character.defense, 10)\n\n def test_level_up_3(self):\n character = RPGCharacter(\"John\", 100, 20, 10, 2)\n character.level_up()\n self.assertEqual(character.level, 3)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 120)\n self.assertEqual(character.attack_power, 25)\n self.assertEqual(character.defense, 15)\n\n def test_level_up_4(self):\n character = RPGCharacter(\"John\", 100, 20, 10, 3)\n character.level_up()\n self.assertEqual(character.level, 4)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 120)\n self.assertEqual(character.attack_power, 25)\n self.assertEqual(character.defense, 15)\n\n def test_level_up_5(self):\n character = RPGCharacter(\"John\", 100, 20, 10, 4)\n character.level_up()\n self.assertEqual(character.level, 5)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 120)\n self.assertEqual(character.attack_power, 25)\n self.assertEqual(character.defense, 15)", "solution_code": "def level_up(self):\n if self.level < 100:\n self.level += 1\n self.exp = 0\n self.hp += 20\n self.attack_power += 5\n self.defense += 5\n return self.level, self.hp, self.attack_power, self.defense", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.attack_power", "self.defense", "self.exp", "self.hp", "self.level" ], "method_dependencies": [ "attack" ] } }, { "method_name": "is_alive", "method_description": "def is_alive(self):\n \"\"\"\n Check if player is alive.\n :return: True if the hp is larger than 0, or False otherwise.\n >>> player_1 = RPGCharacter('player 1', 100, 10, 3)\n >>> player_1.is_alive()\n True\n \"\"\"", "test_class": "RPGCharacterTestIsAlive", "test_code": "class RPGCharacterTestIsAlive(unittest.TestCase):\n def test_is_alive_1(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n self.assertTrue(character.is_alive())\n\n def test_is_alive_2(self):\n character = RPGCharacter(\"John\", 0, 20, 10)\n self.assertFalse(character.is_alive())\n\n def test_is_alive_3(self):\n character = RPGCharacter(\"John\", -10, 20, 10)\n self.assertFalse(character.is_alive())\n\n def test_is_alive_4(self):\n character = RPGCharacter(\"John\", 1, 20, 10)\n self.assertTrue(character.is_alive())\n\n def test_is_alive_5(self):\n character = RPGCharacter(\"John\", 10, 20, 10)\n self.assertTrue(character.is_alive())", "solution_code": "def is_alive(self):\n return self.hp > 0", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.hp" ], "method_dependencies": [] } } ]

[ "RPGCharacterTestAttack", "RPGCharacterTestHeal", "RPGCharacterTestGainExp", "RPGCharacterTestLevelUp", "RPGCharacterTestIsAlive", "RPGCharacterTestMain" ]

[ "self.attack_power", "self.defense", "self.exp", "self.hp", "self.level", "self.name" ]

[]

[ { "method_name": "add_white_list", "method_description": "def add_white_list(self, addr):\n \"\"\"\n Add an address to the whitelist and do nothing if it already exists\n :param addr: int, address to be added\n :return: new whitelist, return False if the address already exists\n >>> server = Server()\n >>> server.add_white_list(88)\n [88]\n \"\"\"", "test_class": "ServerTestAddWhiteList", "test_code": "class ServerTestAddWhiteList(unittest.TestCase):\n def test_add_white_list_1(self):\n server = Server()\n server.add_white_list(88)\n self.assertEqual(server.white_list, [88])\n\n def test_add_white_list_2(self):\n server = Server()\n server.add_white_list(88)\n self.assertEqual(server.add_white_list(88), False)\n\n def test_add_white_list_3(self):\n server = Server()\n server.add_white_list(88)\n server.add_white_list(11)\n self.assertEqual(server.add_white_list(11), False)\n\n def test_add_white_list_4(self):\n server = Server()\n server.add_white_list(11)\n self.assertEqual(server.white_list, [11])\n\n def test_add_white_list_5(self):\n server = Server()\n server.add_white_list(88)\n server.add_white_list(11)\n server.add_white_list(22)\n self.assertEqual(server.add_white_list(22), False)", "solution_code": "def add_white_list(self, addr):\n if addr in self.white_list:\n return False\n else:\n self.white_list.append(addr)\n return self.white_list", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.white_list" ], "method_dependencies": [] } }, { "method_name": "del_white_list", "method_description": "def del_white_list(self, addr):\n \"\"\"\n Remove an address from the whitelist and do nothing if it does not exist\n :param addr: int, address to be deleted\n :return: new whitelist, return False if the address does not exist\n >>> server.add_white_list(88)\n >>> server.del_white_list(88)\n []\n \"\"\"", "test_class": "ServerTestDelWhiteList", "test_code": "class ServerTestDelWhiteList(unittest.TestCase):\n def test_del_white_list_1(self):\n server = Server()\n server.add_white_list(88)\n server.del_white_list(88)\n self.assertEqual(server.white_list, [])\n\n def test_del_white_list_2(self):\n server = Server()\n self.assertEqual(server.del_white_list(88), False)\n\n def test_del_white_list_3(self):\n server = Server()\n self.assertEqual(server.del_white_list(11), False)\n\n def test_del_white_list_4(self):\n server = Server()\n self.assertEqual(server.del_white_list(22), False)\n\n def test_del_white_list_5(self):\n server = Server()\n server.add_white_list(11)\n self.assertEqual(server.del_white_list(22), False)", "solution_code": "def del_white_list(self, addr):\n if addr not in self.white_list:\n return False\n else:\n self.white_list.remove(addr)\n return self.white_list", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.white_list" ], "method_dependencies": [] } }, { "method_name": "recv", "method_description": "def recv(self, info):\n \"\"\"\n Receive information containing address and content. If the address is on the whitelist, receive the content; otherwise, do not receive it\n :param info: dict, information dictionary containing address and content\n :return: if successfully received, return the content of the infomation; otherwise, return False\n >>> server.recv({\"addr\":88,\"content\":\"abc\"})\n abc\n \"\"\"", "test_class": "ServerTestRecv", "test_code": "class ServerTestRecv(unittest.TestCase):\n def test_recv_1(self):\n server = Server()\n server.add_white_list(88)\n server.recv({\"addr\": 88, \"content\": \"abc\"})\n self.assertEqual(server.receive_struct, {\"addr\": 88, \"content\": \"abc\"})\n\n def test_recv_2(self):\n server = Server()\n server.add_white_list(88)\n flag = server.recv({\"addr\": 66, \"content\": \"abc\"})\n self.assertEqual(server.receive_struct, {})\n self.assertEqual(flag, False)\n\n def test_recv_3(self):\n server = Server()\n flag = server.recv([88])\n self.assertEqual(server.receive_struct, {})\n self.assertEqual(flag, -1)\n\n def test_recv_4(self):\n server = Server()\n flag = server.recv({\"addr\": 88})\n self.assertEqual(server.receive_struct, {})\n self.assertEqual(flag, -1)\n\n def test_recv_5(self):\n server = Server()\n flag = server.recv({\"content\": \"abc\"})\n self.assertEqual(server.receive_struct, {})\n self.assertEqual(flag, -1)", "solution_code": "def recv(self, info):\n if not isinstance(info, dict) or \"addr\" not in info or \"content\" not in info:\n return -1\n addr = info[\"addr\"]\n content = info[\"content\"]\n if addr not in self.white_list:\n return False\n else:\n self.receive_struct = {\"addr\": addr, \"content\": content}\n return self.receive_struct[\"content\"]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.receive_struct", "self.white_list" ], "method_dependencies": [] } }, { "method_name": "send", "method_description": "def send(self, info):\n \"\"\"\n Send information containing address and content\n :param info: dict, information dictionary containing address and content\n :return: if successfully sent, return nothing; otherwise, return a string indicating an error message\n >>> server.send({\"addr\":66,\"content\":\"ABC\"})\n self.send_struct = {\"addr\":66,\"content\":\"ABC\"}\n \"\"\"", "test_class": "ServerTestSend", "test_code": "class ServerTestSend(unittest.TestCase):\n def test_send_1(self):\n server = Server()\n server.send({\"addr\": 88, \"content\": \"abc\"})\n self.assertEqual(server.send_struct, {\"addr\": 88, \"content\": \"abc\"})\n\n def test_send_2(self):\n server = Server()\n flag = server.send({\"addr\": 88})\n self.assertEqual(flag, \"info structure is not correct\")\n\n def test_send_3(self):\n server = Server()\n flag = server.send({\"content\": \"abc\"})\n self.assertEqual(flag, \"info structure is not correct\")\n\n def test_send_4(self):\n server = Server()\n flag = server.send([])\n self.assertEqual(flag, \"info structure is not correct\")\n\n def test_send_5(self):\n server = Server()\n server.send({\"addr\": 66, \"content\": \"abc\"})\n self.assertEqual(server.send_struct, {\"addr\": 66, \"content\": \"abc\"})", "solution_code": "def send(self, info):\n if not isinstance(info, dict) or \"addr\" not in info or \"content\" not in info:\n return \"info structure is not correct\"\n self.send_struct = {\"addr\": info[\"addr\"], \"content\": info[\"content\"]}", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.send_struct" ], "method_dependencies": [] } }, { "method_name": "show", "method_description": "def show(self, type):\n \"\"\"\n Returns struct of the specified type\n :param type: string, the type of struct to be returned, which can be 'send' or 'receive'\n :return: if type is equal to 'send' or 'receive', return the corresponding struct; otherwise, return False\n >>> server.recv({\"addr\":88,\"content\":\"abc\"})\n >>> server.send({\"addr\":66,\"content\":\"ABC\"})\n >>> server.show(\"send\")\n {\"addr\":66,\"content\":\"ABC\"}\n \"\"\"", "test_class": "ServerTestShow", "test_code": "class ServerTestShow(unittest.TestCase):\n def test_show_1(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 88, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"send\"), {\"addr\": 88, \"content\": \"abc\"})\n\n def test_show_2(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 88, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"receive\"), {\"addr\": 66, \"content\": \"ABC\"})\n\n def test_show_3(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 88, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"abcdefg\"), False)\n\n def test_show_4(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 11, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"send\"), {\"addr\": 11, \"content\": \"abc\"})\n\n def test_show_5(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 22, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"send\"), {\"addr\": 22, \"content\": \"abc\"})", "solution_code": "def show(self, type):\n if type == \"send\":\n return self.send_struct\n elif type == \"receive\":\n return self.receive_struct\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.receive_struct", "self.send_struct" ], "method_dependencies": [ "send" ] } } ]

[ "ServerTestAddWhiteList", "ServerTestDelWhiteList", "ServerTestRecv", "ServerTestSend", "ServerTestShow", "ServerTest" ]

[ "self.receive_struct", "self.send_struct", "self.white_list" ]

[]

[ { "method_name": "add_item", "method_description": "def add_item(self, item, price, quantity=1):\n \"\"\"\n Add item information to the shopping list items, including price and quantity. The default quantity is 1\n :param item: string, Item to be added\n :param price: float, The price of the item\n :param quantity:int, The number of items, defaults to 1\n :return:None\n >>> shoppingcart = ShoppingCart()\n >>> shoppingcart.add_item(\"apple\", 1, 5)\n self.items = {\"apple\":{\"price\":1, \"quantity\":5}}\n \"\"\"", "test_class": "ShoppingCartTestAddItem", "test_code": "class ShoppingCartTestAddItem(unittest.TestCase):\n def test_add_item_1(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})\n\n def test_add_item_2(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 1}})\n\n def test_add_item_3(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"aaa\", 1)\n self.assertEqual(shoppingcart.items, {\"aaa\": {\"price\": 1, \"quantity\": 1}})\n\n def test_add_item_4(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"bbb\", 1)\n self.assertEqual(shoppingcart.items, {\"bbb\": {\"price\": 1, \"quantity\": 1}})\n\n def test_add_item_5(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"ccc\", 1)\n self.assertEqual(shoppingcart.items, {\"ccc\": {\"price\": 1, \"quantity\": 1}})\n\n def test_add_item_6(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.add_item(\"apple\", 1, 5)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})", "solution_code": "def add_item(self, item, price, quantity=1):\n if item in self.items:\n self.items[item] = {'price': price, 'quantity': quantity}\n else:\n self.items[item] = {'price': price, 'quantity': quantity}", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.items" ], "method_dependencies": [] } }, { "method_name": "remove_item", "method_description": "def remove_item(self, item, quantity=1):\n \"\"\"\n Subtract the specified quantity of item from the shopping list items\n :param item:string, Item to be subtracted in quantity\n :param quantity:int, Quantity to be subtracted\n :return:None\n >>> shoppingcart.add_item(\"apple\", 1, 5)\n >>> shoppingcart.remove_item(\"apple\", 3)\n self.items = {\"apple\":{\"price\":1, \"quantity\":2}}\n \"\"\"", "test_class": "ShoppingCartTestRemoveItem", "test_code": "class ShoppingCartTestRemoveItem(unittest.TestCase):\n def test_remove_item_1(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\", 3)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 2}})\n\n def test_remove_item_2(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\")\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 4}})\n\n def test_remove_item_3(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\", 1)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 4}})\n\n def test_remove_item_4(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\", 2)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 3}})\n\n def test_remove_item_5(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\", 4)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 1}})\n\n def test_remove_item_6(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"banana\", 4)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})", "solution_code": "def remove_item(self, item, quantity=1):\n if item in self.items:\n self.items[item]['quantity'] -= quantity\n else:\n pass", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.items" ], "method_dependencies": [] } }, { "method_name": "view_items", "method_description": "def view_items(self) -> dict:\n \"\"\"\n Return the current shopping list items\n :return:dict, the current shopping list items\n >>> shoppingcart.add_item(\"apple\", 1, 5)\n >>> shoppingcart.remove_item(\"apple\", 3)\n >>> shoppingcart.view_items()\n {\"apple\":{\"price\":1, \"quantity\":2}}\n \"\"\"", "test_class": "ShoppingCartTestViewItems", "test_code": "class ShoppingCartTestViewItems(unittest.TestCase):\n def test_view_items_1(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 5}})\n\n def test_view_items_2(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 4)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 4}})\n\n def test_view_items_3(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 3)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 3}})\n\n def test_view_items_4(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 2)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 2}})\n\n def test_view_items_5(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 1)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 1}})", "solution_code": "def view_items(self) -> dict:\n return self.items", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.items" ], "method_dependencies": [] } }, { "method_name": "total_price", "method_description": "def total_price(self) -> float:\n \"\"\"\n Calculate the total price of all items in the shopping list, which is the quantity of each item multiplied by the price\n :return:float, the total price of all items in the shopping list\n >>> shoppingcart = ShoppingCart()\n >>> shoppingcart.add_item(\"apple\", 1, 5)\n >>> shoppingcart.add_item(\"banana\", 2, 3)\n >>> shoppingcart.total_price()\n 11.0\n \"\"\"", "test_class": "ShoppingCartTestTotalPrice", "test_code": "class ShoppingCartTestTotalPrice(unittest.TestCase):\n def test_total_price_1(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.add_item(\"banana\", 2, 3)\n self.assertEqual(shoppingcart.total_price(), 11.0)\n\n def test_total_price_2(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.add_item(\"banana\", 2, 3)\n shoppingcart.remove_item(\"apple\", 3)\n self.assertEqual(shoppingcart.total_price(), 8.0)\n\n def test_total_price_3(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 1)\n shoppingcart.add_item(\"banana\", 2, 1)\n self.assertEqual(shoppingcart.total_price(), 3.0)\n\n def test_total_price_4(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 2)\n shoppingcart.add_item(\"banana\", 2, 1)\n self.assertEqual(shoppingcart.total_price(), 4.0)\n\n def test_total_price_5(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 3)\n shoppingcart.add_item(\"banana\", 2, 1)\n self.assertEqual(shoppingcart.total_price(), 5.0)", "solution_code": "def total_price(self) -> float:\n return sum([item['quantity'] * item['price'] for item in self.items.values()])", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.items" ], "method_dependencies": [] } } ]

[ "ShoppingCartTestAddItem", "ShoppingCartTestRemoveItem", "ShoppingCartTestViewItems", "ShoppingCartTestTotalPrice", "ShoppingCartTest" ]

[ "self.items" ]

[]

[ { "method_name": "add_user", "method_description": "def add_user(self, username):\n \"\"\"\n Add a user to the sign-in system if the user wasn't in the self.users.\n And the initial state is False.\n :param username: str, the username to be added.\n :return: bool, True if the user is added successfully, False if the user already exists.\n >>> signInSystem.add_user(\"mike\")\n True\n >>> signInSystem.add_user(\"mike\")\n False\n \"\"\"", "test_class": "SignInSystemTestAddUser", "test_code": "class SignInSystemTestAddUser(unittest.TestCase):\n def test_add_user_1(self):\n signin_system = SignInSystem()\n result = signin_system.add_user(\"user1\")\n self.assertTrue(result)\n\n def test_add_user_2(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n result = signin_system.add_user(\"user1\")\n self.assertFalse(result)\n\n def test_add_user_3(self):\n signin_system = SignInSystem()\n result = signin_system.add_user(\"aaa\")\n self.assertTrue(result)\n\n def test_add_user_4(self):\n signin_system = SignInSystem()\n result = signin_system.add_user(\"bbb\")\n self.assertTrue(result)\n\n def test_add_user_5(self):\n signin_system = SignInSystem()\n result = signin_system.add_user(\"ccc\")\n self.assertTrue(result)", "solution_code": "def add_user(self, username):\n if username in self.users:\n return False\n else:\n self.users[username] = False\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.users" ], "method_dependencies": [] } }, { "method_name": "sign_in", "method_description": "def sign_in(self, username):\n \"\"\"\n Sign in a user if the user was in the self.users and change the state to True.\n :param username: str, the username to be signed in.\n :return: bool, True if the user is signed in successfully, False if the user does not exist.\n >>> signInSystem.sign_in(\"mike\")\n True\n >>> signInSystem.sign_in(\"mik\")\n False\n \"\"\"", "test_class": "SignInSystemTestSignIn", "test_code": "class SignInSystemTestSignIn(unittest.TestCase):\n def test_sign_in_1(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n result = signin_system.sign_in(\"user1\")\n self.assertTrue(result)\n\n # user not exist\n def test_sign_in_2(self):\n signin_system = SignInSystem()\n result = signin_system.sign_in(\"user1\")\n self.assertFalse(result)\n\n def test_sign_in_3(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n result = signin_system.sign_in(\"aaa\")\n self.assertTrue(result)\n\n def test_sign_in_4(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"bbb\")\n result = signin_system.sign_in(\"bbb\")\n self.assertTrue(result)\n\n def test_sign_in_5(self):\n signin_system = SignInSystem()\n result = signin_system.sign_in(\"ccc\")\n self.assertFalse(result)", "solution_code": "def sign_in(self, username):\n if username not in self.users:\n return False\n else:\n self.users[username] = True\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.users" ], "method_dependencies": [] } }, { "method_name": "check_sign_in", "method_description": "def check_sign_in(self, username):\n \"\"\"\n Check if a user is signed in.\n :param username: str, the username to be checked.\n :return: bool, True if the user is signed in, False if the user does not exist or is not signed in.\n >>> signInSystem.check_sign_in(\"jack\")\n False\n >>> signInSystem.add_user(\"jack\")\n >>> signInSystem.check_sign_in(\"jack\")\n >>> signInSystem.sign_in(\"jack\")\n >>> signInSystem.check_sign_in(\"jack\")\n True\n \"\"\"", "test_class": "SignInSystemTestCheckSignIn", "test_code": "class SignInSystemTestCheckSignIn(unittest.TestCase):\n # has signed in\n def test_check_sign_in_1(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.sign_in(\"user1\")\n result = signin_system.check_sign_in(\"user1\")\n self.assertTrue(result)\n\n # hasn't signed in \n def test_check_sign_in_2(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n result = signin_system.check_sign_in(\"user1\")\n self.assertFalse(result)\n\n # not exist\n def test_check_sign_in_3(self):\n signin_system = SignInSystem()\n result = signin_system.check_sign_in(\"user1\")\n self.assertFalse(result)\n\n def test_check_sign_in_4(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n signin_system.sign_in(\"aaa\")\n result = signin_system.check_sign_in(\"aaa\")\n self.assertTrue(result)\n\n def test_check_sign_in_5(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"bbb\")\n signin_system.sign_in(\"bbb\")\n result = signin_system.check_sign_in(\"bbb\")\n self.assertTrue(result)", "solution_code": "def check_sign_in(self, username):\n if username not in self.users:\n return False\n else:\n if self.users[username]:\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.users" ], "method_dependencies": [] } }, { "method_name": "all_signed_in", "method_description": "def all_signed_in(self):\n \"\"\"\n Check if all users are signed in.\n :return: bool, True if all users are signed in, False otherwise.\n >>> signInSystem.add_user(\"jack\")\n True\n >>> signInSystem.sign_in(\"jack\")\n >>> signInSystem.all_signed_in()\n True\n \"\"\"", "test_class": "SignInSystemTestAllSignedIn", "test_code": "class SignInSystemTestAllSignedIn(unittest.TestCase):\n def test_all_signed_in_1(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.sign_in(\"user1\")\n result = signin_system.all_signed_in()\n self.assertTrue(result)\n\n def test_all_signed_in_2(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n result = signin_system.all_signed_in()\n self.assertFalse(result)\n\n def test_all_signed_in_3(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n signin_system.sign_in(\"aaa\")\n result = signin_system.all_signed_in()\n self.assertTrue(result)\n\n def test_all_signed_in_4(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"bbb\")\n signin_system.sign_in(\"bbb\")\n result = signin_system.all_signed_in()\n self.assertTrue(result)\n\n def test_all_signed_in_5(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n signin_system.add_user(\"bbb\")\n signin_system.sign_in(\"aaa\")\n result = signin_system.all_signed_in()\n self.assertFalse(result)", "solution_code": "def all_signed_in(self):\n if all(self.users.values()):\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.users" ], "method_dependencies": [] } }, { "method_name": "all_not_signed_in", "method_description": "def all_not_signed_in(self):\n \"\"\"\n Get a list of usernames that are not signed in.\n :return: list[str], a list of usernames that are not signed in.\n >>> signInSystem = SignInSystem()\n >>> signInSystem.add_user(\"a\")\n True\n >>> signInSystem.add_user(\"b\")\n True\n >>> signInSystem.all_not_signed_in()\n ['a', 'b']\n \"\"\"", "test_class": "SignInSystemTestAllNotSignedIn", "test_code": "class SignInSystemTestAllNotSignedIn(unittest.TestCase):\n def test_all_not_signed_in_1(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.sign_in(\"user1\")\n result = signin_system.all_not_signed_in()\n self.assertEqual([], result)\n\n def test_all_not_signed_in_2(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.add_user(\"user2\")\n result = signin_system.all_not_signed_in()\n self.assertEqual([\"user1\", \"user2\"], result)\n\n def test_all_not_signed_in_3(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n signin_system.sign_in(\"aaa\")\n result = signin_system.all_not_signed_in()\n self.assertEqual([], result)\n\n def test_all_not_signed_in_4(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.add_user(\"aaa\")\n signin_system.sign_in(\"user1\")\n result = signin_system.all_not_signed_in()\n self.assertEqual(['aaa'], result)\n\n def test_all_not_signed_in_5(self):\n signin_system = SignInSystem()\n result = signin_system.all_not_signed_in()\n self.assertEqual([], result)", "solution_code": "def all_not_signed_in(self):\n not_signed_in_users = []\n for username, signed_in in self.users.items():\n if not signed_in:\n not_signed_in_users.append(username)\n return not_signed_in_users", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.users" ], "method_dependencies": [] } } ]

[ "SignInSystemTestAddUser", "SignInSystemTestSignIn", "SignInSystemTestCheckSignIn", "SignInSystemTestAllSignedIn", "SignInSystemTestAllNotSignedIn", "SignInSystemTestMain" ]

[ "self.users" ]

[ "import random" ]

[ { "method_name": "move", "method_description": "def move(self, direction):\n \"\"\"\n Move the snake in the specified direction. If the new position of the snake's head is equal to the position of the food, then eat the food; If the position of the snake's head is equal to the position of its body, then start over, otherwise its own length plus one.\n :param direction: tuple, representing the direction of movement (x, y).\n :return: None\n >>> snake.move((1,1))\n self.length = 1\n self.positions = [(51, 51), (50, 50)]\n self.score = 10\n \"\"\"", "test_class": "SnakeTestMove", "test_code": "class SnakeTestMove(unittest.TestCase):\n def test_move_1(self):\n snake = Snake(100, 100, 1, (51, 51))\n snake.move((1, 1))\n self.assertEqual(snake.length, 2)\n self.assertEqual(snake.positions[0], (51, 51))\n self.assertEqual(snake.positions[1], (50, 50))\n self.assertEqual(snake.score, 100)\n\n def test_move_2(self):\n snake = Snake(100, 100, 1, (80, 80))\n snake.move((1, 1))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (51, 51))\n self.assertEqual(snake.score, 0)\n\n def test_move_3(self):\n snake = Snake(100, 100, 1, (51, 51))\n snake.move((1, 0))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (51, 50))\n self.assertEqual(snake.score, 0)\n\n def test_move_4(self):\n snake = Snake(100, 100, 1, (51, 51))\n snake.move((0, 0))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (50, 50))\n self.assertEqual(snake.score, 0)\n\n def test_move_5(self):\n snake = Snake(100, 100, 1, (99, 99))\n snake.move((1, 0))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (51, 50))\n self.assertEqual(snake.score, 0)", "solution_code": "def move(self, direction):\n cur = self.positions[0]\n x, y = direction\n\n new = (\n ((cur[0] + (x * self.BLOCK_SIZE)) % self.SCREEN_WIDTH),\n (cur[1] + (y * self.BLOCK_SIZE)) % self.SCREEN_HEIGHT,\n )\n\n if new == self.food_position:\n self.eat_food()\n\n if len(self.positions) > 2 and new in self.positions[2:]:\n self.reset()\n else:\n self.positions.insert(0, new)\n if len(self.positions) > self.length:\n self.positions.pop()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.BLOCK_SIZE", "self.SCREEN_HEIGHT", "self.SCREEN_WIDTH", "self.food_position", "self.length", "self.positions" ], "method_dependencies": [ "reset", "eat_food" ] } }, { "method_name": "random_food_position", "method_description": "def random_food_position(self):\n \"\"\"\n Randomly generate a new food position, but don't place it on the snake.\n :return: None, Change the food position\n \"\"\"", "test_class": "SnakeTestRandomFoodPosition", "test_code": "class SnakeTestRandomFoodPosition(unittest.TestCase):\n def test_random_food_position_1(self):\n snake = Snake(100, 100, 1, (51, 51))\n self.assertEqual(snake.food_position, (51, 51))\n snake.random_food_position()\n self.assertNotIn(snake.food_position, snake.positions)\n self.assertGreaterEqual(snake.food_position[0], 0)\n self.assertGreaterEqual(snake.food_position[1], 0)\n self.assertLessEqual(snake.food_position[0], 100)\n self.assertLessEqual(snake.food_position[1], 100)\n\n def test_random_food_position_2(self):\n snake = Snake(100, 100, 1, (99, 99))\n self.assertEqual(snake.food_position, (99, 99))\n snake.random_food_position()\n self.assertNotIn(snake.food_position, snake.positions)\n self.assertGreaterEqual(snake.food_position[0], 0)\n self.assertGreaterEqual(snake.food_position[1], 0)\n self.assertLessEqual(snake.food_position[0], 100)\n self.assertLessEqual(snake.food_position[1], 100)\n\n def test_random_food_position_3(self):\n snake = Snake(100, 100, 1, (0, 0))\n self.assertEqual(snake.food_position, (0, 0))\n snake.random_food_position()\n self.assertNotIn(snake.food_position, snake.positions)\n self.assertGreaterEqual(snake.food_position[0], 0)\n self.assertGreaterEqual(snake.food_position[1], 0)\n self.assertLessEqual(snake.food_position[0], 100)\n self.assertLessEqual(snake.food_position[1], 100)\n\n def test_random_food_position_4(self):\n snake = Snake(100, 100, 1, (40, 40))\n self.assertEqual(snake.food_position, (40, 40))\n snake.random_food_position()\n self.assertNotIn(snake.food_position, snake.positions)\n self.assertGreaterEqual(snake.food_position[0], 0)\n self.assertGreaterEqual(snake.food_position[1], 0)\n self.assertLessEqual(snake.food_position[0], 100)\n self.assertLessEqual(snake.food_position[1], 100)\n\n def test_random_food_position_5(self):\n snake = Snake(100, 100, 1, (60, 60))\n self.assertEqual(snake.food_position, (60, 60))\n snake.random_food_position()\n self.assertNotIn(snake.food_position, snake.positions)\n self.assertGreaterEqual(snake.food_position[0], 0)\n self.assertGreaterEqual(snake.food_position[1], 0)\n self.assertLessEqual(snake.food_position[0], 100)\n self.assertLessEqual(snake.food_position[1], 100)", "solution_code": "def random_food_position(self):\n while self.food_position in self.positions:\n self.food_position = (random.randint(0, self.SCREEN_WIDTH // self.BLOCK_SIZE - 1) * self.BLOCK_SIZE,\n random.randint(0, self.SCREEN_HEIGHT // self.BLOCK_SIZE - 1) * self.BLOCK_SIZE)", "dependencies": { "Standalone": false, "lib_dependencies": [ "random" ], "field_dependencies": [ "self.BLOCK_SIZE", "self.SCREEN_HEIGHT", "self.SCREEN_WIDTH", "self.food_position", "self.positions" ], "method_dependencies": [] } }, { "method_name": "reset", "method_description": "def reset(self):\n \"\"\"\n Reset the snake to its initial state. Set the length to 1, the snake head position to ((SCREEN_WIDTH/2), (SCREEN_HEIGHT/2)), the score to 0, and randomly generate new food position.\n :return: None\n >>> snake = Snake(100, 100, 1, (51, 51))\n >>> snake.reset()\n self.length = 1\n self.positions = [(50, 50)]\n self.score = 0\n self.random_food_position()\n \"\"\"", "test_class": "SnakeTestReset", "test_code": "class SnakeTestReset(unittest.TestCase):\n def test_reset_1(self):\n snake = Snake(100, 100, 1, (51, 51))\n snake.move((1, 1))\n snake.reset()\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (50, 50))\n self.assertEqual(snake.score, 0)\n\n def test_reset_2(self):\n snake = Snake(100, 100, 1, (51, 51))\n snake.move((0, 1))\n snake.reset()\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (50, 50))\n self.assertEqual(snake.score, 0)\n\n def test_reset_3(self):\n snake = Snake(100, 100, 1, (51, 51))\n snake.move((0, -1))\n snake.reset()\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (50, 50))\n self.assertEqual(snake.score, 0)\n\n def test_reset_4(self):\n snake = Snake(100, 100, 1, (51, 51))\n snake.move((-1, 0))\n snake.reset()\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (50, 50))\n self.assertEqual(snake.score, 0)\n\n def test_reset_5(self):\n snake = Snake(100, 100, 1, (51, 51))\n snake.move((1, 0))\n snake.reset()\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.positions[0], (50, 50))\n self.assertEqual(snake.score, 0)", "solution_code": "def reset(self):\n self.length = 1\n self.positions = [((self.SCREEN_WIDTH / 2), (self.SCREEN_HEIGHT / 2))]\n self.score = 0\n self.random_food_position()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.SCREEN_HEIGHT", "self.SCREEN_WIDTH", "self.length", "self.positions", "self.score" ], "method_dependencies": [ "random_food_position" ] } }, { "method_name": "eat_food", "method_description": "def eat_food(self):\n \"\"\"\n Increase the length of the snake by 1 and increase the score by 100. Randomly generate a new food position, but\n don't place it on the snake.\n :return: None\n >>> snake = Snake(100, 100, 1, (51, 51))\n >>> snake.move((1,1))\n >>> snake.eat_food()\n self.length = 2\n self.score = 10\n \"\"\"", "test_class": "SnakeTestEatFood", "test_code": "class SnakeTestEatFood(unittest.TestCase):\n def test_eat_food_1(self):\n snake = Snake(100, 100, 1, (51, 51))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.score, 0)\n snake.eat_food()\n self.assertEqual(snake.length, 2)\n self.assertEqual(snake.score, 100)\n\n def test_eat_food_2(self):\n snake = Snake(100, 100, 1, (51, 51))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.score, 0)\n snake.eat_food()\n snake.eat_food()\n self.assertEqual(snake.length, 3)\n self.assertEqual(snake.score, 200)\n\n def test_eat_food_3(self):\n snake = Snake(100, 100, 1, (51, 51))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.score, 0)\n snake.eat_food()\n snake.eat_food()\n snake.eat_food()\n self.assertEqual(snake.length, 4)\n self.assertEqual(snake.score, 300)\n\n def test_eat_food_4(self):\n snake = Snake(100, 100, 1, (51, 51))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.score, 0)\n snake.eat_food()\n snake.eat_food()\n snake.eat_food()\n snake.eat_food()\n self.assertEqual(snake.length, 5)\n self.assertEqual(snake.score, 400)\n\n def test_eat_food_5(self):\n snake = Snake(100, 100, 1, (51, 51))\n self.assertEqual(snake.length, 1)\n self.assertEqual(snake.score, 0)\n snake.eat_food()\n snake.eat_food()\n snake.eat_food()\n snake.eat_food()\n snake.eat_food()\n self.assertEqual(snake.length, 6)\n self.assertEqual(snake.score, 500)", "solution_code": "def eat_food(self):\n self.length += 1\n self.score += 100\n self.random_food_position()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.length", "self.score" ], "method_dependencies": [ "random_food_position" ] } } ]

[ "SnakeTestMove", "SnakeTestRandomFoodPosition", "SnakeTestReset", "SnakeTestEatFood", "SnakeTest" ]

[ "self.BLOCK_SIZE", "self.SCREEN_HEIGHT", "self.SCREEN_WIDTH", "self.food_position", "self.length", "self.positions", "self.score" ]

[ "import re" ]

[ { "method_name": "split_sentences", "method_description": "def split_sentences(self, sentences_string):\n \"\"\"\n Split a string into a list of sentences. Sentences end with . or ? and with a space after that. Please note that Mr. also end with . but are not sentences.\n :param sentences_string: string, string to split\n :return:list, split sentence list\n >>> ss = SplitSentence()\n >>> ss.split_sentences(\"aaa aaaa. bb bbbb bbb? cccc cccc. dd ddd?\")\n ['aaa aaaa.', 'bb bbbb bbb?', 'cccc cccc.', 'dd ddd?']\n \"\"\"", "test_class": "SplitSentenceTestSplitSentences", "test_code": "class SplitSentenceTestSplitSentences(unittest.TestCase):\n def test_split_sentences_1(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb? cccc cccc. dd ddd?\")\n self.assertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?', 'cccc cccc.', 'dd ddd?'])\n\n def test_split_sentences_2(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"Who is Mr. Smith? He is a teacher.\")\n self.assertEqual(lst, ['Who is Mr. Smith?', 'He is a teacher.'])\n\n def test_split_sentences_3(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"Who is A.B.C.? He is a teacher.\")\n self.assertEqual(lst, ['Who is A.B.C.?', 'He is a teacher.'])\n\n def test_split_sentences_4(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb? cccc cccc.\")\n self.assertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?', 'cccc cccc.'])\n\n def test_split_sentences_5(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb?\")\n self.assertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?'])", "solution_code": "def split_sentences(self, sentences_string):\n sentences = re.split(r'(?<!\\w\\.\\w.)(?<![A-Z][a-z]\\.)(?<=\\.|\\?)\\s', sentences_string)\n return sentences", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "count_words", "method_description": "def count_words(self, sentence):\n \"\"\"\n Count the number of words in a sentence. Note that words are separated by spaces and that punctuation marks and numbers are not counted as words.\n :param sentence:string, sentence to be counted, where words are separated by spaces\n :return:int, number of words in the sentence\n >>> ss.count_words(\"abc def\")\n 2\n \"\"\"", "test_class": "SplitSentenceTestCountWords", "test_code": "class SplitSentenceTestCountWords(unittest.TestCase):\n def test_count_words_1(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc def\")\n self.assertEqual(cnt, 2)\n\n def test_count_words_2(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc def 1\")\n self.assertEqual(cnt, 2)\n\n def test_count_words_3(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc 1\")\n self.assertEqual(cnt, 1)\n\n def test_count_words_4(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc def bbb1\")\n self.assertEqual(cnt, 3)\n\n def test_count_words_5(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc def 111\")\n self.assertEqual(cnt, 2)", "solution_code": "def count_words(self, sentence):\n sentence = re.sub(r'[^a-zA-Z\\s]', '', sentence)\n words = sentence.split()\n return len(words)", "dependencies": { "Standalone": false, "lib_dependencies": [ "re" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "process_text_file", "method_description": "def process_text_file(self, sentences_string):\n \"\"\"\n Given a text, return the number of words in the longest sentence\n :param sentences_string: string, undivided long sentence\n :return:int, the number of words in the longest sentence\n >>> ss.process_text_file(\"aaa aaaa. bb bbbb bbb? cccc ccccccc cc ccc. dd ddd?\")\n 4\n \"\"\"", "test_class": "SplitSentenceTestProcessTextFile", "test_code": "class SplitSentenceTestProcessTextFile(unittest.TestCase):\n def test_process_text_file_1(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb? cccc ccccccc cc ccc. dd ddd?\")\n self.assertEqual(cnt, 4)\n\n def test_process_text_file_2(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"Mr. Smith is a teacher. Yes.\")\n self.assertEqual(cnt, 5)\n\n def test_process_text_file_3(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"Mr. Smith is a teacher. Yes 1 2 3 4 5 6.\")\n self.assertEqual(cnt, 5)\n\n def test_process_text_file_4(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb? cccc ccccccc cc ccc.\")\n self.assertEqual(cnt, 4)\n\n def test_process_text_file_5(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb?\")\n self.assertEqual(cnt, 3)", "solution_code": "def process_text_file(self, sentences_string):\n sentences = self.split_sentences(sentences_string)\n max_count = 0\n for sentence in sentences:\n count = self.count_words(sentence)\n if count > max_count:\n max_count = count\n\n return max_count", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "split_sentences", "count_words" ] } } ]

[ "SplitSentenceTestSplitSentences", "SplitSentenceTestCountWords", "SplitSentenceTestProcessTextFile", "SplitSentenceTest" ]

[]

[]

[ { "method_name": "select", "method_description": "def select(self, fields=None, condition=None):\n \"\"\"\n Generates a SELECT SQL statement based on the specified fields and conditions.\n :param fields: list, optional. Default is None. The list of fields to be queried.\n :param condition: str, optional. Default is None. The condition expression for the query.\n :return: str. The generated SQL statement.\n >>> sql = SQLGenerator('table1')\n >>> sql.select(['field1', 'field2'], 'filed3 = value1')\n 'SELECT field1, field2 FROM table1 WHERE filed3 = value1;'\n \"\"\"", "test_class": "SQLGeneratorTestSelect", "test_code": "class SQLGeneratorTestSelect(unittest.TestCase):\n def test_select_1(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1'], \"field2 = value1\")\n self.assertEqual(result, \"SELECT field1 FROM table1 WHERE field2 = value1;\")\n\n def test_select_2(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1', 'field2'], \"field3 = value1\")\n self.assertEqual(result, \"SELECT field1, field2 FROM table1 WHERE field3 = value1;\")\n\n def test_select_3(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1, field2'], \"field3 = value1\")\n self.assertEqual(result, \"SELECT field1, field2 FROM table1 WHERE field3 = value1;\")\n\n def test_select_4(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1, field2'], \"field3 = value1, field4 = value2\")\n self.assertEqual(result, \"SELECT field1, field2 FROM table1 WHERE field3 = value1, field4 = value2;\")\n\n def test_select_5(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1'], \"field2 = value1, field3 = value2\")\n self.assertEqual(result, \"SELECT field1 FROM table1 WHERE field2 = value1, field3 = value2;\")\n\n def test_select_6(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1'])\n self.assertEqual(result, \"SELECT field1 FROM table1;\")", "solution_code": "def select(self, fields=None, condition=None):\n if fields is None:\n fields = \"*\"\n else:\n fields = \", \".join(fields)\n sql = f\"SELECT {fields} FROM {self.table_name}\"\n if condition is not None:\n sql += f\" WHERE {condition}\"\n return sql + \";\"", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.table_name" ], "method_dependencies": [] } }, { "method_name": "insert", "method_description": "def insert(self, data):\n \"\"\"\n Generates an INSERT SQL statement based on the given data.\n :param data: dict. The data to be inserted, in dictionary form where keys are field names and values are field values.\n :return: str. The generated SQL statement.\n >>> sql.insert({'key1': 'value1', 'key2': 'value2'})\n \"INSERT INTO table1 (key1, key2) VALUES ('value1', 'value2');\"\n \"\"\"", "test_class": "SQLGeneratorTestInsert", "test_code": "class SQLGeneratorTestInsert(unittest.TestCase):\n def test_insert(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2'})\n self.assertEqual(result, \"INSERT INTO table1 (field1, field2) VALUES ('value1', 'value2');\")\n\n def test_insert_2(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2', 'field3': 'value3'})\n self.assertEqual(result, \"INSERT INTO table1 (field1, field2, field3) VALUES ('value1', 'value2', 'value3');\")\n\n def test_insert_3(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2', 'field3': 'value3', 'field4': 'value4'})\n self.assertEqual(result,\n \"INSERT INTO table1 (field1, field2, field3, field4) VALUES ('value1', 'value2', 'value3', 'value4');\")\n\n def test_insert_4(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2', 'field3': 'value3', 'field4': 'value4',\n 'field5': 'value5'})\n self.assertEqual(result,\n \"INSERT INTO table1 (field1, field2, field3, field4, field5) VALUES ('value1', 'value2', 'value3', 'value4', 'value5');\")\n\n def test_insert_5(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2', 'field3': 'value3', 'field4': 'value4',\n 'field5': 'value5', 'field6': 'value6'})\n self.assertEqual(result,\n \"INSERT INTO table1 (field1, field2, field3, field4, field5, field6) VALUES ('value1', 'value2', 'value3', 'value4', 'value5', 'value6');\")", "solution_code": "def insert(self, data):\n fields = \", \".join(data.keys())\n values = \", \".join([f\"'{value}'\" for value in data.values()])\n sql = f\"INSERT INTO {self.table_name} ({fields}) VALUES ({values})\"\n return sql + \";\"", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.table_name" ], "method_dependencies": [] } }, { "method_name": "update", "method_description": "def update(self, data, condition):\n \"\"\"\n Generates an UPDATE SQL statement based on the given data and condition.\n :param data: dict. The data to be updated, in dictionary form where keys are field names and values are new field values.\n :param condition: str. The condition expression for the update.\n :return: str. The generated SQL statement.\n >>> sql.update({'field1': 'new_value1', 'field2': 'new_value2'}, \"field3 = value1\")\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2' WHERE field3 = value1;\"\n \"\"\"", "test_class": "SQLGeneratorTestUpdate", "test_code": "class SQLGeneratorTestUpdate(unittest.TestCase):\n def test_update(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2'}, \"field3 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2' WHERE field3 = value1;\")\n\n def test_update_2(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2', 'field3': 'new_value3'},\n \"field4 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2', field3 = 'new_value3' WHERE field4 = value1;\")\n\n def test_update_3(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2', 'field3': 'new_value3',\n 'field4': 'new_value4'}, \"field5 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2', field3 = 'new_value3', field4 = 'new_value4' WHERE field5 = value1;\")\n\n def test_update_4(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2', 'field3': 'new_value3',\n 'field4': 'new_value4', 'field5': 'new_value5'}, \"field6 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2', field3 = 'new_value3', field4 = 'new_value4', field5 = 'new_value5' WHERE field6 = value1;\")\n\n def test_update_5(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2', 'field3': 'new_value3',\n 'field4': 'new_value4', 'field5': 'new_value5', 'field6': 'new_value6'},\n \"field7 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2', field3 = 'new_value3', field4 = 'new_value4', field5 = 'new_value5', field6 = 'new_value6' WHERE field7 = value1;\")", "solution_code": "def update(self, data, condition):\n set_clause = \", \".join([f\"{field} = '{value}'\" for field, value in data.items()])\n sql = f\"UPDATE {self.table_name} SET {set_clause} WHERE {condition}\"\n return sql + \";\"", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.table_name" ], "method_dependencies": [] } }, { "method_name": "delete", "method_description": "def delete(self, condition):\n \"\"\"\n Generates a DELETE SQL statement based on the given condition.\n :param condition: str. The condition expression for the delete.\n :return: str. The generated SQL statement.\n >>> sql.delete(\"field1 = value1\")\n 'DELETE FROM table1 WHERE field1 = value1;'\n \"\"\"", "test_class": "SQLGeneratorTestDelete", "test_code": "class SQLGeneratorTestDelete(unittest.TestCase):\n def test_delete(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1\")\n self.assertEqual(result, \"DELETE FROM table1 WHERE field1 = value1;\")\n\n def test_delete_2(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1 AND field2 = value2\")\n self.assertEqual(result, \"DELETE FROM table1 WHERE field1 = value1 AND field2 = value2;\")\n\n def test_delete_3(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1 AND field2 = value2 AND field3 = value3\")\n self.assertEqual(result, \"DELETE FROM table1 WHERE field1 = value1 AND field2 = value2 AND field3 = value3;\")\n\n def test_delete_4(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1 AND field2 = value2 AND field3 = value3 AND field4 = value4\")\n self.assertEqual(result,\n \"DELETE FROM table1 WHERE field1 = value1 AND field2 = value2 AND field3 = value3 AND field4 = value4;\")\n\n def test_delete_5(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1 AND field2 = value2 AND field3 = value3 AND field4 = value4 AND field5 = value5\")\n self.assertEqual(result,\n \"DELETE FROM table1 WHERE field1 = value1 AND field2 = value2 AND field3 = value3 AND field4 = value4 AND field5 = value5;\")", "solution_code": "def delete(self, condition):\n sql = f\"DELETE FROM {self.table_name} WHERE {condition}\"\n return sql + \";\"", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.table_name" ], "method_dependencies": [] } }, { "method_name": "select_female_under_age", "method_description": "def select_female_under_age(self, age):\n \"\"\"\n Generates a SQL statement to select females under a specified age.\n :param age: int. The specified age.\n :return: str. The generated SQL statement.\n >>> sql.select_female_under_age(30)\n \"SELECT * FROM table1 WHERE age < 30 AND gender = 'female';\"\n \"\"\"", "test_class": "SQLGeneratorTestSelectFemaleUnderAge", "test_code": "class SQLGeneratorTestSelectFemaleUnderAge(unittest.TestCase):\n def test_select_female_under_age(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(30)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age < 30 AND gender = 'female';\")\n\n def test_select_female_under_age_2(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(40)\n self.assertEqual(result,\"SELECT * FROM table1 WHERE age < 40 AND gender = 'female';\")\n\n def test_select_female_under_age_3(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(20)\n self.assertEqual(result,\"SELECT * FROM table1 WHERE age < 20 AND gender = 'female';\")\n\n def test_select_female_under_age_4(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(10)\n self.assertEqual(result,\"SELECT * FROM table1 WHERE age < 10 AND gender = 'female';\")\n\n def test_select_female_under_age_5(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(50)\n self.assertEqual(result,\"SELECT * FROM table1 WHERE age < 50 AND gender = 'female';\")", "solution_code": "def select_female_under_age(self, age):\n condition = f\"age < {age} AND gender = 'female'\"\n return self.select(condition=condition)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "select" ] } }, { "method_name": "select_by_age_range", "method_description": "def select_by_age_range(self, min_age, max_age):\n \"\"\"\n Generates a SQL statement to select records within a specified age range.\n :param min_age: int. The minimum age.\n :param max_age: int. The maximum age.\n :return: str. The generated SQL statement.\n >>> sql.select_by_age_range(20, 30)\n 'SELECT * FROM table1 WHERE age BETWEEN 20 AND 30;'\n \"\"\"", "test_class": "SQLGeneratorTestSelectByAgeRange", "test_code": "class SQLGeneratorTestSelectByAgeRange(unittest.TestCase):\n def test_select_by_age_range(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(20, 30)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 20 AND 30;\")\n\n def test_select_by_age_range_2(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(10, 20)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 10 AND 20;\")\n\n def test_select_by_age_range_3(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(30, 40)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 30 AND 40;\")\n\n def test_select_by_age_range_4(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(40, 50)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 40 AND 50;\")\n\n def test_select_by_age_range_5(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(50, 60)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 50 AND 60;\")", "solution_code": "def select_by_age_range(self, min_age, max_age):\n condition = f\"age BETWEEN {min_age} AND {max_age}\"\n return self.select(condition=condition)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "select" ] } } ]

[ "SQLGeneratorTestSelect", "SQLGeneratorTestInsert", "SQLGeneratorTestUpdate", "SQLGeneratorTestDelete", "SQLGeneratorTestSelectFemaleUnderAge", "SQLGeneratorTestSelectByAgeRange", "SQLGeneratorTestMain" ]

[ "self.table_name" ]

[]

[ { "method_name": "select", "method_description": "def select(table, columns='*', where=None):\n \"\"\"\n Generate the SELECT SQL statement from the given parameters.\n :param table: str, the query table in database.\n :param columns: list of str, ['col1', 'col2'].\n :param where: dict, {key1: value1, key2: value2 ...}. The query condition.\n return query: str, the SQL query statement.\n >>> SQLQueryBuilder.select('table1', columns = [\"col1\",\"col2\"], where = {\"age\": 15})\n \"SELECT col1, col2 FROM table1 WHERE age='15'\"\n \"\"\"", "test_class": "SQLQueryBuilderTestSelect", "test_code": "class SQLQueryBuilderTestSelect(unittest.TestCase):\n def test_select_1(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"id\", \"name\"], {'age': 30}),\n \"SELECT id, name FROM users WHERE age='30'\"\n )\n\n def test_select_2(self):\n self.assertEqual(\n SQLQueryBuilder.select('students', [\"id\", \"name\"], {'age': 18}),\n \"SELECT id, name FROM students WHERE age='18'\"\n )\n\n def test_select_3(self):\n self.assertEqual(\n SQLQueryBuilder.select('items', [\"id\", \"name\"], {'price': 1.0}),\n \"SELECT id, name FROM items WHERE price='1.0'\"\n )\n\n def test_select_4(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"id\"], {'age': 30}),\n \"SELECT id FROM users WHERE age='30'\"\n )\n\n def test_select_5(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"name\"], {'age': 30}),\n \"SELECT name FROM users WHERE age='30'\"\n )\n\n def test_select_6(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"name\"]),\n \"SELECT name FROM users\"\n )\n\n def test_select_7(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', \"*\"),\n \"SELECT * FROM users\"\n )", "solution_code": "def select(table, columns='*', where=None):\n if columns != '*':\n columns = ', '.join(columns)\n query = f\"SELECT {columns} FROM {table}\"\n if where:\n query += \" WHERE \" + ' AND '.join(f\"{k}='{v}'\" for k, v in where.items())\n return query", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "insert", "method_description": "@staticmethod\n def insert(table, data):\n \"\"\"\n Generate the INSERT SQL statement from the given parameters.\n :param table: str, the table to be inserted in database.\n :param data: dict, the key and value in SQL insert statement\n :return query: str, the SQL insert statement.\n >>> SQLQueryBuilder.insert('table1', {'name': 'Test', 'age': 14})\n \"INSERT INTO table1 (name, age) VALUES ('Test', '14')\"\n \"\"\"", "test_class": "SQLQueryBuilderTestInsert", "test_code": "class SQLQueryBuilderTestInsert(unittest.TestCase):\n def test_insert_1(self):\n self.assertEqual(\n SQLQueryBuilder.insert('users', {'name': 'Tom', 'age': 30}),\n \"INSERT INTO users (name, age) VALUES ('Tom', '30')\"\n )\n\n def test_insert_2(self):\n self.assertEqual(\n SQLQueryBuilder.insert('students', {'name': 'Tom', 'age': 18}),\n \"INSERT INTO students (name, age) VALUES ('Tom', '18')\"\n )\n\n def test_insert_3(self):\n self.assertEqual(\n SQLQueryBuilder.insert('items', {'name': 'apple', 'price': 1.0}),\n \"INSERT INTO items (name, price) VALUES ('apple', '1.0')\"\n )\n\n def test_insert_4(self):\n self.assertEqual(\n SQLQueryBuilder.insert('users', {'name': 'Tom'}),\n \"INSERT INTO users (name) VALUES ('Tom')\"\n )\n\n def test_insert_5(self):\n self.assertEqual(\n SQLQueryBuilder.insert('users', {'name': 'Tom', 'age': 30, 'region': 'USA'}),\n \"INSERT INTO users (name, age, region) VALUES ('Tom', '30', 'USA')\"\n )", "solution_code": "@staticmethod\n def insert(table, data):\n keys = ', '.join(data.keys())\n values = ', '.join(f\"'{v}'\" for v in data.values())\n return f\"INSERT INTO {table} ({keys}) VALUES ({values})\"", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "delete", "method_description": "@staticmethod\n def delete(table, where=None):\n \"\"\"\n Generate the DELETE SQL statement from the given parameters.\n :param table: str, the table that will be excuted with DELETE operation in database\n :param where: dict, {key1: value1, key2: value2 ...}. The query condition.\n :return query: str, the SQL delete statement.\n >>> SQLQueryBuilder.delete('table1', {'name': 'Test', 'age': 14})\n \"DELETE FROM table1 WHERE name='Test' AND age='14'\"\n \"\"\"", "test_class": "SQLQueryBuilderTestDetele", "test_code": "class SQLQueryBuilderTestDetele(unittest.TestCase):\n def test_delete_1(self):\n self.assertEqual(\n SQLQueryBuilder.delete('users', {'name': 'Tom'}),\n \"DELETE FROM users WHERE name='Tom'\"\n )\n\n def test_delete_2(self):\n self.assertEqual(\n SQLQueryBuilder.delete('students', {'name': 'Tom'}),\n \"DELETE FROM students WHERE name='Tom'\"\n )\n\n def test_delete_3(self):\n self.assertEqual(\n SQLQueryBuilder.delete('items', {'name': 'apple'}),\n \"DELETE FROM items WHERE name='apple'\"\n )\n\n def test_delete_4(self):\n self.assertEqual(\n SQLQueryBuilder.delete('items', {'name': 'aaa'}),\n \"DELETE FROM items WHERE name='aaa'\"\n )\n\n def test_delete_5(self):\n self.assertEqual(\n SQLQueryBuilder.delete('items', {'name': 'bbb'}),\n \"DELETE FROM items WHERE name='bbb'\"\n )\n\n def test_delete_6(self):\n self.assertEqual(\n SQLQueryBuilder.delete('items'),\n \"DELETE FROM items\"\n )", "solution_code": "@staticmethod\n def delete(table, where=None):\n query = f\"DELETE FROM {table}\"\n if where:\n query += \" WHERE \" + ' AND '.join(f\"{k}='{v}'\" for k, v in where.items())\n return query", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "update", "method_description": "@staticmethod\n def update(table, data, where=None):\n \"\"\"\n Generate the UPDATE SQL statement from the given parameters.\n :param table: str, the table that will be excuted with UPDATE operation in database\n :param data: dict, the key and value in SQL update statement\n :param where: dict, {key1: value1, key2: value2 ...}. The query condition.\n >>> SQLQueryBuilder.update('table1', {'name': 'Test2', 'age': 15}, where = {'name':'Test'})\n \"UPDATE table1 SET name='Test2', age='15' WHERE name='Test'\"\n \"\"\"", "test_class": "SQLQueryBuilderTestUpdate", "test_code": "class SQLQueryBuilderTestUpdate(unittest.TestCase):\n def test_update_1(self):\n self.assertEqual(\n SQLQueryBuilder.update('users', {'age': 35}, {'name': 'Tom'}),\n \"UPDATE users SET age='35' WHERE name='Tom'\"\n )\n\n def test_update_2(self):\n self.assertEqual(\n SQLQueryBuilder.update('students', {'age': 18}, {'name': 'Tom'}),\n \"UPDATE students SET age='18' WHERE name='Tom'\"\n )\n\n def test_update_3(self):\n self.assertEqual(\n SQLQueryBuilder.update('items', {'price': 1.0}, {'name': 'apple'}),\n \"UPDATE items SET price='1.0' WHERE name='apple'\"\n )\n\n def test_update_4(self):\n self.assertEqual(\n SQLQueryBuilder.update('items', {'price': 1.0}, {'name': 'aaa'}),\n \"UPDATE items SET price='1.0' WHERE name='aaa'\"\n )\n\n def test_update_5(self):\n self.assertEqual(\n SQLQueryBuilder.update('items', {'price': 1.0}, {'name': 'bbb'}),\n \"UPDATE items SET price='1.0' WHERE name='bbb'\"\n )\n\n def test_update_6(self):\n self.assertEqual(\n SQLQueryBuilder.update('items', {'price': 1.0}),\n \"UPDATE items SET price='1.0'\"\n )", "solution_code": "@staticmethod\n def update(table, data, where=None):\n update_str = ', '.join(f\"{k}='{v}'\" for k, v in data.items())\n query = f\"UPDATE {table} SET {update_str}\"\n if where:\n query += \" WHERE \" + ' AND '.join(f\"{k}='{v}'\" for k, v in where.items())\n return query", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "SQLQueryBuilderTestSelect", "SQLQueryBuilderTestInsert", "SQLQueryBuilderTestDetele", "SQLQueryBuilderTestUpdate", "SQLQueryBuilderTestMain" ]

[]

[ "import math" ]

[ { "method_name": "median", "method_description": "def median(data):\n \"\"\"\n calculates the median of the given list.\n :param data: the given list, list.\n :return: the median of the given list, float.\n >>> statistics3 = Statistics3()\n >>> statistics3.median([1, 2, 3, 4])\n 2.5\n\n \"\"\"", "test_class": "Statistics3TestMedian", "test_code": "class Statistics3TestMedian(unittest.TestCase):\n def test_median(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4]), 2.5)\n\n def test_median_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4, 5]), 3)\n\n def test_median_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4, 5, 6]), 3.5)\n\n def test_median_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4, 5, 6, 7]), 4)\n\n def test_median_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4, 5, 6, 7, 8]), 4.5)", "solution_code": "def median(data):\n sorted_data = sorted(data)\n n = len(sorted_data)\n if n % 2 == 1:\n return sorted_data[n // 2]\n else:\n return (sorted_data[n // 2 - 1] + sorted_data[n // 2]) / 2", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "mode", "method_description": "@staticmethod\n def mode(data):\n \"\"\"\n calculates the mode of the given list.\n :param data: the given list, list.\n :return: the mode of the given list, list.\n >>> statistics3 = Statistics3()\n >>> statistics3.mode([1, 2, 3, 3])\n [3]\n\n \"\"\"", "test_class": "Statistics3TestMode", "test_code": "class Statistics3TestMode(unittest.TestCase):\n def test_mode(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3]), [3])\n\n def test_mode_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3, 4, 4]), [3, 4])\n\n def test_mode_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3, 4, 4, 5]), [3, 4])\n\n def test_mode_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3, 4, 4, 5, 5]), [3, 4, 5])\n\n def test_mode_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3, 4, 4, 5, 5, 6]), [3, 4, 5])", "solution_code": "@staticmethod\n def mode(data):\n counts = {}\n for value in data:\n counts[value] = counts.get(value, 0) + 1\n max_count = max(counts.values())\n mode_values = [value for value, count in counts.items() if count == max_count]\n return mode_values", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "correlation", "method_description": "@staticmethod\n def correlation(x, y):\n \"\"\"\n calculates the correlation of the given list.\n :param x: the given list, list.\n :param y: the given list, list.\n :return: the correlation of the given list, float.\n >>> statistics3 = Statistics3()\n >>> statistics3.correlation([1, 2, 3], [4, 5, 6])\n 1.0\n\n \"\"\"", "test_class": "Statistics3TestCorrelation", "test_code": "class Statistics3TestCorrelation(unittest.TestCase):\n def test_correlation(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 2, 3], [4, 5, 6]), 1.0)\n\n def test_correlation_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 2, 3, 4], [5, 6, 7, 8]), 1.0)\n\n def test_correlation_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 2, 3], [1,2,3]), 1.0)\n\n def test_correlation_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 1,1], [2,2,2]), None)\n\n def test_correlation_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 1,1], [1,1,1]), None)", "solution_code": "@staticmethod\n def correlation(x, y):\n n = len(x)\n mean_x = sum(x) / n\n mean_y = sum(y) / n\n numerator = sum((xi - mean_x) * (yi - mean_y) for xi, yi in zip(x, y))\n denominator = math.sqrt(sum((xi - mean_x) ** 2 for xi in x) * sum((yi - mean_y) ** 2 for yi in y))\n if denominator == 0:\n return None\n return numerator / denominator", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [], "method_dependencies": [ "mean" ] } }, { "method_name": "mean", "method_description": "@staticmethod\n def mean(data):\n \"\"\"\n calculates the mean of the given list.\n :param data: the given list, list.\n :return: the mean of the given list, float.\n >>> statistics3 = Statistics3()\n >>> statistics3.mean([1, 2, 3])\n 2.0\n\n \"\"\"", "test_class": "Statistics3TestMean", "test_code": "class Statistics3TestMean(unittest.TestCase):\n def test_mean(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([1, 2, 3]), 2.0)\n\n def test_mean_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([]), None)\n\n def test_mean_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([1, 1, 1]), 1.0)\n\n def test_mean_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([1, 1, 1, 1]), 1.0)\n\n def test_mean_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([1, 1, 1, 1, 1]), 1.0)", "solution_code": "@staticmethod\n def mean(data):\n if len(data) == 0:\n return None\n return sum(data) / len(data)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "correlation_matrix", "method_description": "@staticmethod\n def correlation_matrix(data):\n \"\"\"\n calculates the correlation matrix of the given list.\n :param data: the given list, list.\n :return: the correlation matrix of the given list, list.\n >>> statistics3 = Statistics3()\n >>> statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]\n\n \"\"\"", "test_class": "Statistics3TestCorrelationMatrix", "test_code": "class Statistics3TestCorrelationMatrix(unittest.TestCase):\n def test_correlation_matrix(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n\n def test_correlation_matrix_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n\n def test_correlation_matrix_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3]]), [[None, None, None], [None, None, None], [None, None, None]])\n\n def test_correlation_matrix_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11,12]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n\n def test_correlation_matrix_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11,12], [13, 14, 15]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])", "solution_code": "@staticmethod\n def correlation_matrix(data):\n matrix = []\n for i in range(len(data[0])):\n row = []\n for j in range(len(data[0])):\n column1 = [row[i] for row in data]\n column2 = [row[j] for row in data]\n correlation = Statistics3.correlation(column1, column2)\n row.append(correlation)\n matrix.append(row)\n return matrix", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "correlation" ] } }, { "method_name": "standard_deviation", "method_description": "@staticmethod\n def standard_deviation(data):\n \"\"\"\n calculates the standard deviation of the given list.\n :param data: the given list, list.\n :return: the standard deviation of the given list, float.\n >>> statistics3 = Statistics3()\n >>> statistics3.standard_deviation([1, 2, 3])\n 1.0\n\n \"\"\"", "test_class": "Statistics3TestStandardDeviation", "test_code": "class Statistics3TestStandardDeviation(unittest.TestCase):\n def test_standard_deviation(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 2, 3]), 1.0)\n\n def test_standard_deviation_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 1, 1]), 0.0)\n\n def test_standard_deviation_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 1]), 0.0)\n\n def test_standard_deviation_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 1, 1, 1]), 0.0)\n\n def test_standard_deviation_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 1, 2, 1, 4]), 1.3038404810405297)", "solution_code": "@staticmethod\n def standard_deviation(data):\n n = len(data)\n if n < 2:\n return None\n mean_value = Statistics3.mean(data)\n variance = sum((x - mean_value) ** 2 for x in data) / (n - 1)\n return math.sqrt(variance)", "dependencies": { "Standalone": false, "lib_dependencies": [ "math" ], "field_dependencies": [], "method_dependencies": [ "mean" ] } }, { "method_name": "z_score", "method_description": "@staticmethod\n def z_score(data):\n \"\"\"\n calculates the z-score of the given list.\n :param data: the given list, list.\n :return: the z-score of the given list, list.\n >>> statistics3 = Statistics3()\n >>> statistics3.z_score([1, 2, 3, 4])\n [-1.161895003862225, -0.3872983346207417, 0.3872983346207417, 1.161895003862225]\n\n \"\"\"", "test_class": "Statistics3TestZScore", "test_code": "class Statistics3TestZScore(unittest.TestCase):\n def test_z_score(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1, 2, 3, 4]), [-1.161895003862225, -0.3872983346207417, 0.3872983346207417, 1.161895003862225])\n\n def test_z_score_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1, 1, 1, 1]), None)\n\n def test_z_score_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1]),None)\n\n def test_z_score_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1, 1, 2, 3]), [-0.7833494518006403,-0.7833494518006403,0.26111648393354675,1.3055824196677337])\n\n def test_z_score_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1, 1, 1, 1, 1]), None)", "solution_code": "@staticmethod\n def z_score(data):\n mean = Statistics3.mean(data)\n std_deviation = Statistics3.standard_deviation(data)\n if std_deviation is None or std_deviation == 0:\n return None\n return [(x - mean) / std_deviation for x in data]", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "mean", "standard_deviation" ] } } ]

[ "Statistics3TestMedian", "Statistics3TestMode", "Statistics3TestCorrelation", "Statistics3TestMean", "Statistics3TestCorrelationMatrix", "Statistics3TestStandardDeviation", "Statistics3TestZScore", "Statistics3TestMain" ]

[]

[]

[ { "method_name": "add_stock", "method_description": "def add_stock(self, stock):\n \"\"\"\n Add a stock to the portfolio.\n :param stock: a dictionary with keys \"name\", \"price\", and \"quantity\"\n >>> tracker = StockPortfolioTracker(10000.0)\n >>> tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n >>> tracker.portfolio\n [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n\n \"\"\"", "test_class": "StockPortfolioTrackerTestAddStock", "test_code": "class StockPortfolioTrackerTestAddStock(unittest.TestCase):\n def test_add_stock(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n\n def test_add_stock_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20}])\n\n def test_add_stock_3(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n\n def test_add_stock_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n\n def test_add_stock_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10})\n tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 20}])", "solution_code": "def add_stock(self, stock):\n for pf in self.portfolio:\n if pf['name'] == stock['name']:\n pf['quantity'] += stock['quantity']\n return\n\n self.portfolio.append(stock)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.portfolio" ], "method_dependencies": [] } }, { "method_name": "remove_stock", "method_description": "def remove_stock(self, stock):\n \"\"\"\n Remove a stock from the portfolio.\n :param stock: a dictionary with keys \"name\", \"price\", and \"quantity\"\n >>> tracker = StockPortfolioTracker(10000.0)\n >>> tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n >>> tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n True\n >>> tracker.portfolio\n []\n\n \"\"\"", "test_class": "StockPortfolioTrackerTestRemoveStock", "test_code": "class StockPortfolioTrackerTestRemoveStock(unittest.TestCase):\n def test_remove_stock(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [])\n\n def test_remove_stock_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n\n def test_remove_stock_3(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 20}), False)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n\n def test_remove_stock_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), False)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n\n def test_remove_stock_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])", "solution_code": "def remove_stock(self, stock):\n for pf in self.portfolio:\n if pf['name'] == stock['name'] and pf['quantity'] >= stock['quantity']:\n pf['quantity'] -= stock['quantity']\n if pf['quantity'] == 0:\n self.portfolio.remove(pf)\n return True\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.portfolio" ], "method_dependencies": [] } }, { "method_name": "buy_stock", "method_description": "def buy_stock(self, stock):\n \"\"\"\n Buy a stock and add it to the portfolio.\n :param stock: a dictionary with keys \"name\", \"price\", and \"quantity\"\n :param quantity: the quantity of the stock to buy,int.\n :return: True if the stock was bought successfully, False if the cash balance is not enough.\n >>> tracker = StockPortfolioTracker(10000.0)\n >>> tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n True\n >>> tracker.portfolio\n [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n\n \"\"\"", "test_class": "StockPortfolioTrackerTestBuyStock", "test_code": "class StockPortfolioTrackerTestBuyStock(unittest.TestCase):\n def test_buy_stock(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 8500.0)\n\n def test_buy_stock_2(self):\n tracker = StockPortfolioTracker(1000.0)\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), False)\n self.assertEqual(tracker.portfolio, [])\n self.assertEqual(tracker.cash_balance, 1000.0)\n\n def test_buy_stock_3(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20}])\n self.assertEqual(tracker.cash_balance, 8500.0)\n\n def test_buy_stock_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.buy_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.buy_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 20}])\n self.assertEqual(tracker.cash_balance, 7000.0)\n\n def test_buy_stock_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.buy_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 7000.0)", "solution_code": "def buy_stock(self, stock):\n if stock['price'] * stock['quantity'] > self.cash_balance:\n return False\n else:\n self.add_stock(stock)\n self.cash_balance -= stock['price'] * stock['quantity']\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.cash_balance" ], "method_dependencies": [ "add_stock" ] } }, { "method_name": "sell_stock", "method_description": "def sell_stock(self, stock):\n \"\"\"\n Sell a stock and remove it from the portfolio and add the cash to the cash balance.\n :param stock: a dictionary with keys \"name\", \"price\", and \"quantity\"\n :param quantity: the quantity of the stock to sell,int.\n :return: True if the stock was sold successfully, False if the quantity of the stock is not enough.\n >>> tracker = StockPortfolioTracker(10000.0)\n >>> tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n >>> tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n True\n >>> tracker.portfolio\n []\n\n \"\"\"", "test_class": "StockPortfolioTrackerTestSellStock", "test_code": "class StockPortfolioTrackerTestSellStock(unittest.TestCase):\n def test_sell_stock(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 9}), True)\n self.assertEqual(tracker.portfolio, [{\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 1}])\n self.assertEqual(tracker.cash_balance, 11350.0)\n\n def test_sell_stock_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 20}), False)\n self.assertEqual(tracker.portfolio, [{\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}])\n self.assertEqual(tracker.cash_balance, 10000.0)\n\n def test_sell_stock_3(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), False)\n self.assertEqual(tracker.portfolio, [])\n self.assertEqual(tracker.cash_balance, 10000.0)\n\n def test_sell_stock_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 20}]\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 20}), True)\n self.assertEqual(tracker.portfolio, [])\n self.assertEqual(tracker.cash_balance, 13000.0)\n\n def test_sell_stock_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 20}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 13000.0)", "solution_code": "def sell_stock(self, stock):\n if self.remove_stock(stock) == False:\n return False\n self.cash_balance += stock['price'] * stock['quantity']\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.cash_balance" ], "method_dependencies": [ "remove_stock" ] } }, { "method_name": "calculate_portfolio_value", "method_description": "def calculate_portfolio_value(self):\n \"\"\"\n Calculate the total value of the portfolio.\n :return: the total value of the portfolio, float.\n >>> tracker = StockPortfolioTracker(10000.0)\n >>> tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n >>> tracker.calculate_portfolio_value()\n 11500.0\n\n \"\"\"", "test_class": "StockPortfolioTrackerTestCalculatePortfolioValue", "test_code": "class StockPortfolioTrackerTestCalculatePortfolioValue(unittest.TestCase):\n def test_calculate_portfolio_value(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.calculate_portfolio_value(), 11500.0)\n\n def test_calculate_portfolio_value_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.calculate_portfolio_value(), 13000.0)\n\n def test_calculate_portfolio_value_3(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.calculate_portfolio_value(), 10000.0)\n\n def test_calculate_portfolio_value_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 0}]\n self.assertEqual(tracker.calculate_portfolio_value(), 10000.0)\n\n def test_calculate_portfolio_value_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 0.0, 'quantity': 10}]\n self.assertEqual(tracker.calculate_portfolio_value(), 10000.0)", "solution_code": "def calculate_portfolio_value(self):\n total_value = self.cash_balance\n for stock in self.portfolio:\n total_value += stock['price'] * stock['quantity']\n return total_value", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.cash_balance", "self.portfolio" ], "method_dependencies": [] } }, { "method_name": "get_portfolio_summary", "method_description": "def get_portfolio_summary(self):\n \"\"\"\n Get a summary of the portfolio.\n :return: a tuple of the total value of the portfolio and a list of dictionaries with keys \"name\" and \"value\"\n >>> tracker = StockPortfolioTracker(10000.0)\n >>> tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n >>> tracker.get_portfolio_summary()\n (11500.0, [{'name': 'AAPL', 'value': 1500.0}])\n\n \"\"\"", "test_class": "StockPortfolioTrackerTestGetPortfolioSummary", "test_code": "class StockPortfolioTrackerTestGetPortfolioSummary(unittest.TestCase):\n def test_get_portfolio_summary(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.get_portfolio_summary(), (11500.0, [{'name': 'AAPL', 'value': 1500.0}]))\n\n def test_get_portfolio_summary_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.get_portfolio_summary(),\n (13000.0, [{'name': 'AAPL', 'value': 1500.0}, {'name': 'MSFT', 'value': 1500.0}]))\n\n def test_get_portfolio_summary_3(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_portfolio_summary(), (10000.0, []))\n\n def test_get_portfolio_summary_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 0}]\n self.assertEqual(tracker.get_portfolio_summary(), (10000.0, [{'name': 'AAPL', 'value': 0.0}]))\n\n def test_get_portfolio_summary_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 0.0, 'quantity': 10}]\n self.assertEqual(tracker.get_portfolio_summary(), (10000.0, [{'name': 'AAPL', 'value': 0.0}]))", "solution_code": "def get_portfolio_summary(self):\n summary = []\n for stock in self.portfolio:\n value = self.get_stock_value(stock)\n summary.append({\"name\": stock[\"name\"], \"value\": value})\n portfolio_value = self.calculate_portfolio_value()\n return portfolio_value, summary", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.portfolio" ], "method_dependencies": [ "calculate_portfolio_value", "get_stock_value" ] } }, { "method_name": "get_stock_value", "method_description": "def get_stock_value(self, stock):\n \"\"\"\n Get the value of a stock.\n :param stock: a dictionary with keys \"name\", \"price\", and \"quantity\"\n :return: the value of the stock, float.\n >>> tracker = StockPortfolioTracker(10000.0)\n >>> tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n 1500.0\n\n \"\"\"", "test_class": "StockPortfolioTrackerTestGetStockValue", "test_code": "class StockPortfolioTrackerTestGetStockValue(unittest.TestCase):\n def test_get_stock_value(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), 1500.0)\n\n def test_get_stock_value_2(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 0}), 0.0)\n\n def test_get_stock_value_3(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 0.0, \"quantity\": 10}), 0.0)\n\n def test_get_stock_value_4(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 0.0, \"quantity\": 0}), 0.0)\n\n def test_get_stock_value_5(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"MSFL\", \"price\": 150.0, \"quantity\": 2}), 300.0)", "solution_code": "def get_stock_value(self, stock):\n return stock['price'] * stock['quantity']", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "StockPortfolioTrackerTestAddStock", "StockPortfolioTrackerTestRemoveStock", "StockPortfolioTrackerTestBuyStock", "StockPortfolioTrackerTestSellStock", "StockPortfolioTrackerTestCalculatePortfolioValue", "StockPortfolioTrackerTestGetPortfolioSummary", "StockPortfolioTrackerTestGetStockValue", "StockPortfolioTrackerTestMain" ]

[ "self.cash_balance", "self.portfolio" ]

[ "import sqlite3" ]

[ { "method_name": "create_student_table", "method_description": "def create_student_table(self):\n \"\"\"\n Creates a \"students\" table in the database if it does not exist already.Fields include ID of type int, name of type str, age of type int, gender of type str, and grade of type int\n :return: None\n >>> processor = StudentDatabaseProcessor(\"students.db\")\n >>> processor.create_student_table()\n \"\"\"", "test_class": "StudentDatabaseProcessorTestInsertStudent", "test_code": "class StudentDatabaseProcessorTestInsertStudent(unittest.TestCase):\n def setUp(self):\n self.processor = StudentDatabaseProcessor(\"test_database.db\")\n self.processor.create_student_table()\n\n def tearDown(self):\n conn = sqlite3.connect(\"test_database.db\")\n conn.execute(\"DROP TABLE IF EXISTS students\")\n conn.commit()\n conn.close()\n\n def test_insert_student_1(self):\n student_data = {\n 'name': 'Alice',\n 'age': 20,\n 'gender': 'female',\n 'grade': 90\n }\n self.processor.insert_student(student_data)\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('Alice',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'Alice')\n\n def test_insert_student_2(self):\n student_data = {\n 'name': 'aaa',\n 'age': 20,\n 'gender': 'female',\n 'grade': 90\n }\n self.processor.insert_student(student_data)\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('aaa',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'aaa')\n\n def test_insert_student_3(self):\n student_data = {\n 'name': 'bbb',\n 'age': 20,\n 'gender': 'female',\n 'grade': 90\n }\n self.processor.insert_student(student_data)\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('bbb',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'bbb')\n\n def test_insert_student_4(self):\n student_data = {\n 'name': 'ccc',\n 'age': 20,\n 'gender': 'female',\n 'grade': 90\n }\n self.processor.insert_student(student_data)\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('ccc',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'ccc')\n\n def test_insert_student_5(self):\n student_data = {\n 'name': 'ddd',\n 'age': 20,\n 'gender': 'female',\n 'grade': 90\n }\n self.processor.insert_student(student_data)\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('ddd',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'ddd')", "solution_code": "def create_student_table(self):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n\n create_table_query = \"\"\"\n CREATE TABLE IF NOT EXISTS students (\n id INTEGER PRIMARY KEY,\n name TEXT,\n age INTEGER,\n gender TEXT,\n grade INTEGER\n )\n \"\"\"\n cursor.execute(create_table_query)\n\n conn.commit()\n conn.close()", "dependencies": { "Standalone": false, "lib_dependencies": [ "sqlite3" ], "field_dependencies": [ "self.database_name" ], "method_dependencies": [] } }, { "method_name": "insert_student", "method_description": "def insert_student(self, student_data):\n \"\"\"\n Inserts a new student into the \"students\" table.\n :param student_data: dict, a dictionary containing the student's information (name, age, gender, grade).\n :return: None\n >>> processor = StudentDatabaseProcessor(\"students.db\")\n >>> processor.create_student_table()\n >>> student_data = {'name': 'John', 'age': 15, 'gender': 'Male', 'grade': 9}\n >>> processor.insert_student(student_data)\n \"\"\"", "test_class": "StudentDatabaseProcessorTestSearchStudentByName", "test_code": "class StudentDatabaseProcessorTestSearchStudentByName(unittest.TestCase):\n def setUp(self):\n self.processor = StudentDatabaseProcessor(\"test_database.db\")\n self.processor.create_student_table()\n\n def tearDown(self):\n conn = sqlite3.connect(\"test_database.db\")\n conn.execute(\"DROP TABLE IF EXISTS students\")\n conn.commit()\n conn.close()\n\n def test_search_student_by_name_1(self):\n student_data = {\n 'name': 'Bob',\n 'age': 19,\n 'gender': 'male',\n 'grade': 85\n }\n self.processor.insert_student(student_data)\n\n result = self.processor.search_student_by_name('Bob')\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'Bob')\n\n def test_search_student_by_name_2(self):\n student_data = {\n 'name': 'aaa',\n 'age': 19,\n 'gender': 'male',\n 'grade': 85\n }\n self.processor.insert_student(student_data)\n\n result = self.processor.search_student_by_name('aaa')\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'aaa')\n\n def test_search_student_by_name_3(self):\n student_data = {\n 'name': 'bbb',\n 'age': 19,\n 'gender': 'male',\n 'grade': 85\n }\n self.processor.insert_student(student_data)\n\n result = self.processor.search_student_by_name('bbb')\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'bbb')\n\n def test_search_student_by_name_4(self):\n student_data = {\n 'name': 'ccc',\n 'age': 19,\n 'gender': 'male',\n 'grade': 85\n }\n self.processor.insert_student(student_data)\n\n result = self.processor.search_student_by_name('ccc')\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'ccc')\n\n def test_search_student_by_name_5(self):\n student_data = {\n 'name': 'ddd',\n 'age': 19,\n 'gender': 'male',\n 'grade': 85\n }\n self.processor.insert_student(student_data)\n\n result = self.processor.search_student_by_name('ddd')\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'ddd')", "solution_code": "def insert_student(self, student_data):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n\n insert_query = \"\"\"\n INSERT INTO students (name, age, gender, grade)\n VALUES (?, ?, ?, ?)\n \"\"\"\n cursor.execute(insert_query,\n (student_data['name'], student_data['age'], student_data['gender'], student_data['grade']))\n\n conn.commit()\n conn.close()", "dependencies": { "Standalone": false, "lib_dependencies": [ "sqlite3" ], "field_dependencies": [ "self.database_name" ], "method_dependencies": [] } }, { "method_name": "search_student_by_name", "method_description": "def search_student_by_name(self, name):\n \"\"\"\n Searches for a student in the \"students\" table by their name.\n :param name: str, the name of the student to search for.\n :return: list of tuples, the rows from the \"students\" table that match the search criteria.\n >>> processor = StudentDatabaseProcessor(\"students.db\")\n >>> processor.create_student_table()\n >>> result = processor.search_student_by_name(\"John\")\n \"\"\"", "test_class": "StudentDatabaseProcessorTestDeleteStudentByName", "test_code": "class StudentDatabaseProcessorTestDeleteStudentByName(unittest.TestCase):\n def setUp(self):\n self.processor = StudentDatabaseProcessor(\"test_database.db\")\n self.processor.create_student_table()\n\n def tearDown(self):\n conn = sqlite3.connect(\"test_database.db\")\n conn.execute(\"DROP TABLE IF EXISTS students\")\n conn.commit()\n conn.close()\n\n def test_delete_student_by_name_1(self):\n student_data = {\n 'name': 'Charlie',\n 'age': 18,\n 'gender': 'male',\n 'grade': 95\n }\n self.processor.insert_student(student_data)\n\n self.processor.delete_student_by_name('Charlie')\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('Charlie',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 0)\n\n def test_delete_student_by_name_2(self):\n student_data = {\n 'name': 'aaa',\n 'age': 18,\n 'gender': 'male',\n 'grade': 95\n }\n self.processor.insert_student(student_data)\n\n self.processor.delete_student_by_name('aaa')\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('aaa',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 0)\n\n def test_delete_student_by_name_3(self):\n student_data = {\n 'name': 'bbb',\n 'age': 18,\n 'gender': 'male',\n 'grade': 95\n }\n self.processor.insert_student(student_data)\n\n self.processor.delete_student_by_name('bbb')\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('bbb',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 0)\n\n def test_delete_student_by_name_4(self):\n student_data = {\n 'name': 'ccc',\n 'age': 18,\n 'gender': 'male',\n 'grade': 95\n }\n self.processor.insert_student(student_data)\n\n self.processor.delete_student_by_name('ccc')\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('ccc',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 0)\n\n def test_delete_student_by_name_5(self):\n student_data = {\n 'name': 'ddd',\n 'age': 18,\n 'gender': 'male',\n 'grade': 95\n }\n self.processor.insert_student(student_data)\n\n self.processor.delete_student_by_name('ddd')\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('ddd',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 0)", "solution_code": "def search_student_by_name(self, name):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n\n select_query = \"SELECT * FROM students WHERE name = ?\"\n cursor.execute(select_query, (name,))\n result = cursor.fetchall()\n\n conn.close()\n\n return result", "dependencies": { "Standalone": false, "lib_dependencies": [ "sqlite3" ], "field_dependencies": [ "self.database_name" ], "method_dependencies": [] } }, { "method_name": "delete_student_by_name", "method_description": "def delete_student_by_name(self, name):\n \"\"\"\n Deletes a student from the \"students\" table by their name.\n :param name: str, the name of the student to delete.\n :return: None\n >>> processor = StudentDatabaseProcessor(\"students.db\")\n >>> processor.create_student_table()\n >>> student_data = {'name': 'John', 'age': 15, 'gender': 'Male', 'grade': 9}\n >>> processor.insert_student(student_data)\n >>> processor.delete_student_by_name(\"John\")\n \"\"\"", "test_class": "StudentDatabaseProcessorTest", "test_code": "class StudentDatabaseProcessorTest(unittest.TestCase):\n def setUp(self):\n self.processor = StudentDatabaseProcessor(\"test_database.db\")\n self.processor.create_student_table()\n\n def tearDown(self):\n conn = sqlite3.connect(\"test_database.db\")\n conn.execute(\"DROP TABLE IF EXISTS students\")\n conn.commit()\n conn.close()\n\n def test_StudentDatabaseProcessor(self):\n student_data = {\n 'name': 'Alice',\n 'age': 20,\n 'gender': 'female',\n 'grade': 90\n }\n self.processor.insert_student(student_data)\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('Alice',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'Alice')\n\n student_data = {\n 'name': 'Bob',\n 'age': 19,\n 'gender': 'male',\n 'grade': 85\n }\n self.processor.insert_student(student_data)\n\n result = self.processor.search_student_by_name('Bob')\n\n self.assertEqual(len(result), 1)\n self.assertEqual(result[0][1], 'Bob')\n\n student_data = {\n 'name': 'Charlie',\n 'age': 18,\n 'gender': 'male',\n 'grade': 95\n }\n self.processor.insert_student(student_data)\n\n self.processor.delete_student_by_name('Charlie')\n\n conn = sqlite3.connect(\"test_database.db\")\n cursor = conn.cursor()\n cursor.execute(\"SELECT * FROM students WHERE name=?\", ('Charlie',))\n result = cursor.fetchall()\n conn.close()\n\n self.assertEqual(len(result), 0)", "solution_code": "def delete_student_by_name(self, name):\n conn = sqlite3.connect(self.database_name)\n cursor = conn.cursor()\n\n delete_query = \"DELETE FROM students WHERE name = ?\"\n cursor.execute(delete_query, (name,))\n\n conn.commit()\n conn.close()", "dependencies": { "Standalone": false, "lib_dependencies": [ "sqlite3" ], "field_dependencies": [ "self.database_name" ], "method_dependencies": [] } } ]

[ "StudentDatabaseProcessorTestInsertStudent", "StudentDatabaseProcessorTestSearchStudentByName", "StudentDatabaseProcessorTestDeleteStudentByName", "StudentDatabaseProcessorTest" ]

[ "self.database_name" ]

[ "import json" ]

[ { "method_name": "read_file_as_json", "method_description": "def read_file_as_json(self):\n \"\"\"\n Read the self.file_path file as json format.\n if the file content doesn't obey json format, the code will raise error.\n :return data: dict if the file is stored as json format, or str/int/float.. according to the file content otherwise.\n >>> textFileProcessor = TextFileProcessor('test.json')\n >>> textFileProcessor.read_file_as_json()\n {'name': 'test', 'age': 12}\n >>> type(textFileProcessor.read_file_as_json())\n <class 'dict'>\n \"\"\"", "test_class": "TextFileProcessorTestReadFileAsJson", "test_code": "class TextFileProcessorTestReadFileAsJson(unittest.TestCase):\n def setUp(self):\n self.files = ['test_1.txt', 'test_2.txt', 'test_3.txt', 'test_4.txt', 'test_5.txt']\n self.contents = ['{\\n \"name\": \"test\",\\n \"age\": 12\\n}', '12345', '\\\"hello\\\"', '\\\"aaa\\\"', '\\\"bbb\\\"']\n for index, file in enumerate(self.files):\n with open(file, 'w') as f:\n f.write(self.contents[index])\n\n # the dict type\n def test_read_file_as_json_1(self):\n textFileProcessor = TextFileProcessor(self.files[0])\n data = textFileProcessor.read_file_as_json()\n expected = {\"name\": \"test\", \"age\": 12}\n self.assertEqual(dict, type(data))\n self.assertEqual(expected, data)\n\n # the int type\n def test_read_file_as_json_2(self):\n textFileProcessor = TextFileProcessor(self.files[1])\n data = textFileProcessor.read_file_as_json()\n expected = 12345\n self.assertEqual(int, type(data))\n self.assertEqual(expected, data)\n\n # the str type\n def test_read_file_as_json_3(self):\n textFileProcessor = TextFileProcessor(self.files[2])\n data = textFileProcessor.read_file_as_json()\n expected = 'hello'\n self.assertEqual(str, type(data))\n self.assertEqual(expected, data)\n\n def test_read_file_as_json_4(self):\n textFileProcessor = TextFileProcessor(self.files[3])\n data = textFileProcessor.read_file_as_json()\n expected = 'aaa'\n self.assertEqual(str, type(data))\n self.assertEqual(expected, data)\n\n def test_read_file_as_json_5(self):\n textFileProcessor = TextFileProcessor(self.files[4])\n data = textFileProcessor.read_file_as_json()\n expected = 'bbb'\n self.assertEqual(str, type(data))\n self.assertEqual(expected, data)", "solution_code": "def read_file_as_json(self):\n with open(self.file_path, 'r') as file:\n data = json.load(file)\n\n return data", "dependencies": { "Standalone": false, "lib_dependencies": [ "json" ], "field_dependencies": [ "self.file_path" ], "method_dependencies": [] } }, { "method_name": "read_file", "method_description": "def read_file(self):\n \"\"\"\n Read the return the content of self.file_path file.\n :return: the same return as the read() method\n >>> textFileProcessor = TextFileProcessor('test.json')\n >>> textFileProcessor.read_file()\n '{\\n \"name\": \"test\",\\n \"age\": 12\\n}'\n \"\"\"", "test_class": "TextFileProcessorTestReadFile", "test_code": "class TextFileProcessorTestReadFile(unittest.TestCase):\n def setUp(self) -> None:\n self.files = ['test_1.txt', 'test_2.txt', 'test_3.txt', 'test_4.txt', 'test_5.txt']\n self.contents = ['123aac\\n&^(*&43)', '12345', 'aaa', 'bbb', 'ccc']\n for index, file in enumerate(self.files):\n with open(file, 'w') as f:\n f.write(self.contents[index])\n\n def test_read_file_1(self):\n textFileProcessor = TextFileProcessor(self.files[0])\n data = textFileProcessor.read_file()\n self.assertEqual(str, type(data))\n self.assertEqual(data, self.contents[0])\n\n def test_read_file_2(self):\n textFileProcessor = TextFileProcessor(self.files[1])\n data = textFileProcessor.read_file()\n self.assertEqual(str, type(data))\n self.assertEqual(data, self.contents[1])\n\n def test_read_file_3(self):\n textFileProcessor = TextFileProcessor(self.files[2])\n data = textFileProcessor.read_file()\n self.assertEqual(str, type(data))\n self.assertEqual(data, self.contents[2])\n\n def test_read_file_4(self):\n textFileProcessor = TextFileProcessor(self.files[3])\n data = textFileProcessor.read_file()\n self.assertEqual(str, type(data))\n self.assertEqual(data, self.contents[3])\n\n def test_read_file_5(self):\n textFileProcessor = TextFileProcessor(self.files[4])\n data = textFileProcessor.read_file()\n self.assertEqual(str, type(data))\n self.assertEqual(data, self.contents[4])", "solution_code": "def read_file(self):\n with open(self.file_path, 'r') as file:\n return file.read()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.file_path" ], "method_dependencies": [] } }, { "method_name": "write_file", "method_description": "def write_file(self, content):\n \"\"\"\n Write content into the self.file_path file, and overwrite if the file has already existed.\n :param content: any content\n >>> textFileProcessor = TextFileProcessor('test.json')\n >>> textFileProcessor.write_file('Hello world!')\n >>> textFileProcessor.read_file()\n 'Hello world!'\n \"\"\"", "test_class": "TextFileProcessorTestWriteFile", "test_code": "class TextFileProcessorTestWriteFile(unittest.TestCase):\n def setUp(self) -> None:\n self.files = ['test_1.txt', 'test_2.txt', 'test_3.txt', 'test_4.txt', 'test_5.txt']\n self.contents = ['123aac\\n&^(*&43)', '12345', 'aaa', 'bbb', 'ccc']\n\n def tearDown(self) -> None:\n for file in self.files:\n if os.path.exists(file):\n os.remove(file)\n\n def test_write_file_1(self):\n textFileProcessor = TextFileProcessor(self.files[0])\n textFileProcessor.write_file(self.contents[0])\n with open(self.files[0], 'r') as f:\n data = f.read()\n self.assertEqual(data, self.contents[0])\n\n def test_write_file_2(self):\n textFileProcessor = TextFileProcessor(self.files[1])\n textFileProcessor.write_file(self.contents[1])\n with open(self.files[1], 'r') as f:\n data = f.read()\n self.assertEqual(data, self.contents[1])\n\n def test_write_file_3(self):\n textFileProcessor = TextFileProcessor(self.files[2])\n textFileProcessor.write_file(self.contents[2])\n with open(self.files[2], 'r') as f:\n data = f.read()\n self.assertEqual(data, self.contents[2])\n\n def test_write_file_4(self):\n textFileProcessor = TextFileProcessor(self.files[3])\n textFileProcessor.write_file(self.contents[3])\n with open(self.files[3], 'r') as f:\n data = f.read()\n self.assertEqual(data, self.contents[3])\n\n def test_write_file_5(self):\n textFileProcessor = TextFileProcessor(self.files[4])\n textFileProcessor.write_file(self.contents[4])\n with open(self.files[4], 'r') as f:\n data = f.read()\n self.assertEqual(data, self.contents[4])", "solution_code": "def write_file(self, content):\n with open(self.file_path, 'w') as file:\n file.write(content)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.file_path" ], "method_dependencies": [] } }, { "method_name": "process_file", "method_description": "def process_file(self):\n \"\"\"\n Read the self.file_path file and filter out non-alphabetic characters from the content string.\n Overwrite the after-processed data into the same self.file_path file.\n >>> textFileProcessor = TextFileProcessor('test.json')\n >>> textFileProcessor.read_file()\n '{\\n \"name\": \"test\",\\n \"age\": 12\\n}'\n >>> textFileProcessor.process_file()\n 'nametestage'\n \"\"\"", "test_class": "TextFileProcessorTestProcessFile", "test_code": "class TextFileProcessorTestProcessFile(unittest.TestCase):\n def test_process_file_1(self):\n self.file = 'test.txt'\n self.content = 'Hello, 123 World!'\n self.expected_result = 'HelloWorld'\n\n textFileProcessor = TextFileProcessor(self.file)\n textFileProcessor.read_file = MagicMock(return_value=self.content)\n textFileProcessor.write_file = MagicMock()\n\n result = textFileProcessor.process_file()\n self.assertEqual(result, self.expected_result)\n textFileProcessor.read_file.assert_called_once()\n textFileProcessor.write_file.assert_called_once_with(self.expected_result)\n\n def test_process_file_2(self):\n self.file = 'test.txt'\n self.content = 'Hello, abc World!'\n self.expected_result = 'HelloabcWorld'\n\n textFileProcessor = TextFileProcessor(self.file)\n textFileProcessor.read_file = MagicMock(return_value=self.content)\n textFileProcessor.write_file = MagicMock()\n\n result = textFileProcessor.process_file()\n self.assertEqual(result, self.expected_result)\n textFileProcessor.read_file.assert_called_once()\n textFileProcessor.write_file.assert_called_once_with(self.expected_result)\n\n def test_process_file_3(self):\n self.file = 'test.txt'\n self.content = ', 123 !'\n self.expected_result = ''\n\n textFileProcessor = TextFileProcessor(self.file)\n textFileProcessor.read_file = MagicMock(return_value=self.content)\n textFileProcessor.write_file = MagicMock()\n\n result = textFileProcessor.process_file()\n self.assertEqual(result, self.expected_result)\n textFileProcessor.read_file.assert_called_once()\n textFileProcessor.write_file.assert_called_once_with(self.expected_result)\n\n def test_process_file_4(self):\n self.file = 'test.txt'\n self.content = 'Hello, World!'\n self.expected_result = 'HelloWorld'\n\n textFileProcessor = TextFileProcessor(self.file)\n textFileProcessor.read_file = MagicMock(return_value=self.content)\n textFileProcessor.write_file = MagicMock()\n\n result = textFileProcessor.process_file()\n self.assertEqual(result, self.expected_result)\n textFileProcessor.read_file.assert_called_once()\n textFileProcessor.write_file.assert_called_once_with(self.expected_result)\n\n def test_process_file_5(self):\n self.file = 'test.txt'\n self.content = 'Hello, 123a World!'\n self.expected_result = 'HelloaWorld'\n\n textFileProcessor = TextFileProcessor(self.file)\n textFileProcessor.read_file = MagicMock(return_value=self.content)\n textFileProcessor.write_file = MagicMock()\n\n result = textFileProcessor.process_file()\n self.assertEqual(result, self.expected_result)\n textFileProcessor.read_file.assert_called_once()\n textFileProcessor.write_file.assert_called_once_with(self.expected_result)", "solution_code": "def process_file(self):\n content = self.read_file()\n content = ''.join([char for char in content if char.isalpha()])\n self.write_file(content)\n return content", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "read_file", "write_file" ] } } ]

[ "TextFileProcessorTestReadFileAsJson", "TextFileProcessorTestReadFile", "TextFileProcessorTestWriteFile", "TextFileProcessorTestProcessFile", "TextFileProcessorTestMain" ]

[ "self.file_path" ]

[ "import time" ]

[ { "method_name": "get_target_temperature", "method_description": "def get_target_temperature(self):\n \"\"\"\n Get the target temperature of an instance of the Thermostat class.\n :return self.current_temperature: int\n >>> thermostat.get_target_temperature()\n 37.5\n \"\"\"", "test_class": "ThermostatTestGetTargetTemperature", "test_code": "class ThermostatTestGetTargetTemperature(unittest.TestCase):\n def test_get_target_temperature_1(self):\n t = Thermostat(20, 25, 'heat')\n self.assertEqual(t.get_target_temperature(), 25)\n\n def test_get_target_temperature_2(self):\n t = Thermostat(20, 25, 'cool')\n self.assertEqual(t.get_target_temperature(), 25)\n\n def test_get_target_temperature_3(self):\n t = Thermostat(20, 25, 'test')\n self.assertEqual(t.get_target_temperature(), 25)\n\n def test_get_target_temperature_4(self):\n t = Thermostat(25, 25, 'cool')\n self.assertEqual(t.get_target_temperature(), 25)\n\n def test_get_target_temperature_5(self):\n t = Thermostat(25, 25, 'heat')\n self.assertEqual(t.get_target_temperature(), 25)", "solution_code": "def get_target_temperature(self):\n return self.target_temperature", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.target_temperature" ], "method_dependencies": [] } }, { "method_name": "set_target_temperature", "method_description": "def set_target_temperature(self, temperature):\n \"\"\"\n Set the target temperature\n :param temperature: float, the target temperature\n >>> thermostat.set_target_temperature(37.6)\n >>> thermostat.target_temperature\n 37.6\n \"\"\"", "test_class": "ThermostatTestSetTargetTemperature", "test_code": "class ThermostatTestSetTargetTemperature(unittest.TestCase):\n def test_set_target_temperature_1(self):\n t = Thermostat(20, 25, 'heat')\n t.set_target_temperature(30)\n self.assertEqual(t.get_target_temperature(), 30)\n\n def test_set_target_temperature_2(self):\n t = Thermostat(20, 25, 'cool')\n t.set_target_temperature(10)\n self.assertEqual(t.get_target_temperature(), 10)\n\n def test_set_target_temperature_3(self):\n t = Thermostat(20, 25, 'test')\n t.set_target_temperature(10)\n self.assertEqual(t.get_target_temperature(), 10)\n\n def test_set_target_temperature_4(self):\n t = Thermostat(25, 25, 'cool')\n t.set_target_temperature(10)\n self.assertEqual(t.get_target_temperature(), 10)\n\n def test_set_target_temperature_5(self):\n t = Thermostat(25, 25, 'heat')\n t.set_target_temperature(10)\n self.assertEqual(t.get_target_temperature(), 10)", "solution_code": "def set_target_temperature(self, temperature):\n self.target_temperature = temperature", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.target_temperature" ], "method_dependencies": [] } }, { "method_name": "get_mode", "method_description": "def get_mode(self):\n \"\"\"\n Get the current work mode\n :return mode: str, working mode. only ['heat', 'cool']\n \"\"\"", "test_class": "ThermostatTestGetMode", "test_code": "class ThermostatTestGetMode(unittest.TestCase):\n def test_get_mode_1(self):\n t = Thermostat(20, 25, 'heat')\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_get_mode_2(self):\n t = Thermostat(20, 25, 'cool')\n self.assertEqual(t.get_mode(), 'cool')\n\n def test_get_mode_3(self):\n t = Thermostat(20, 25, 'test')\n self.assertEqual(t.get_mode(), 'test')\n\n def test_get_mode_4(self):\n t = Thermostat(25, 25, 'cool')\n self.assertEqual(t.get_mode(), 'cool')\n\n def test_get_mode_5(self):\n t = Thermostat(25, 25, 'heat')\n self.assertEqual(t.get_mode(), 'heat')", "solution_code": "def get_mode(self):\n return self.mode", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.mode" ], "method_dependencies": [] } }, { "method_name": "set_mode", "method_description": "def set_mode(self, mode):\n \"\"\"\n Get the current work mode\n :param mode: str, working mode. only ['heat', 'cool']\n >>> thermostat.set_mode('cool')\n >>> thermostat.mode\n 'cool'\n \"\"\"", "test_class": "ThermostatTestSetMode", "test_code": "class ThermostatTestSetMode(unittest.TestCase):\n def test_set_mode_1(self):\n t = Thermostat(20, 25, 'heat')\n t.set_mode('cool')\n self.assertEqual(t.get_mode(), 'cool')\n\n # use mode that not in ['heat', 'cool']\n def test_set_mode_2(self):\n t = Thermostat(20, 25, 'heat')\n self.assertFalse(t.set_mode('test'))\n\n def test_set_mode_3(self):\n t = Thermostat(20, 25, 'cool')\n t.set_mode('heat')\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_set_mode_4(self):\n t = Thermostat(20, 25, 'test')\n t.set_mode('heat')\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_set_mode_5(self):\n t = Thermostat(25, 25, 'cool')\n t.set_mode('heat')\n self.assertEqual(t.get_mode(), 'heat')", "solution_code": "def set_mode(self, mode):\n if mode in ['heat', 'cool']:\n self.mode = mode\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.mode" ], "method_dependencies": [] } }, { "method_name": "auto_set_mode", "method_description": "def auto_set_mode(self):\n \"\"\"\n Automatically set the operating mode by comparing with the current temperature and target temperature. If the current temperature is lower than the target temperature, the operating mode is set to 'heat', otherwise it is set to 'cool'.\n >>> thermostat = Thermostat(20.4, 37.5, 'cool')\n >>> thermostat.auto_set_mode()\n >>> thermostat.mode\n 'heat'\n \"\"\"", "test_class": "ThermostatTestAutoSetMode", "test_code": "class ThermostatTestAutoSetMode(unittest.TestCase):\n def test_auto_set_mode_1(self):\n t = Thermostat(20, 25, 'heat')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_auto_set_mode_2(self):\n t = Thermostat(25, 20, 'heat')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'cool')\n\n def test_auto_set_mode_3(self):\n t = Thermostat(25, 20, 'cool')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'cool')\n\n def test_auto_set_mode_4(self):\n t = Thermostat(20, 25, 'cool')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_auto_set_mode_5(self):\n t = Thermostat(25, 25, 'cool')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'cool')", "solution_code": "def auto_set_mode(self):\n if self.current_temperature < self.target_temperature:\n self.mode = 'heat'\n else:\n self.mode = 'cool'", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.current_temperature", "self.mode", "self.target_temperature" ], "method_dependencies": [] } }, { "method_name": "auto_check_conflict", "method_description": "def auto_check_conflict(self):\n \"\"\"\n Check if there is a conflict between the operating mode and the relationship between the current temperature and the target temperature.\n If there is a conflict, the operating mode will be adjusted automatically.\n :return: True if mode isn't conflict with the relationship between the current temperature and the target temperature, or False otherwise.\n >>> thermostat = Thermostat(20.4, 37.5, 'cool')\n >>> thermostat.auto_check_conflict()\n False\n >>> thermostat.mode\n 'heat'\n \"\"\"", "test_class": "ThermostatTestAutoCheckConflict", "test_code": "class ThermostatTestAutoCheckConflict(unittest.TestCase):\n def test_auto_check_conflict_1(self):\n t = Thermostat(30, 25, 'cool')\n self.assertTrue(t.auto_check_conflict())\n\n def test_auto_check_conflict_2(self):\n t = Thermostat(30, 25, 'heat')\n self.assertFalse(t.auto_check_conflict())\n self.assertEqual(t.mode, 'cool')\n\n def test_auto_check_conflict_3(self):\n t = Thermostat(25, 30, 'heat')\n self.assertTrue(t.auto_check_conflict())\n\n def test_auto_check_conflict_4(self):\n t = Thermostat(25, 30, 'cool')\n self.assertFalse(t.auto_check_conflict())\n self.assertEqual(t.mode, 'heat')\n\n def test_auto_check_conflict_5(self):\n t = Thermostat(25, 25, 'cool')\n self.assertFalse(t.auto_check_conflict())\n self.assertEqual(t.mode, 'cool')", "solution_code": "def auto_check_conflict(self):\n if self.current_temperature > self.target_temperature:\n if self.mode == 'cool':\n return True\n else:\n self.auto_set_mode()\n return False\n else:\n if self.mode == 'heat':\n return True\n else:\n self.auto_set_mode()\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.current_temperature", "self.mode", "self.target_temperature" ], "method_dependencies": [ "set_mode", "auto_set_mode" ] } }, { "method_name": "simulate_operation", "method_description": "def simulate_operation(self):\n \"\"\"\n simulate the operation of Thermostat. It will automatically start the auto_set_mode method to set the operating mode,\n and then automatically adjust the current temperature according to the operating mode until the target temperature is reached.\n :return time: int, the time it took to complete the simulation.\n >>> thermostat = Thermostat(20.4, 37.5, 'cool')\n >>> thermostat.simulate_operation()\n 18\n \"\"\"", "test_class": "ThermostatTestSimulateOperation", "test_code": "class ThermostatTestSimulateOperation(unittest.TestCase):\n def test_simulate_operation_1(self):\n t = Thermostat(20, 25, 'heat')\n self.assertEqual(t.simulate_operation(), 5)\n self.assertEqual(t.get_mode(), 'heat')\n self.assertEqual(t.current_temperature, 25)\n\n def test_simulate_operation_2(self):\n t = Thermostat(25.7, 20, 'cool')\n self.assertEqual(t.simulate_operation(), 6)\n self.assertEqual(t.get_mode(), 'cool')\n self.assertEqual(t.current_temperature, 19.7)\n\n def test_simulate_operation_3(self):\n t = Thermostat(25, 25, 'heat')\n self.assertEqual(t.simulate_operation(), 0)\n self.assertEqual(t.get_mode(), 'cool')\n self.assertEqual(t.current_temperature, 25)\n\n def test_simulate_operation_4(self):\n t = Thermostat(25, 25, 'cool')\n self.assertEqual(t.simulate_operation(), 0)\n self.assertEqual(t.get_mode(), 'cool')\n self.assertEqual(t.current_temperature, 25)\n\n def test_simulate_operation_5(self):\n t = Thermostat(25, 25, 'test')\n self.assertEqual(t.simulate_operation(), 0)\n self.assertEqual(t.get_mode(), 'cool')\n self.assertEqual(t.current_temperature, 25)", "solution_code": "def simulate_operation(self):\n self.auto_set_mode()\n use_time = 0\n if self.mode == 'heat':\n while(self.current_temperature < self.target_temperature):\n self.current_temperature += 1\n use_time += 1\n else:\n while(self.current_temperature > self.target_temperature):\n self.current_temperature -= 1\n use_time += 1\n return use_time", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.current_temperature", "self.mode", "self.target_temperature" ], "method_dependencies": [ "set_mode", "auto_set_mode" ] } } ]

[ "ThermostatTestGetTargetTemperature", "ThermostatTestSetTargetTemperature", "ThermostatTestGetMode", "ThermostatTestSetMode", "ThermostatTestAutoSetMode", "ThermostatTestAutoCheckConflict", "ThermostatTestSimulateOperation", "ThermostatTestMain" ]

[ "self.current_temperature", "self.mode", "self.target_temperature" ]

[]

[ { "method_name": "make_move", "method_description": "def make_move(self, row, col):\n \"\"\"\n Place the current player's mark at the specified position on the board and switch the mark.\n :param row: int, the row index of the position\n :param col: int, the column index of the position\n :return: bool, indicating whether the move was successful or not\n >>> ttt.current_player\n 'X'\n >>> ttt.make_move(1, 1)\n >>> ttt.current_player\n 'O'\n \"\"\"", "test_class": "TicTacToeTestMakeMove", "test_code": "class TicTacToeTestMakeMove(unittest.TestCase):\n def test_make_move_1(self):\n ttt = TicTacToe()\n self.assertEqual(ttt.current_player, 'X')\n self.assertTrue(ttt.make_move(0, 0))\n self.assertEqual(ttt.current_player, 'O')\n\n # move invalid\n def test_make_move_2(self):\n ttt = TicTacToe()\n self.assertEqual(ttt.current_player, 'X')\n self.assertTrue(ttt.make_move(0, 0))\n self.assertTrue(ttt.make_move(0, 1))\n self.assertFalse(ttt.make_move(0, 0))\n self.assertEqual(ttt.current_player, 'X')\n\n def test_make_move_3(self):\n ttt = TicTacToe()\n self.assertEqual(ttt.current_player, 'X')\n self.assertTrue(ttt.make_move(0, 0))\n self.assertTrue(ttt.make_move(0, 1))\n self.assertTrue(ttt.make_move(1, 1))\n self.assertEqual(ttt.current_player, 'O')\n\n def test_make_move_4(self):\n ttt = TicTacToe()\n self.assertEqual(ttt.current_player, 'X')\n self.assertTrue(ttt.make_move(0, 0))\n self.assertTrue(ttt.make_move(0, 1))\n self.assertTrue(ttt.make_move(1, 1))\n self.assertTrue(ttt.make_move(1, 2))\n self.assertEqual(ttt.current_player, 'X')\n\n def test_make_move_5(self):\n ttt = TicTacToe()\n self.assertEqual(ttt.current_player, 'X')\n self.assertTrue(ttt.make_move(0, 0))\n self.assertTrue(ttt.make_move(0, 1))\n self.assertTrue(ttt.make_move(1, 1))\n self.assertTrue(ttt.make_move(1, 2))\n self.assertTrue(ttt.make_move(2, 2))\n self.assertEqual(ttt.current_player, 'O')", "solution_code": "def make_move(self, row, col):\n if self.board[row][col] == ' ':\n self.board[row][col] = self.current_player\n self.current_player = 'O' if self.current_player == 'X' else 'X'\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.board", "self.current_player" ], "method_dependencies": [] } }, { "method_name": "check_winner", "method_description": "def check_winner(self):\n \"\"\"\n Check if there is a winner on the board in rows, columns and diagonals three directions\n :return: str or None, the mark of the winner ('X' or 'O'), or None if there is no winner yet\n >>> moves = [(1, 0), (2, 0), (1, 1), (2, 1), (1, 2)]\n >>> for move in moves:\n ... ttt.make_move(move[0], move[1])\n >>> ttt.check_winner()\n 'X'\n \"\"\"", "test_class": "TicTacToeTestCheckWinner", "test_code": "class TicTacToeTestCheckWinner(unittest.TestCase):\n # rows\n def test_check_winner_1(self):\n ttt = TicTacToe()\n moves = [(1, 0), (2, 0), (1, 1), (2, 1), (1, 2)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertEqual(ttt.check_winner(), 'X')\n\n # columns\n def test_check_winner_2(self):\n ttt = TicTacToe()\n moves = [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertEqual(ttt.check_winner(), 'X')\n\n # main diagonals \n def test_check_winner_3(self):\n ttt = TicTacToe()\n moves = [(0, 0), (0, 1), (1, 1), (0, 2), (2, 2)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertEqual(ttt.check_winner(), 'X')\n\n # secondary diagonals \n def test_check_winner_4(self):\n ttt = TicTacToe()\n moves = [(0, 2), (0, 1), (1, 1), (1, 0), (2, 0)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertEqual(ttt.check_winner(), 'X')\n\n def test_check_winner_5(self):\n ttt = TicTacToe()\n moves = [(0, 0), (0, 1), (1, 1), (1, 0), (2, 0)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertEqual(ttt.check_winner(), None)", "solution_code": "def check_winner(self):\n for row in self.board:\n if row[0] == row[1] == row[2] != ' ':\n return row[0]\n for col in range(3):\n if self.board[0][col] == self.board[1][col] == self.board[2][col] != ' ':\n return self.board[0][col]\n if self.board[0][0] == self.board[1][1] == self.board[2][2] != ' ':\n return self.board[0][0]\n if self.board[0][2] == self.board[1][1] == self.board[2][0] != ' ':\n return self.board[0][2]\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.board" ], "method_dependencies": [] } }, { "method_name": "is_board_full", "method_description": "def is_board_full(self):\n \"\"\"\n Check if the game board is completely filled.\n :return: bool, indicating whether the game board is full or not\n >>> ttt.is_board_full()\n False\n \"\"\"", "test_class": "TicTacToeTestIsBoardFull", "test_code": "class TicTacToeTestIsBoardFull(unittest.TestCase):\n # not full\n def test_is_board_full_1(self):\n ttt = TicTacToe()\n self.assertFalse(ttt.is_board_full())\n\n # full\n def test_is_board_full_2(self):\n ttt = TicTacToe()\n moves = [(1, 1), (0, 2), (2, 2), (0, 0), (0, 1), (2, 1), (1, 0), (1, 2), (2, 0)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertTrue(ttt.is_board_full())\n\n def test_is_board_full_3(self):\n ttt = TicTacToe()\n moves = [(0, 0), (0, 1), (1, 1), (1, 0), (2, 0)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertFalse(ttt.is_board_full())\n\n def test_is_board_full_4(self):\n ttt = TicTacToe()\n moves = [(0, 0), (0, 1), (1, 1), (1, 0), (2, 0), (0, 2), (1, 2), (2, 1), (2, 2)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertTrue(ttt.is_board_full())\n\n def test_is_board_full_5(self):\n ttt = TicTacToe()\n moves = [(0, 0), (0, 1), (1, 1), (1, 0), (2, 0), (0, 2), (1, 2), (2, 1)]\n for move in moves:\n ttt.make_move(move[0], move[1])\n self.assertFalse(ttt.is_board_full())", "solution_code": "def is_board_full(self):\n for row in self.board:\n if ' ' in row:\n return False\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.board" ], "method_dependencies": [] } } ]

[ "TicTacToeTestMakeMove", "TicTacToeTestCheckWinner", "TicTacToeTestIsBoardFull", "TicTacToeTestMain" ]

[ "self.board", "self.current_player" ]

[ "import datetime", "import time" ]

[ { "method_name": "get_current_time", "method_description": "def get_current_time(self):\n \"\"\"\n Return the current time in the format of '%H:%M:%S'\n :return: string\n >>> timeutils = TimeUtils()\n >>> timeutils.get_current_time()\n \"19:19:22\"\n \"\"\"", "test_class": "TimeUtilsTestGetCurrentTime", "test_code": "class TimeUtilsTestGetCurrentTime(unittest.TestCase):\n def test_get_current_time_1(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_time(), timeutils.datetime.strftime(\"%H:%M:%S\"))\n\n def test_get_current_time_2(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_time(), timeutils.datetime.strftime(\"%H:%M:%S\"))\n\n def test_get_current_time_3(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_time(), timeutils.datetime.strftime(\"%H:%M:%S\"))\n\n def test_get_current_time_4(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_time(), timeutils.datetime.strftime(\"%H:%M:%S\"))\n\n def test_get_current_time_5(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_time(), timeutils.datetime.strftime(\"%H:%M:%S\"))", "solution_code": "def get_current_time(self):\n format = \"%H:%M:%S\"\n return self.datetime.strftime(format)", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime", "time" ], "field_dependencies": [ "self.datetime" ], "method_dependencies": [] } }, { "method_name": "get_current_date", "method_description": "def get_current_date(self):\n \"\"\"\n Return the current date in the format of \"%Y-%m-%d\"\n :return: string\n >>> timeutils.get_current_date()\n \"2023-06-14\"\n \"\"\"", "test_class": "TimeUtilsTestGetCurrentDate", "test_code": "class TimeUtilsTestGetCurrentDate(unittest.TestCase):\n def test_get_current_date_1(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_date(), timeutils.datetime.strftime(\"%Y-%m-%d\"))\n\n def test_get_current_date_2(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_date(), timeutils.datetime.strftime(\"%Y-%m-%d\"))\n\n def test_get_current_date_3(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_date(), timeutils.datetime.strftime(\"%Y-%m-%d\"))\n\n def test_get_current_date_4(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_date(), timeutils.datetime.strftime(\"%Y-%m-%d\"))\n\n def test_get_current_date_5(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_current_date(), timeutils.datetime.strftime(\"%Y-%m-%d\"))", "solution_code": "def get_current_date(self):\n format = \"%Y-%m-%d\"\n return self.datetime.strftime(format)", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime", "time" ], "field_dependencies": [ "self.datetime" ], "method_dependencies": [] } }, { "method_name": "add_seconds", "method_description": "def add_seconds(self, seconds):\n \"\"\"\n Add the specified number of seconds to the current time\n :param seconds: int, number of seconds to add\n :return: string, time after adding the specified number of seconds in the format '%H:%M:%S'\n >>> timeutils.add_seconds(600)\n \"19:29:22\"\n \"\"\"", "test_class": "TimeUtilsTestAddSeconds", "test_code": "class TimeUtilsTestAddSeconds(unittest.TestCase):\n def test_add_seconds_1(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.add_seconds(600),\n (timeutils.datetime + datetime.timedelta(seconds=600)).strftime(\"%H:%M:%S\"))\n\n def test_add_seconds_2(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.add_seconds(500),\n (timeutils.datetime + datetime.timedelta(seconds=500)).strftime(\"%H:%M:%S\"))\n\n def test_add_seconds_3(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.add_seconds(400),\n (timeutils.datetime + datetime.timedelta(seconds=400)).strftime(\"%H:%M:%S\"))\n\n def test_add_seconds_4(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.add_seconds(300),\n (timeutils.datetime + datetime.timedelta(seconds=300)).strftime(\"%H:%M:%S\"))\n\n def test_add_seconds_5(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.add_seconds(200),\n (timeutils.datetime + datetime.timedelta(seconds=200)).strftime(\"%H:%M:%S\"))", "solution_code": "def add_seconds(self, seconds):\n new_datetime = self.datetime + datetime.timedelta(seconds=seconds)\n format = \"%H:%M:%S\"\n return new_datetime.strftime(format)", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime", "time" ], "field_dependencies": [ "self.datetime" ], "method_dependencies": [] } }, { "method_name": "string_to_datetime", "method_description": "def string_to_datetime(self, string):\n \"\"\"\n Convert the time string to a datetime instance\n :param string: string, string before converting format\n :return: datetime instance\n >>> timeutils.string_to_datetime(\"2001-7-18 1:1:1\")\n 2001-07-18 01:01:01\n \"\"\"", "test_class": "TimeUtilsTestStringToDatetime", "test_code": "class TimeUtilsTestStringToDatetime(unittest.TestCase):\n def test_string_to_datetime_1(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.string_to_datetime('2001-7-18 1:1:1'), datetime.datetime(2001, 7, 18, 1, 1, 1))\n\n def test_string_to_datetime_2(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.string_to_datetime('2001-7-17 1:1:1'), datetime.datetime(2001, 7, 17, 1, 1, 1))\n\n def test_string_to_datetime_3(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.string_to_datetime('2001-7-16 1:1:1'), datetime.datetime(2001, 7, 16, 1, 1, 1))\n\n def test_string_to_datetime_4(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.string_to_datetime('2001-7-15 1:1:1'), datetime.datetime(2001, 7, 15, 1, 1, 1))\n\n def test_string_to_datetime_5(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.string_to_datetime('2001-7-14 1:1:1'), datetime.datetime(2001, 7, 14, 1, 1, 1))", "solution_code": "def string_to_datetime(self, string):\n return datetime.datetime.strptime(string, \"%Y-%m-%d %H:%M:%S\")", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime", "time" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "datetime_to_string", "method_description": "def datetime_to_string(self, datetime):\n \"\"\"\n Convert a datetime instance to a string\n :param datetime: the datetime instance to convert\n :return: string, converted time string\n >>> timeutils.datetime_to_string(timeutils.datetime)\n \"2023-06-14 19:30:03\"\n \"\"\"", "test_class": "TimeUtilsTestDatetimeToString", "test_code": "class TimeUtilsTestDatetimeToString(unittest.TestCase):\n def test_datetime_to_string_1(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.datetime_to_string(timeutils.datetime),\n timeutils.datetime.strftime(\"%Y-%m-%d %H:%M:%S\"))\n\n def test_datetime_to_string_2(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.datetime_to_string(timeutils.datetime),\n timeutils.datetime.strftime(\"%Y-%m-%d %H:%M:%S\"))\n\n def test_datetime_to_string_3(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.datetime_to_string(timeutils.datetime),\n timeutils.datetime.strftime(\"%Y-%m-%d %H:%M:%S\"))\n\n def test_datetime_to_string_4(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.datetime_to_string(timeutils.datetime),\n timeutils.datetime.strftime(\"%Y-%m-%d %H:%M:%S\"))\n\n def test_datetime_to_string_5(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.datetime_to_string(timeutils.datetime),\n timeutils.datetime.strftime(\"%Y-%m-%d %H:%M:%S\"))", "solution_code": "def datetime_to_string(self, datetime):\n return datetime.strftime(\"%Y-%m-%d %H:%M:%S\")", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime", "time" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "get_minutes", "method_description": "def get_minutes(self, string_time1, string_time2):\n \"\"\"\n Calculate how many minutes have passed between two times, and round the results to the nearest\n :return: int, the number of minutes between two times, rounded off\n >>> timeutils.get_minutes(\"2001-7-18 1:1:1\", \"2001-7-18 2:1:1\")\n 60\n \"\"\"", "test_class": "TimeUtilsTestGetMinutes", "test_code": "class TimeUtilsTestGetMinutes(unittest.TestCase):\n def test_get_minutes_1(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_minutes(\"2001-7-18 1:1:1\", \"2001-7-18 2:1:1\"), 60)\n\n def test_get_minutes_2(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_minutes(\"2001-7-18 1:1:1\", \"2001-7-18 3:1:1\"), 120)\n\n def test_get_minutes_3(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_minutes(\"2001-7-18 1:1:1\", \"2001-7-18 4:1:1\"), 180)\n\n def test_get_minutes_4(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_minutes(\"2001-7-18 1:1:1\", \"2001-7-18 5:1:1\"), 240)\n\n def test_get_minutes_5(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_minutes(\"2001-7-18 1:1:1\", \"2001-7-18 6:1:1\"), 300)", "solution_code": "def get_minutes(self, string_time1, string_time2):\n time1 = self.string_to_datetime(string_time1)\n time2 = self.string_to_datetime(string_time2)\n return round((time2 - time1).seconds / 60)", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime", "time" ], "field_dependencies": [], "method_dependencies": [ "string_to_datetime" ] } }, { "method_name": "get_format_time", "method_description": "def get_format_time(self, year, month, day, hour, minute, second):\n \"\"\"\n get format time\n :param year: int\n :param month: int\n :param day: int\n :param hour: int\n :param minute: int\n :param second: int\n :return: formatted time string\n >>> timeutils.get_format_time(2001, 7, 18, 1, 1, 1)\n \"2001-07-18 01:01:01\"\n \"\"\"", "test_class": "TimeUtilsTestGetFormatTime", "test_code": "class TimeUtilsTestGetFormatTime(unittest.TestCase):\n def test_get_format_time_1(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_format_time(2001, 7, 18, 1, 1, 1), \"2001-07-18 01:01:01\")\n\n def test_get_format_time_2(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_format_time(2001, 7, 17, 1, 1, 1), \"2001-07-17 01:01:01\")\n\n def test_get_format_time_3(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_format_time(2001, 7, 16, 1, 1, 1), \"2001-07-16 01:01:01\")\n\n def test_get_format_time_4(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_format_time(2001, 7, 15, 1, 1, 1), \"2001-07-15 01:01:01\")\n\n def test_get_format_time_5(self):\n timeutils = TimeUtils()\n self.assertEqual(timeutils.get_format_time(2001, 7, 14, 1, 1, 1), \"2001-07-14 01:01:01\")", "solution_code": "def get_format_time(self, year, month, day, hour, minute, second):\n format = \"%Y-%m-%d %H:%M:%S\"\n time_item = datetime.datetime(year, month, day, hour, minute, second)\n return time_item.strftime(format)", "dependencies": { "Standalone": false, "lib_dependencies": [ "datetime", "time" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "TimeUtilsTestGetCurrentTime", "TimeUtilsTestGetCurrentDate", "TimeUtilsTestAddSeconds", "TimeUtilsTestStringToDatetime", "TimeUtilsTestDatetimeToString", "TimeUtilsTestGetMinutes", "TimeUtilsTestGetFormatTime", "TimeUtilsTest" ]

[ "self.datetime" ]

[ "from math import pi, fabs" ]

[ { "method_name": "cos", "method_description": "def cos(self, x):\n \"\"\"\n Calculate the cos value of the x-degree angle\n :param x:float\n :return:float\n >>> tricalculator = TriCalculator()\n >>> tricalculator.cos(60)\n 0.5\n \"\"\"", "test_class": "TriCalculatorTestCos", "test_code": "class TriCalculatorTestCos(unittest.TestCase):\n def test_cos_1(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.cos(60), 0.5)\n\n def test_cos_2(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.cos(30), 0.8660254038)\n\n def test_cos_3(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.cos(0), 1.0)\n\n def test_cos_4(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.cos(90), 0.0)\n\n def test_cos_5(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.cos(45), 0.7071067812)", "solution_code": "def cos(self, x):\n return round(self.taylor(x, 50), 10)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "taylor" ] } }, { "method_name": "factorial", "method_description": "def factorial(self, a):\n \"\"\"\n Calculate the factorial of a\n :param a: int\n :return: int\n >>> tricalculator.factorial(5)\n 120\n \"\"\"", "test_class": "TriCalculatorTestFactorial", "test_code": "class TriCalculatorTestFactorial(unittest.TestCase):\n def test_factorial_1(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(5), 120)\n\n def test_factorial_2(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(4), 24)\n\n def test_factorial_3(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(3), 6)\n\n def test_factorial_4(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(2), 2)\n\n def test_factorial_5(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(1), 1)", "solution_code": "def factorial(self, a):\n b = 1\n while a != 1:\n b *= a\n a -= 1\n return b", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "taylor", "method_description": "def taylor(self, x, n):\n \"\"\"\n Finding the n-order Taylor expansion value of cos (x/180 * pi)\n :param x: int\n :param n: int\n :return: float\n >>> tricalculator.taylor(60, 50)\n 0.5000000000000001\n \"\"\"", "test_class": "TriCalculatorTestTaylor", "test_code": "class TriCalculatorTestTaylor(unittest.TestCase):\n def test_taylor_1(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(60, 50), 0.5)\n\n def test_taylor_2(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(30, 50), 0.8660254037844386)\n\n def test_taylor_3(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(90, 50), 0.0)\n\n def test_taylor_4(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(0, 50), 1.0)\n\n def test_taylor_5(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(45, 50), 0.7071067811865475)", "solution_code": "def taylor(self, x, n):\n a = 1\n x = x / 180 * pi\n count = 1\n for k in range(1, n):\n if count % 2 != 0:\n a -= (x ** (2 * k)) / self.factorial(2 * k)\n else:\n a += (x ** (2 * k)) / self.factorial(2 * k)\n count += 1\n return a", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "factorial" ] } }, { "method_name": "sin", "method_description": "def sin(self, x):\n \"\"\"\n Calculate the sin value of the x-degree angle\n :param x: float\n :return: float\n >>> tricalculator.sin(30)\n 0.5\n \"\"\"", "test_class": "TriCalculatorTestSin", "test_code": "class TriCalculatorTestSin(unittest.TestCase):\n def test_sin_1(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.sin(30), 0.5)\n\n def test_sin_2(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.sin(60), 0.8660254038)\n\n def test_sin_3(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.sin(0), 0.0)\n\n def test_sin_4(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.sin(90), 1.0)\n\n def test_sin_5(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.sin(45), 0.7071067812)", "solution_code": "def sin(self, x):\n x = x / 180 * pi\n g = 0\n t = x\n n = 1\n\n while fabs(t) >= 1e-15:\n g += t\n n += 1\n t = -t * x * x / (2 * n - 1) / (2 * n - 2)\n return round(g, 10)", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "tan", "method_description": "def tan(self, x):\n \"\"\"\n Calculate the tan value of the x-degree angle\n :param x: float\n :return: float\n >>> tricalculator.tan(45)\n 1.0\n \"\"\"", "test_class": "TriCalculatorTestTan", "test_code": "class TriCalculatorTestTan(unittest.TestCase):\n def test_tan_1(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.tan(45), 1.0)\n\n def test_tan_2(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.tan(90), False)\n\n def test_tan_3(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.tan(30), 0.5773502692)\n\n def test_tan_4(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.tan(60), 1.7320508076)\n\n def test_tan_5(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.tan(0), 0.0)", "solution_code": "def tan(self, x):\n if self.cos(x) != 0:\n result = self.sin(x) / self.cos(x)\n return round(result, 10)\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "cos", "sin" ] } } ]

[ "TriCalculatorTestCos", "TriCalculatorTestFactorial", "TriCalculatorTestTaylor", "TriCalculatorTestSin", "TriCalculatorTestTan", "TriCalculatorTest" ]

[]

[ "import random" ]

[ { "method_name": "_generate_cards", "method_description": "def _generate_cards(self):\n \"\"\"\n Generate random numbers between 1 and 9 for the cards.\n \"\"\"", "test_class": "TwentyFourPointGameTestGetMyCards", "test_code": "class TwentyFourPointGameTestGetMyCards(unittest.TestCase):\n def test_get_my_cards_1(self):\n game = TwentyFourPointGame()\n cards = game.get_my_cards()\n self.assertEqual(len(cards), 4)\n for card in cards:\n self.assertIn(card, [1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n def test_get_my_cards_2(self):\n game = TwentyFourPointGame()\n cards = game.get_my_cards()\n self.assertEqual(len(cards), 4)\n for card in cards:\n self.assertIn(card, [1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n def test_get_my_cards_3(self):\n game = TwentyFourPointGame()\n cards = game.get_my_cards()\n self.assertEqual(len(cards), 4)\n for card in cards:\n self.assertIn(card, [1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n def test_get_my_cards_4(self):\n game = TwentyFourPointGame()\n cards = game.get_my_cards()\n self.assertEqual(len(cards), 4)\n for card in cards:\n self.assertIn(card, [1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n def test_get_my_cards_5(self):\n game = TwentyFourPointGame()\n cards = game.get_my_cards()\n self.assertEqual(len(cards), 4)\n for card in cards:\n self.assertIn(card, [1, 2, 3, 4, 5, 6, 7, 8, 9])", "solution_code": "def _generate_cards(self):\n for i in range(4):\n self.nums.append(random.randint(1, 9))\n assert len(self.nums) == 4", "dependencies": { "Standalone": false, "lib_dependencies": [ "random" ], "field_dependencies": [ "self.nums" ], "method_dependencies": [] } }, { "method_name": "get_my_cards", "method_description": "def get_my_cards(self):\n \"\"\"\n Get a list of four random numbers between 1 and 9 representing the player's cards.\n :return: list of integers, representing the player's cards\n >>> game = TwentyFourPointGame()\n >>> game.get_my_cards()\n\n \"\"\"", "test_class": "TwentyFourPointGameTestAnswer", "test_code": "class TwentyFourPointGameTestAnswer(unittest.TestCase):\n def test_answer_1(self):\n game = TwentyFourPointGame()\n cards = game.answer('pass')\n self.assertEqual(len(cards), 4)\n\n def test_answer_2(self):\n game = TwentyFourPointGame()\n result = game.answer('4*3+6+6')\n self.assertTrue(result)\n\n def test_answer_3(self):\n game = TwentyFourPointGame()\n result = game.answer('1+1+1+1')\n self.assertFalse(result)\n\n def test_answer_4(self):\n game = TwentyFourPointGame()\n result = game.answer('1+')\n self.assertFalse(result)\n\n def test_answer_5(self):\n game = TwentyFourPointGame()\n result = game.answer('abc')\n self.assertFalse(result)\n\n def test_answer_6(self):\n game = TwentyFourPointGame()\n game.nums = [1, 1, 1, 1]\n result = game.answer('1+1+1+2')\n self.assertFalse(result)\n\n def test_answer_7(self):\n game = TwentyFourPointGame()\n game.nums = [1, 1, 1, 1]\n result = game.answer('1+1+1+1+1')\n self.assertFalse(result)", "solution_code": "def get_my_cards(self):\n self.nums = []\n self._generate_cards()\n return self.nums", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.nums" ], "method_dependencies": [ "_generate_cards" ] } }, { "method_name": "answer", "method_description": "def answer(self, expression):\n \"\"\"\n Check if a given mathematical expression using the cards can evaluate to 24.\n :param expression: string, mathematical expression using the cards\n :return: bool, True if the expression evaluates to 24, False otherwise\n >>> game = TwentyFourPointGame()\n >>> game.nums = [4, 3, 6, 6]\n >>> ans = \"4*3+6+6\"\n >>> ret = game.answer(ans)\n True\n \"\"\"", "test_class": "TwentyFourPointGameTestEvaluateExpression", "test_code": "class TwentyFourPointGameTestEvaluateExpression(unittest.TestCase):\n def test_evaluate_expression_1(self):\n game = TwentyFourPointGame()\n result = game.evaluate_expression('4+3+6+6')\n self.assertFalse(result)\n\n def test_evaluate_expression_2(self):\n game = TwentyFourPointGame()\n result = game.evaluate_expression('4*3+6+6')\n self.assertTrue(result)\n\n def test_evaluate_expression_3(self):\n game = TwentyFourPointGame()\n result = game.evaluate_expression('1+1+1+1')\n self.assertFalse(result)\n\n def test_evaluate_expression_4(self):\n game = TwentyFourPointGame()\n result = game.evaluate_expression('1+')\n self.assertFalse(result)\n\n def test_evaluate_expression_5(self):\n game = TwentyFourPointGame()\n result = game.evaluate_expression('abc')\n self.assertFalse(result)", "solution_code": "def answer(self, expression):\n if expression == 'pass':\n return self.get_my_cards()\n statistic = {}\n for c in expression:\n if c.isdigit() and int(c) in self.nums:\n statistic[c] = statistic.get(c, 0) + 1\n\n nums_used = statistic.copy()\n\n for num in self.nums:\n if nums_used.get(str(num), -100) != -100 and nums_used[str(num)] > 0:\n nums_used[str(num)] -= 1\n else:\n return False\n\n if all(count == 0 for count in nums_used.values()) == True:\n return self.evaluate_expression(expression)\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.nums" ], "method_dependencies": [ "get_my_cards", "evaluate_expression" ] } }, { "method_name": "evaluate_expression", "method_description": "def evaluate_expression(self, expression):\n \"\"\"\n Evaluate a mathematical expression and check if the result is 24.\n :param expression: string, mathematical expression\n :return: bool, True if the expression evaluates to 24, False otherwise\n >>> game = TwentyFourPointGame()\n >>> nums = [4, 3, 6, 6]\n >>> ans = \"4*3+6+6\"\n >>> ret = game.evaluate_expression(ans)\n True\n \"\"\"", "test_class": "TwentyFourPointGameTest", "test_code": "class TwentyFourPointGameTest(unittest.TestCase):\n def test_TwentyFourPointGame(self):\n game = TwentyFourPointGame()\n cards = game.get_my_cards()\n self.assertEqual(len(cards), 4)\n for card in cards:\n self.assertIn(card, [1, 2, 3, 4, 5, 6, 7, 8, 9])\n game.nums = [4, 3, 6, 6]\n result = game.answer('4*3+6+6')\n self.assertTrue(result)\n result = game.evaluate_expression('4*3+6+6')\n self.assertTrue(result)", "solution_code": "def evaluate_expression(self, expression):\n try:\n if eval(expression) == 24:\n return True\n else:\n return False\n except Exception as e:\n return False", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "TwentyFourPointGameTestGetMyCards", "TwentyFourPointGameTestAnswer", "TwentyFourPointGameTestEvaluateExpression", "TwentyFourPointGameTest" ]

[ "self.nums" ]

[]

[ { "method_name": "get_scheme", "method_description": "def get_scheme(self):\n \"\"\"\n get the scheme of the URL\n :return: string, If successful, return the scheme of the URL\n >>> urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n >>> urlhandler.get_scheme()\n \"https\"\n \"\"\"", "test_class": "URLHandlerTestGetScheme", "test_code": "class URLHandlerTestGetScheme(unittest.TestCase):\n def test_get_scheme_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"https\")\n\n def test_get_scheme_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"https\")\n\n def test_get_scheme_3(self):\n urlhandler = URLHandler(\"https://github.com/openai/human-eval\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"https\")\n\n def test_get_scheme_4(self):\n urlhandler = URLHandler(\"aaa://github.com/openai/human-eval\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"aaa\")\n\n def test_get_scheme_5(self):\n urlhandler = URLHandler(\"bbb://github.com/openai/human-eval\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"bbb\")\n\n def test_get_scheme_6(self):\n urlhandler = URLHandler(\"abcdefg\")\n temp = urlhandler.get_scheme()\n self.assertIsNone(temp)", "solution_code": "def get_scheme(self):\n scheme_end = self.url.find(\"://\")\n if scheme_end != -1:\n return self.url[:scheme_end]\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.url" ], "method_dependencies": [] } }, { "method_name": "get_host", "method_description": "def get_host(self):\n \"\"\"\n Get the second part of the URL, which is the host domain name\n :return: string, If successful, return the host domain name of the URL\n >>> urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n >>> urlhandler.get_host()\n \"www.baidu.com\"\n \"\"\"", "test_class": "URLHandlerTestGetHost", "test_code": "class URLHandlerTestGetHost(unittest.TestCase):\n def test_get_host_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"www.baidu.com\")\n\n def test_get_host_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"www.bing.com\")\n\n def test_get_host_3(self):\n urlhandler = URLHandler(\"https://github.com/openai/human-eval\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"github.com\")\n\n def test_get_host_4(self):\n urlhandler = URLHandler(\"https://aaa.com/openai/human-eval\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"aaa.com\")\n\n def test_get_host_5(self):\n urlhandler = URLHandler(\"https://bbb.com/openai/human-eval\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"bbb.com\")\n\n def test_get_host_6(self):\n urlhandler = URLHandler(\"abcdefg\")\n temp = urlhandler.get_host()\n self.assertIsNone(temp)\n\n def test_get_host_7(self):\n urlhandler = URLHandler(\"https://bbb.com\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"bbb.com\")\n\n def test_get_host_8(self):\n urlhandler = URLHandler(\"https://bbb.com/\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"bbb.com\")", "solution_code": "def get_host(self):\n scheme_end = self.url.find(\"://\")\n if scheme_end != -1:\n url_without_scheme = self.url[scheme_end + 3:]\n host_end = url_without_scheme.find(\"/\")\n if host_end != -1:\n return url_without_scheme[:host_end]\n return url_without_scheme\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.url" ], "method_dependencies": [] } }, { "method_name": "get_path", "method_description": "def get_path(self):\n \"\"\"\n Get the third part of the URL, which is the address of the resource\n :return: string, If successful, return the address of the resource of the URL\n >>> urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n >>> urlhandler.get_path()\n \"/s?wd=aaa&rsv_spt=1#page\"\n \"\"\"", "test_class": "URLHandlerTestGetPath", "test_code": "class URLHandlerTestGetPath(unittest.TestCase):\n def test_get_path_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/s?wd=aaa&rsv_spt=1#page\")\n\n def test_get_path_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n temp = urlhandler.get_path()\n self.assertEqual(temp,\n \"/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n\n def test_get_path_3(self):\n urlhandler = URLHandler(\"https://github.com/openai/human-eval\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/openai/human-eval\")\n\n def test_get_path_4(self):\n urlhandler = URLHandler(\"https://github.com/aaa/human-eval\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/aaa/human-eval\")\n\n def test_get_path_5(self):\n urlhandler = URLHandler(\"https://github.com/bbb/human-eval\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/bbb/human-eval\")\n\n def test_get_path_6(self):\n urlhandler = URLHandler(\"abcdefg\")\n temp = urlhandler.get_path()\n self.assertIsNone(temp)", "solution_code": "def get_path(self):\n scheme_end = self.url.find(\"://\")\n if scheme_end != -1:\n url_without_scheme = self.url[scheme_end + 3:]\n host_end = url_without_scheme.find(\"/\")\n if host_end != -1:\n return url_without_scheme[host_end:]\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.url" ], "method_dependencies": [] } }, { "method_name": "get_query_params", "method_description": "def get_query_params(self):\n \"\"\"\n Get the request parameters for the URL\n :return: dict, If successful, return the request parameters of the URL\n >>> urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n >>> urlhandler.get_query_params()\n {\"wd\": \"aaa\", \"rsv_spt\": \"1\"}\n \"\"\"", "test_class": "URLHandlerTestGetQueryParams", "test_code": "class URLHandlerTestGetQueryParams(unittest.TestCase):\n def test_get_query_params_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"wd\": \"aaa\", \"rsv_spt\": \"1\"})\n\n def test_get_query_params_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531#\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"pglt\": \"41\", \"q\": \"humaneval\", \"cvid\": \"4dc2da2bb4bc429eb498c85245ae5253\",\n \"aqs\": \"edge.0.0l7j69i61j69i60.10008j0j1\", \"FORM\": \"ANNTA1\", \"PC\": \"U531\"})\n\n def test_get_query_params_3(self):\n urlhandler = URLHandler(\"https://github.com/openai/human-eval\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, None)\n\n def test_get_query_params_4(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=bbb&rsv_spt=1#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"wd\": \"bbb\", \"rsv_spt\": \"1\"})\n\n def test_get_query_params_5(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=ccc&rsv_spt=1#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"wd\": \"ccc\", \"rsv_spt\": \"1\"})\n\n def test_get_query_params_6(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?&#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {})", "solution_code": "def get_query_params(self):\n query_start = self.url.find(\"?\")\n fragment_start = self.url.find(\"#\")\n if query_start != -1:\n query_string = self.url[query_start + 1:fragment_start]\n params = {}\n if len(query_string) > 0:\n param_pairs = query_string.split(\"&\")\n for pair in param_pairs:\n key_value = pair.split(\"=\")\n if len(key_value) == 2:\n key, value = key_value\n params[key] = value\n return params\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.url" ], "method_dependencies": [] } }, { "method_name": "get_fragment", "method_description": "def get_fragment(self):\n \"\"\"\n Get the fragment after '#' in the URL\n :return: string, If successful, return the fragment after '#' of the URL\n >>> urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n >>> urlhandler.get_fragment()\n \"page\"\n \"\"\"", "test_class": "URLHandlerTestGetFragment", "test_code": "class URLHandlerTestGetFragment(unittest.TestCase):\n def test_get_fragment_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"page\")\n\n def test_get_fragment_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, None)\n\n def test_get_fragment_3(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#aaa\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"aaa\")\n\n def test_get_fragment_4(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#bbb\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"bbb\")\n\n def test_get_fragment_5(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#ccc\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"ccc\")", "solution_code": "def get_fragment(self):\n fragment_start = self.url.find(\"#\")\n if fragment_start != -1:\n return self.url[fragment_start + 1:]\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.url" ], "method_dependencies": [] } } ]

[ "URLHandlerTestGetScheme", "URLHandlerTestGetHost", "URLHandlerTestGetPath", "URLHandlerTestGetQueryParams", "URLHandlerTestGetFragment", "URLHandlerTest" ]

[ "self.url" ]

[ "import urllib.parse" ]

[ { "method_name": "add", "method_description": "def add(self, segment):\n \"\"\"\n Adds a segment to the list of segments in the UrlPath.\n :param segment: str, the segment to add.\n >>> url_path = UrlPath()\n >>> url_path.add('foo')\n >>> url_path.add('bar')\n\n url_path.segments = ['foo', 'bar']\n \"\"\"", "test_class": "UrlPathTestAdd", "test_code": "class UrlPathTestAdd(unittest.TestCase):\n def test_add_1(self):\n url_path = UrlPath()\n url_path.add('foo')\n url_path.add('bar')\n self.assertEqual(url_path.segments, ['foo', 'bar'])\n\n def test_add_2(self):\n url_path = UrlPath()\n url_path.add('aaa')\n url_path.add('bbb')\n self.assertEqual(url_path.segments, ['aaa', 'bbb'])\n\n def test_add_3(self):\n url_path = UrlPath()\n url_path.add('123')\n self.assertEqual(url_path.segments, ['123'])\n\n def test_add_4(self):\n url_path = UrlPath()\n url_path.add('ddd')\n self.assertEqual(url_path.segments, ['ddd'])\n\n def test_add_5(self):\n url_path = UrlPath()\n url_path.add('eee')\n self.assertEqual(url_path.segments, ['eee'])", "solution_code": "def add(self, segment):\n self.segments.append(self.fix_path(segment))", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.segments" ], "method_dependencies": [ "fix_path" ] } }, { "method_name": "parse", "method_description": "def parse(self, path, charset):\n \"\"\"\n Parses a given path string and populates the list of segments in the UrlPath.\n :param path: str, the path string to parse.\n :param charset: str, the character encoding of the path string.\n >>> url_path = UrlPath()\n >>> url_path.parse('/foo/bar/', 'utf-8')\n\n url_path.segments = ['foo', 'bar']\n \"\"\"", "test_class": "UrlPathTestParse", "test_code": "class UrlPathTestParse(unittest.TestCase):\n def test_parse_1(self):\n url_path = UrlPath()\n url_path.parse('/foo/bar/', 'utf-8')\n self.assertEqual(url_path.segments, ['foo', 'bar'])\n self.assertEqual(url_path.with_end_tag, True)\n\n def test_parse_2(self):\n url_path = UrlPath()\n url_path.parse('aaa/bbb', 'utf-8')\n self.assertEqual(url_path.segments, ['aaa', 'bbb'])\n self.assertEqual(url_path.with_end_tag, False)\n\n def test_parse_3(self):\n url_path = UrlPath()\n url_path.parse('/123/456/', 'utf-8')\n self.assertEqual(url_path.segments, ['123', '456'])\n self.assertEqual(url_path.with_end_tag, True)\n\n def test_parse_4(self):\n url_path = UrlPath()\n url_path.parse('/123/456/789', 'utf-8')\n self.assertEqual(url_path.segments, ['123', '456', '789'])\n self.assertEqual(url_path.with_end_tag, False)\n\n def test_parse_5(self):\n url_path = UrlPath()\n url_path.parse('/foo/bar', 'utf-8')\n self.assertEqual(url_path.segments, ['foo', 'bar'])\n self.assertEqual(url_path.with_end_tag, False)\n\n def test_parse_6(self):\n url_path = UrlPath()\n url_path.parse('', 'utf-8')\n self.assertEqual(url_path.segments, [])\n self.assertEqual(url_path.with_end_tag, False)\n\n def test_parse_7(self):\n url_path = UrlPath()\n url_path.parse('//', 'utf-8')\n self.assertEqual(url_path.segments, [])\n self.assertEqual(url_path.with_end_tag, True)", "solution_code": "def parse(self, path, charset):\n if path:\n if path.endswith('/'):\n self.with_end_tag = True\n\n path = self.fix_path(path)\n if path:\n split = path.split('/')\n for seg in split:\n decoded_seg = urllib.parse.unquote(seg, encoding=charset)\n self.segments.append(decoded_seg)", "dependencies": { "Standalone": false, "lib_dependencies": [ "urllib.parse" ], "field_dependencies": [ "self.segments", "self.with_end_tag" ], "method_dependencies": [ "fix_path" ] } }, { "method_name": "fix_path", "method_description": "@staticmethod\n def fix_path(path):\n \"\"\"\n Fixes the given path string by removing leading and trailing slashes.\n :param path: str, the path string to fix.\n :return: str, the fixed path string.\n >>> url_path = UrlPath()\n >>> url_path.fix_path('/foo/bar/')\n 'foo/bar'\n\n \"\"\"", "test_class": "UrlPathTestFixPath", "test_code": "class UrlPathTestFixPath(unittest.TestCase):\n def test_fix_path_1(self):\n fixed_path = UrlPath.fix_path('/foo/bar/')\n self.assertEqual(fixed_path, 'foo/bar')\n\n def test_fix_path_2(self):\n fixed_path = UrlPath.fix_path('/aaa/bbb/')\n self.assertEqual(fixed_path, 'aaa/bbb')\n\n def test_fix_path_3(self):\n fixed_path = UrlPath.fix_path('/a/b/')\n self.assertEqual(fixed_path, 'a/b')\n\n def test_fix_path_4(self):\n fixed_path = UrlPath.fix_path('/111/222/')\n self.assertEqual(fixed_path, '111/222')\n\n def test_fix_path_5(self):\n fixed_path = UrlPath.fix_path('/a/')\n self.assertEqual(fixed_path, 'a')\n\n def test_fix_path_6(self):\n fixed_path = UrlPath.fix_path('')\n self.assertEqual(fixed_path, '')", "solution_code": "@staticmethod\n def fix_path(path):\n if not path:\n return ''\n\n segment_str = path.strip('/')\n return segment_str", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "UrlPathTestAdd", "UrlPathTestParse", "UrlPathTestFixPath", "UrlPathTest" ]

[ "self.segments", "self.with_end_tag" ]

[ "import sqlite3" ]

[ { "method_name": "insert_user", "method_description": "def insert_user(self, username, password):\n \"\"\"\n Inserts a new user into the \"users\" table.\n :param username: str, the username of the user.\n :param password: str, the password of the user.\n :return: None\n >>> user_db = UserLoginDB(\"user_database.db\")\n >>> user_db.create_table()\n >>> user_db.insert_user('user1', 'pass1')\n \"\"\"", "test_class": "UserLoginDBTestInsertUser", "test_code": "class UserLoginDBTestInsertUser(unittest.TestCase):\n def setUp(self):\n self.db_path = os.path.join(gettempdir(), 'test_db.db')\n conn = sqlite3.connect(self.db_path)\n cursor = conn.cursor()\n create_table_query = \"\"\"\n CREATE TABLE IF NOT EXISTS users (\n username TEXT,\n password TEXT\n )\n \"\"\"\n cursor.execute(create_table_query)\n\n conn.commit()\n conn.close()\n self.db = UserLoginDB(self.db_path)\n\n def tearDown(self):\n self.db.connection.close()\n os.unlink(self.db_path)\n\n def test_insert_user_1(self):\n self.db.insert_user('user1', 'pass1')\n user = self.db.search_user_by_username('user1')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user1')\n self.assertEqual(user[1], 'pass1')\n\n def test_insert_user_2(self):\n self.db.insert_user('user2', 'pass2')\n user = self.db.search_user_by_username('user2')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user2')\n self.assertEqual(user[1], 'pass2')\n\n def test_insert_user_3(self):\n self.db.insert_user('user3', 'pass3')\n user = self.db.search_user_by_username('user3')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user3')\n self.assertEqual(user[1], 'pass3')\n\n def test_insert_user_4(self):\n self.db.insert_user('user4', 'pass4')\n user = self.db.search_user_by_username('user4')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user4')\n self.assertEqual(user[1], 'pass4')\n\n def test_insert_user_5(self):\n self.db.insert_user('user5', 'pass5')\n user = self.db.search_user_by_username('user5')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user5')\n self.assertEqual(user[1], 'pass5')", "solution_code": "def insert_user(self, username, password):\n self.cursor.execute('''\n INSERT INTO users (username, password)\n VALUES (?, ?)\n ''', (username, password))\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "search_user_by_username", "method_description": "def search_user_by_username(self, username):\n \"\"\"\n Searches for users in the \"users\" table by username.\n :param username: str, the username of the user to search for.\n :return:list of tuples, the rows from the \"users\" table that match the search criteria.\n >>> user_db = UserLoginDB(\"user_database.db\")\n >>> user_db.create_table()\n >>> user_db.insert_user('user1', 'pass1')\n >>> result = user_db.search_user_by_username('user1')\n len(result) = 1\n \"\"\"", "test_class": "UserLoginDBTestSearchUserByUsername", "test_code": "class UserLoginDBTestSearchUserByUsername(unittest.TestCase):\n def setUp(self):\n self.db_path = os.path.join(gettempdir(), 'test_db.db')\n conn = sqlite3.connect(self.db_path)\n cursor = conn.cursor()\n create_table_query = \"\"\"\n CREATE TABLE IF NOT EXISTS users (\n username TEXT,\n password TEXT\n )\n \"\"\"\n cursor.execute(create_table_query)\n\n conn.commit()\n conn.close()\n self.db = UserLoginDB(self.db_path)\n\n def tearDown(self):\n self.db.connection.close()\n os.unlink(self.db_path)\n\n def test_search_user_by_username_1(self):\n self.db.insert_user('user1', 'pass1')\n user = self.db.search_user_by_username('user1')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user1')\n self.assertEqual(user[1], 'pass1')\n\n def test_search_user_by_username_2(self):\n self.db.insert_user('user2', 'pass2')\n user = self.db.search_user_by_username('user2')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user2')\n self.assertEqual(user[1], 'pass2')\n\n def test_search_user_by_username_3(self):\n self.db.insert_user('user3', 'pass3')\n user = self.db.search_user_by_username('user3')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user3')\n self.assertEqual(user[1], 'pass3')\n\n def test_search_user_by_username_4(self):\n self.db.insert_user('user4', 'pass4')\n user = self.db.search_user_by_username('user4')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user4')\n self.assertEqual(user[1], 'pass4')\n\n def test_search_user_by_username_5(self):\n self.db.insert_user('user5', 'pass5')\n user = self.db.search_user_by_username('user5')\n self.assertIsNotNone(user)\n self.assertEqual(user[0], 'user5')\n self.assertEqual(user[1], 'pass5')", "solution_code": "def search_user_by_username(self, username):\n self.cursor.execute('''\n SELECT * FROM users WHERE username = ?\n ''', (username,))\n user = self.cursor.fetchone()\n return user", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.cursor" ], "method_dependencies": [] } }, { "method_name": "delete_user_by_username", "method_description": "def delete_user_by_username(self, username):\n \"\"\"\n Deletes a user from the \"users\" table by username.\n :param username: str, the username of the user to delete.\n :return: None\n >>> user_db = UserLoginDB(\"user_database.db\")\n >>> user_db.create_table()\n >>> user_db.insert_user('user1', 'pass1')\n >>> user_db.delete_user_by_username('user1')\n \"\"\"", "test_class": "UserLoginDBTestDeleteUserByUsername", "test_code": "class UserLoginDBTestDeleteUserByUsername(unittest.TestCase):\n def setUp(self):\n self.db_path = os.path.join(gettempdir(), 'test_db.db')\n conn = sqlite3.connect(self.db_path)\n cursor = conn.cursor()\n create_table_query = \"\"\"\n CREATE TABLE IF NOT EXISTS users (\n username TEXT,\n password TEXT\n )\n \"\"\"\n cursor.execute(create_table_query)\n\n conn.commit()\n conn.close()\n self.db = UserLoginDB(self.db_path)\n\n def tearDown(self):\n self.db.connection.close()\n os.unlink(self.db_path)\n\n def test_delete_user_by_username_1(self):\n self.db.insert_user('user1', 'pass1')\n self.db.delete_user_by_username('user1')\n user = self.db.search_user_by_username('user1')\n self.assertIsNone(user)\n\n def test_delete_user_by_username_2(self):\n self.db.insert_user('user2', 'pass2')\n self.db.delete_user_by_username('user2')\n user = self.db.search_user_by_username('user2')\n self.assertIsNone(user)\n\n def test_delete_user_by_username_3(self):\n self.db.insert_user('user3', 'pass3')\n self.db.delete_user_by_username('user3')\n user = self.db.search_user_by_username('user3')\n self.assertIsNone(user)\n\n def test_delete_user_by_username_4(self):\n self.db.insert_user('user4', 'pass4')\n self.db.delete_user_by_username('user4')\n user = self.db.search_user_by_username('user4')\n self.assertIsNone(user)\n\n def test_delete_user_by_username_5(self):\n self.db.insert_user('user5', 'pass5')\n self.db.delete_user_by_username('user5')\n user = self.db.search_user_by_username('user5')\n self.assertIsNone(user)", "solution_code": "def delete_user_by_username(self, username):\n self.cursor.execute('''\n DELETE FROM users WHERE username = ?\n ''', (username,))\n self.connection.commit()", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.connection", "self.cursor" ], "method_dependencies": [] } }, { "method_name": "validate_user_login", "method_description": "def validate_user_login(self, username, password):\n \"\"\"\n Determine whether the user can log in, that is, the user is in the database and the password is correct\n :param username:str, the username of the user to validate.\n :param password:str, the password of the user to validate.\n :return:bool, representing whether the user can log in correctly\n >>> user_db = UserLoginDB(\"user_database.db\")\n >>> user_db.create_table()\n >>> user_db.insert_user('user1', 'pass1')\n >>> user_db.validate_user_login('user1', 'pass1')\n True\n \"\"\"", "test_class": "UserLoginDBTestValidateUserLogin", "test_code": "class UserLoginDBTestValidateUserLogin(unittest.TestCase):\n def setUp(self):\n self.db_path = os.path.join(gettempdir(), 'test_db.db')\n conn = sqlite3.connect(self.db_path)\n cursor = conn.cursor()\n create_table_query = \"\"\"\n CREATE TABLE IF NOT EXISTS users (\n username TEXT,\n password TEXT\n )\n \"\"\"\n cursor.execute(create_table_query)\n\n conn.commit()\n conn.close()\n self.db = UserLoginDB(self.db_path)\n\n def tearDown(self):\n self.db.connection.close()\n os.unlink(self.db_path)\n\n def test_validate_user_login_1(self):\n self.db.insert_user('user1', 'pass1')\n valid = self.db.validate_user_login('user1', 'pass1')\n self.assertTrue(valid)\n\n def test_validate_user_login_2(self):\n self.db.insert_user('user1', 'pass1')\n invalid = self.db.validate_user_login('user1', 'wrongpass')\n self.assertFalse(invalid)\n\n def test_validate_user_login_3(self):\n valid = self.db.validate_user_login('nonexistentuser', 'somepass')\n self.assertFalse(valid)\n\n def test_validate_user_login_4(self):\n self.db.insert_user('user2', 'pass2')\n valid = self.db.validate_user_login('user2', 'pass2')\n self.assertTrue(valid)\n\n def test_validate_user_login_5(self):\n self.db.insert_user('user3', 'pass3')\n valid = self.db.validate_user_login('user3', 'pass3')\n self.assertTrue(valid)", "solution_code": "def validate_user_login(self, username, password):\n user = self.search_user_by_username(username)\n if user is not None and user[1] == password:\n return True\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [ "search_user_by_username" ] } } ]

[ "UserLoginDBTestInsertUser", "UserLoginDBTestSearchUserByUsername", "UserLoginDBTestDeleteUserByUsername", "UserLoginDBTestValidateUserLogin", "UserLoginDBTest" ]

[ "self.connection", "self.cursor" ]

[ "import numpy as np", "from gensim import matutils", "from numpy import dot, array" ]

[ { "method_name": "similarity", "method_description": "def similarity(vector_1, vector_2):\n \"\"\"\n Compute the cosine similarity between one vector and another vector.\n :param vector_1: numpy.ndarray, Vector from which similarities are to be computed, expected shape (dim,).\n :param vector_2: numpy.ndarray, Vector from which similarities are to be computed, expected shape (dim,).\n :return: numpy.ndarray, Contains cosine distance between `vector_1` and `vector_2`\n >>> vector_1 = np.array([1, 1])\n >>> vector_2 = np.array([1, 0])\n >>> VectorUtil.similarity(vector_1, vector_2)\n 0.7071067811865475\n \"\"\"", "test_class": "VectorUtilTestSimilarity", "test_code": "class VectorUtilTestSimilarity(unittest.TestCase):\n def test_similarity_1(self):\n vector_1 = np.array([1, 1])\n vector_2 = np.array([1, 0])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.7071067811865475)\n\n def test_similarity_2(self):\n vector_1 = np.array([1, 1])\n vector_2 = np.array([0, 0])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.0)\n\n def test_similarity_3(self):\n vector_1 = np.array([1, 1])\n vector_2 = np.array([1, 1])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 1.0)\n\n def test_similarity_4(self):\n vector_1 = np.array([1, 1, 0, 1, 0, 1, 0, 1])\n vector_2 = np.array([1, 0, 0, 1, 0, 1, 0, 1])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.8944271909999159)\n\n def test_similarity_5(self):\n vector_1 = np.array([1, 1, 1, 1, 1, 1, 1, 1])\n vector_2 = np.array([0, 0, 0, 0, 0, 0, 0, 0])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.0)", "solution_code": "def similarity(vector_1, vector_2):\n return dot(matutils.unitvec(vector_1), matutils.unitvec(vector_2))", "dependencies": { "Standalone": false, "lib_dependencies": [ "matutils" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "cosine_similarities", "method_description": "@staticmethod\n def cosine_similarities(vector_1, vectors_all):\n \"\"\"\n Compute cosine similarities between one vector and a set of other vectors.\n :param vector_1: numpy.ndarray, Vector from which similarities are to be computed, expected shape (dim,).\n :param vectors_all: list of numpy.ndarray, For each row in vectors_all, distance from vector_1 is computed, expected shape (num_vectors, dim).\n :return: numpy.ndarray, Contains cosine distance between `vector_1` and each row in `vectors_all`, shape (num_vectors,).\n >>> vector1 = np.array([1, 2, 3])\n >>> vectors_all = [np.array([4, 5, 6]), np.array([7, 8, 9])]\n >>> VectorUtil.cosine_similarities(vector1, vectors_all)\n [0.97463185 0.95941195]\n \"\"\"", "test_class": "VectorUtilTestCosineSimilarities", "test_code": "class VectorUtilTestCosineSimilarities(unittest.TestCase):\n def test_cosine_similarities_1(self):\n vector1 = np.array([1, 1])\n vectors_all = [np.array([1, 0]), np.array([1, 1])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.7071067811865475, 1.0]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n def test_cosine_similarities_2(self):\n vector1 = np.array([1, 1, 0, 0, 1, 0, 1, 0])\n vectors_all = [np.array([1, 0, 0, 0, 1, 0, 1, 0]), np.array([1, 1, 0, 1, 1, 1, 1, 0])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.8660254037844387, 0.8164965809277261]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n def test_cosine_similarities_3(self):\n vector1 = np.array([1, 1, 0, 0, 1, 0, 1, 0])\n vectors_all = [np.array([1, 0, 0, 0, 1, 0, 1, 0]), np.array([1, 1, 1, 1, 1, 1, 1, 0])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.8660254037844387, 0.7559289460184544]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n def test_cosine_similarities_4(self):\n vector1 = np.array([1, 1, 0, 0, 1, 0, 1, 0])\n vectors_all = [np.array([1, 0, 0, 0, 1, 0, 1, 0]), np.array([1, 1, 1, 1, 1, 1, 1, 1])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.8660254037844387, 0.7071067811865475]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n def test_cosine_similarities_5(self):\n vector1 = np.array([1, 1, 0, 0, 1, 0, 1, 0])\n vectors_all = [np.array([1, 0, 0, 0, 1, 0, 1, 0]), np.array([0, 1, 1, 1, 1, 1, 1, 1])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.8660254037844387, 0.5669467095138409]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])", "solution_code": "@staticmethod\n def cosine_similarities(vector_1, vectors_all):\n norm = np.linalg.norm(vector_1)\n all_norms = np.linalg.norm(vectors_all, axis=1)\n dot_products = dot(vectors_all, vector_1)\n similarities = dot_products / (norm * all_norms)\n return similarities", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "n_similarity", "method_description": "@staticmethod\n def n_similarity(vector_list_1, vector_list_2):\n \"\"\"\n Compute cosine similarity between two sets of vectors.\n :param vector_list_1: list of numpy vector\n :param vector_list_2: list of numpy vector\n :return: numpy.ndarray, Similarities between vector_list_1 and vector_list_2.\n >>> vector_list1 = [np.array([1, 2, 3]), np.array([4, 5, 6])]\n >>> vector_list2 = [np.array([7, 8, 9]), np.array([10, 11, 12])]\n >>> VectorUtil.n_similarity(vector_list1, vector_list2)\n 0.9897287473881233\n \"\"\"", "test_class": "VectorUtilTestNSimilarity", "test_code": "class VectorUtilTestNSimilarity(unittest.TestCase):\n def test_n_similarity_1(self):\n vector_list1 = [np.array([1, 0]), np.array([0, 1])]\n vector_list2 = [np.array([0, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 1.0)\n\n def test_n_similarity_2(self):\n vector_list1 = [np.array([1, 1]), np.array([0, 1])]\n vector_list2 = [np.array([0, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 0.9486832980505137)\n\n def test_n_similarity_3(self):\n vector_list1 = [np.array([1, 0]), np.array([1, 1])]\n vector_list2 = [np.array([0, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 0.9486832980505137)\n\n def test_n_similarity_4(self):\n vector_list1 = [np.array([1, 0]), np.array([0, 1])]\n vector_list2 = [np.array([1, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 0.9486832980505137)\n\n def test_n_similarity_5(self):\n vector_list1 = [np.array([1, 0]), np.array([0, 1])]\n vector_list2 = [np.array([0, 1]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 0.9486832980505137)\n\n def test_n_similarity_6(self):\n try:\n vector_list1 = []\n vector_list2 = []\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n except:\n pass", "solution_code": "@staticmethod\n def n_similarity(vector_list_1, vector_list_2):\n if not (len(vector_list_1) and len(vector_list_2)):\n raise ZeroDivisionError('At least one of the passed list is empty.')\n\n return dot(matutils.unitvec(array(vector_list_1).mean(axis=0)),\n matutils.unitvec(array(vector_list_2).mean(axis=0)))", "dependencies": { "Standalone": false, "lib_dependencies": [ "matutils" ], "field_dependencies": [], "method_dependencies": [] } }, { "method_name": "compute_idf_weight_dict", "method_description": "@staticmethod\n def compute_idf_weight_dict(total_num, number_dict):\n \"\"\"\n Calculate log(total_num+1/count+1) for each count in number_dict\n :param total_num: int\n :param number_dict: dict\n :return: dict\n >>> num_dict = {'key1':0.1, 'key2':0.5}\n >>> VectorUtil.compute_idf_weight_dict(2, num_dict)\n {'key1': 1.0033021088637848, 'key2': 0.6931471805599453}\n \"\"\"", "test_class": "VectorUtilTestComputeIdfWeightDict", "test_code": "class VectorUtilTestComputeIdfWeightDict(unittest.TestCase):\n def test_compute_idf_weight_dict_1(self):\n num_dict = {'key1': 0.1, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 1.0033021088637848)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n def test_compute_idf_weight_dict_2(self):\n num_dict = {'key1': 0.2, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 0.9162907318741551)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n def test_compute_idf_weight_dict_3(self):\n num_dict = {'key1': 0.3, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 0.8362480242006185)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n def test_compute_idf_weight_dict_4(self):\n num_dict = {'key1': 0.4, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 0.7621400520468967)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n def test_compute_idf_weight_dict_5(self):\n num_dict = {'key1': 0.5, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 0.6931471805599453)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)", "solution_code": "@staticmethod\n def compute_idf_weight_dict(total_num, number_dict):\n index_2_key_map = {}\n\n index = 0\n\n count_list = []\n for key, count in number_dict.items():\n index_2_key_map[index] = key\n count_list.append(count)\n index = index + 1\n\n a = np.array(count_list)\n ## smooth, in case the divide by zero error\n a = np.log((total_num + 1) / (a + 1))\n result = {}\n\n for index, w in enumerate(a):\n key = index_2_key_map[index]\n result[key] = w\n\n return result", "dependencies": { "Standalone": true, "lib_dependencies": [], "field_dependencies": [], "method_dependencies": [] } } ]

[ "VectorUtilTestSimilarity", "VectorUtilTestCosineSimilarities", "VectorUtilTestNSimilarity", "VectorUtilTestComputeIdfWeightDict", "VectorUtilTest" ]

[]

[]

[ { "method_name": "add_item", "method_description": "def add_item(self, item_name, price, quantity):\n \"\"\"\n Adds a product to the vending machine's inventory.\n :param item_name: The name of the product to be added, str.\n :param price: The price of the product to be added, float.\n :param quantity: The quantity of the product to be added, int.\n :return: None\n >>> vendingMachine = VendingMachine()\n >>> vendingMachine.add_item('Coke', 1.25, 10)\n >>> vendingMachine.inventory\n {'Coke': {'price': 1.25, 'quantity': 10}}\n\n \"\"\"", "test_class": "VendingMachineTestAddItem", "test_code": "class VendingMachineTestAddItem(unittest.TestCase):\n def test_add_item(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_add_item_2(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n vendingMachine.add_item('Coke', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 20}})\n\n def test_add_item_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}})\n\n def test_add_item_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 20}})\n\n def test_add_item_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n vendingMachine.add_item('Coke', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 20}, 'Pizza': {'price': 1.25, 'quantity': 20}})", "solution_code": "def add_item(self, item_name, price, quantity):\n if not self.restock_item(item_name, quantity):\n self.inventory[item_name] = {'price': price, 'quantity': quantity}", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [ "restock_item" ] } }, { "method_name": "insert_coin", "method_description": "def insert_coin(self, amount):\n \"\"\"\n Inserts coins into the vending machine.\n :param amount: The amount of coins to be inserted, float.\n :return: The balance of the vending machine after the coins are inserted, float.\n >>> vendingMachine = VendingMachine()\n >>> vendingMachine.insert_coin(1.25)\n 1.25\n\n \"\"\"", "test_class": "VendingMachineTestInsertCoin", "test_code": "class VendingMachineTestInsertCoin(unittest.TestCase):\n def test_insert_coin(self):\n vendingMachine = VendingMachine()\n self.assertEqual(vendingMachine.insert_coin(1.25), 1.25)\n\n def test_insert_coin_2(self):\n vendingMachine = VendingMachine()\n self.assertEqual(vendingMachine.insert_coin(2.5), 2.5)\n\n def test_insert_coin_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n self.assertEqual(vendingMachine.balance, 2.50)\n\n def test_insert_coin_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.balance = 1.25\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n self.assertEqual(vendingMachine.balance, 5.0)\n\n def test_insert_coin_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.balance = 1.25\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n self.assertEqual(vendingMachine.balance, 6.25)", "solution_code": "def insert_coin(self, amount):\n self.balance += amount\n return self.balance", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.balance" ], "method_dependencies": [] } }, { "method_name": "purchase_item", "method_description": "def purchase_item(self, item_name):\n \"\"\"\n Purchases a product from the vending machine and returns the balance after the purchase and display purchase unsuccessful if the product is out of stock.\n :param item_name: The name of the product to be purchased, str.\n :return: If successful, returns the balance of the vending machine after the product is purchased, float,otherwise,returns False.\n >>> vendingMachine = VendingMachine()\n >>> vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n >>> vendingMachine.balance = 1.25\n >>> vendingMachine.purchase_item('Coke')\n 0.0\n >>> vendingMachine.purchase_item('Pizza')\n False\n\n \"\"\"", "test_class": "VendingMachineTestPurchaseItem", "test_code": "class VendingMachineTestPurchaseItem(unittest.TestCase):\n def test_purchase_item(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n vendingMachine.balance = 1.25\n self.assertEqual(vendingMachine.purchase_item('Coke'), 0.0)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 9}})\n\n def test_purchase_item_2(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n vendingMachine.balance = 1.25\n self.assertEqual(vendingMachine.purchase_item('Pizza'), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_purchase_item_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n vendingMachine.balance = 0\n self.assertEqual(vendingMachine.purchase_item('Coke'), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_purchase_item_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 0}}\n vendingMachine.balance = 1.25\n self.assertEqual(vendingMachine.purchase_item('Coke'), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 0}})\n\n def test_purchase_item_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n vendingMachine.balance = 1.25\n self.assertEqual(vendingMachine.purchase_item('Pizza'), 0.0)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 9}})", "solution_code": "def purchase_item(self, item_name):\n if item_name in self.inventory:\n item = self.inventory[item_name]\n if item['quantity'] > 0 and self.balance >= item['price']:\n self.balance -= item['price']\n item['quantity'] -= 1\n return self.balance\n else:\n return False\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.balance", "self.inventory" ], "method_dependencies": [] } }, { "method_name": "restock_item", "method_description": "def restock_item(self, item_name, quantity):\n \"\"\"\n Replenishes the inventory of a product already in the vending machine.\n :param item_name: The name of the product to be replenished, str.\n :param quantity: The quantity of the product to be replenished, int.\n :return: If the product is already in the vending machine, returns True, otherwise, returns False.\n >>> vendingMachine = VendingMachine()\n >>> vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n >>> vendingMachine.restock_item('Coke', 10)\n True\n >>> vendingMachine.restock_item('Pizza', 10)\n False\n\n \"\"\"", "test_class": "VendingMachineTestRestockItem", "test_code": "class VendingMachineTestRestockItem(unittest.TestCase):\n def test_restock_item(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.restock_item('Coke', 10), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 20}})\n\n def test_restock_item_2(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.restock_item('Pizza', 10), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_restock_item_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 0}}\n self.assertEqual(vendingMachine.restock_item('Coke', 10), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_restock_item_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.restock_item('Pizza', 10), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 20}})\n\n def test_restock_item_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.restock_item('Pizza', 0), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}})", "solution_code": "def restock_item(self, item_name, quantity):\n if item_name in self.inventory:\n self.inventory[item_name]['quantity'] += quantity\n return True\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } }, { "method_name": "display_items", "method_description": "def display_items(self):\n \"\"\"\n Displays the products in the vending machine.\n :return: If the vending machine is empty, returns False, otherwise, returns a list of the products in the vending machine, str.\n >>> vendingMachine = VendingMachine()\n >>> vendingMachine.display_items()\n False\n >>> vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10} }\n >>> vendingMachine.display_items()\n 'Coke - $1.25 [10]'\n\n \"\"\"", "test_class": "VendingMachineTestDisplayItems", "test_code": "class VendingMachineTestDisplayItems(unittest.TestCase):\n def test_display_items(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.display_items(), 'Coke - $1.25 [10]')\n\n def test_display_items_2(self):\n vendingMachine = VendingMachine()\n self.assertEqual(vendingMachine.display_items(), False)\n\n def test_display_items_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.display_items(),\"Coke - $1.25 [10]\\nPizza - $1.25 [10]\")\n\n def test_display_items_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 0}}\n self.assertEqual(vendingMachine.display_items(), 'Coke - $1.25 [0]')\n\n def test_display_items_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 0}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.display_items(), 'Coke - $1.25 [0]\\nPizza - $1.25 [10]')", "solution_code": "def display_items(self):\n if not self.inventory:\n return False\n else:\n items = []\n for item_name, item_info in self.inventory.items():\n items.append(f\"{item_name} - ${item_info['price']} [{item_info['quantity']}]\")\n return \"\\n\".join(items)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } } ]

[ "VendingMachineTestAddItem", "VendingMachineTestInsertCoin", "VendingMachineTestPurchaseItem", "VendingMachineTestRestockItem", "VendingMachineTestDisplayItems", "VendingMachineTestMain" ]

[ "self.balance", "self.inventory" ]

[]

[ { "method_name": "add_product", "method_description": "def add_product(self, product_id, name, quantity):\n \"\"\"\n Add product to inventory and plus the quantity if it has existed in inventory.\n Or just add new product to dict otherwise.\n :param product_id: int\n :param name: str, product name\n :param quantity: int, product quantity\n >>> warehouse.add_product(1, \"product1\", 3)\n >>> warehouse.inventory\n {1: {'name': 'product1', 'quantity': 3}}\n \"\"\"", "test_class": "WarehouseTestAddProduct", "test_code": "class WarehouseTestAddProduct(unittest.TestCase):\n def test_add_product_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 10}})\n\n def test_add_product_2(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.add_product(2, 'product 2', 5)\n self.assertEqual(warehouse.inventory,\n {1: {'name': 'product 1', 'quantity': 10}, 2: {'name': 'product 2', 'quantity': 5}})\n\n def test_add_product_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 3', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 3', 'quantity': 10}})\n\n def test_add_product_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 4', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 4', 'quantity': 10}})\n\n def test_add_product_5(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 5', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 5', 'quantity': 10}})\n\n def test_add_product_6(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 5', 10)\n warehouse.add_product(1, 'product 5', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 5', 'quantity': 20}})", "solution_code": "def add_product(self, product_id, name, quantity):\n if product_id not in self.inventory:\n self.inventory[product_id] = {'name': name, 'quantity': quantity}\n else:\n self.inventory[product_id]['quantity'] += quantity", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } }, { "method_name": "update_product_quantity", "method_description": "def update_product_quantity(self, product_id, quantity):\n \"\"\"\n According to product_id, add the quantity to the corresponding product in inventory.\n >>> warehouse.add_product(1, \"product1\", 3)\n >>> warehouse.update_product_quantity(1, -1)\n >>> warehouse.inventory\n {1: {'name': 'product1', 'quantity': 2}}\n \"\"\"", "test_class": "WarehouseTestUpdateProductQuantity", "test_code": "class WarehouseTestUpdateProductQuantity(unittest.TestCase):\n def test_update_product_quantity_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.update_product_quantity(1, 5)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 15}})\n\n # quantity is negative\n def test_update_product_quantity_2(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.update_product_quantity(1, -5)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 5}})\n\n def test_update_product_quantity_3(self):\n warehouse = Warehouse()\n warehouse.update_product_quantity(1, -5)\n self.assertEqual(warehouse.inventory, {})\n\n def test_update_product_quantity_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.update_product_quantity(1, 1)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 11}})\n\n def test_update_product_quantity_5(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.update_product_quantity(1, -9)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 1}})", "solution_code": "def update_product_quantity(self, product_id, quantity):\n if product_id in self.inventory:\n self.inventory[product_id]['quantity'] += quantity", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } }, { "method_name": "get_product_quantity", "method_description": "def get_product_quantity(self, product_id):\n \"\"\"\n Get the quantity of specific product by product_id.\n :param product_id, int\n :return: if the product_id is in inventory then return the corresponding quantity,\n or False otherwise.\n >>> warehouse.add_product(1, \"product1\", 3)\n >>> warehouse.get_product_quantity(1)\n 3\n >>> warehouse.get_product_quantity(2)\n False\n \"\"\"", "test_class": "WarehouseTestGetProductQuantity", "test_code": "class WarehouseTestGetProductQuantity(unittest.TestCase):\n def test_get_product_quantity_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n self.assertEqual(warehouse.get_product_quantity(1), 10)\n\n def test_get_product_quantity_2(self):\n warehouse = Warehouse()\n self.assertEqual(warehouse.get_product_quantity(1), False)\n\n def test_get_product_quantity_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 5)\n self.assertEqual(warehouse.get_product_quantity(1), 5)\n\n def test_get_product_quantity_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 100)\n self.assertEqual(warehouse.get_product_quantity(1), 100)\n\n def test_get_product_quantity_5(self):\n warehouse = Warehouse()\n warehouse.add_product(5, 'product 1', 10)\n self.assertEqual(warehouse.get_product_quantity(5), 10)", "solution_code": "def get_product_quantity(self, product_id):\n if product_id in self.inventory:\n return self.inventory[product_id]['quantity']\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.inventory" ], "method_dependencies": [] } }, { "method_name": "create_order", "method_description": "def create_order(self, order_id, product_id, quantity):\n \"\"\"\n Create a order which includes the infomation of product, like id and quantity.\n And put the new order into self.orders.\n The default value of status is 'Shipped'.\n :param order_id: int\n :param product_id: int\n :param quantity: the quantity of product that be selected.\n :return False: only if product_id is not in inventory or the quantity is not adequate\n >>> warehouse.add_product(1, \"product1\", 3)\n >>> warehouse.create_order(1, 1, 2)\n >>> warehouse.orders\n {1: {'product_id': 1, 'quantity': 2, 'status': 'Shipped'}}\n >>> warehouse.create_order(1, 2, 2)\n False\n \"\"\"", "test_class": "WarehouseTestCreateOrder", "test_code": "class WarehouseTestCreateOrder(unittest.TestCase):\n def test_create_order_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.create_order(1, 1, 5)\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Shipped'}})\n\n def test_create_order_2(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n result = warehouse.create_order(1, 1, 15)\n self.assertFalse(result)\n\n def test_create_order_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 1)\n warehouse.create_order(1, 1, 1)\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 1, 'status': 'Shipped'}})\n\n def test_create_order_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 4', 5)\n warehouse.create_order(1, 1, 5)\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Shipped'}})\n\n def test_create_order_5(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 5', 100)\n warehouse.create_order(1, 1, 50)\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 50, 'status': 'Shipped'}})", "solution_code": "def create_order(self, order_id, product_id, quantity):\n if self.get_product_quantity(product_id) >= quantity:\n self.update_product_quantity(product_id, -quantity)\n self.orders[order_id] = {'product_id': product_id, 'quantity': quantity, 'status': 'Shipped'}\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.orders" ], "method_dependencies": [ "update_product_quantity", "get_product_quantity" ] } }, { "method_name": "change_order_status", "method_description": "def change_order_status(self, order_id, status):\n \"\"\"\n Change the status of order if the input order_id is in self.orders.\n :param order_id: int\n :param status: str, the state that is going to change to\n :return False: only if the order_id is not in self.orders\n >>> warehouse.add_product(1, \"product1\", 3)\n >>> warehouse.create_order(1, 1, 2)\n >>> warehouse.change_order_status(1, \"done\")\n >>> warehouse.orders\n {1: {'product_id': 1, 'quantity': 2, 'status': 'done'}}\n \"\"\"", "test_class": "WarehouseTestChangeOrderStatus", "test_code": "class WarehouseTestChangeOrderStatus(unittest.TestCase):\n def test_change_order_status_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.create_order(1, 1, 5)\n warehouse.change_order_status(1, 'Delivered')\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Delivered'}})\n\n def test_change_order_status_2(self):\n warehouse = Warehouse()\n result = warehouse.change_order_status(1, 'Delivered')\n self.assertFalse(result)\n\n def test_change_order_status_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 3', 5)\n warehouse.create_order(1, 1, 5)\n warehouse.change_order_status(1, 'Delivered')\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Delivered'}})\n\n def test_change_order_status_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 4', 100)\n warehouse.create_order(1, 1, 50)\n warehouse.change_order_status(1, 'Delivered')\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 50, 'status': 'Delivered'}})\n\n def test_change_order_status_5(self):\n warehouse = Warehouse()\n result = warehouse.change_order_status(2, 'Delivered')\n self.assertFalse(result)", "solution_code": "def change_order_status(self, order_id, status):\n if order_id in self.orders:\n self.orders[order_id]['status'] = status\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.orders" ], "method_dependencies": [] } }, { "method_name": "track_order", "method_description": "def track_order(self, order_id):\n \"\"\"\n Get the status of specific order.\n :param order_id: int\n :return False: only if the order_id is not in self.orders.\n >>> warehouse.add_product(1, \"product1\", 3)\n >>> warehouse.create_order(1, 1, 2)\n >>> warehouse.track_order(1)\n 'Shipped'\n \"\"\"", "test_class": "WarehouseTestTrackOrder", "test_code": "class WarehouseTestTrackOrder(unittest.TestCase):\n def test_track_order_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.create_order(1, 1, 5)\n self.assertEqual(warehouse.track_order(1), 'Shipped')\n\n def test_track_order_2(self):\n warehouse = Warehouse()\n result = warehouse.track_order(1)\n self.assertFalse(result)\n\n def test_track_order_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 3', 10)\n warehouse.create_order(1, 1, 1)\n self.assertEqual(warehouse.track_order(1), 'Shipped')\n\n def test_track_order_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 4', 100)\n warehouse.create_order(1, 1, 50)\n self.assertEqual(warehouse.track_order(1), 'Shipped')\n\n def test_track_order_5(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 5', 100)\n warehouse.create_order(1, 1, 10)\n self.assertEqual(warehouse.track_order(1), 'Shipped')", "solution_code": "def track_order(self, order_id):\n if order_id in self.orders:\n return self.orders[order_id]['status']\n else:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.orders" ], "method_dependencies": [] } } ]

[ "WarehouseTestAddProduct", "WarehouseTestUpdateProductQuantity", "WarehouseTestGetProductQuantity", "WarehouseTestCreateOrder", "WarehouseTestChangeOrderStatus", "WarehouseTestTrackOrder", "WarehouseTestMain" ]

[ "self.inventory", "self.orders" ]

[]

[ { "method_name": "query", "method_description": "def query(self, weather_list, tmp_units = 'celsius'):\n \"\"\"\n Query the weather system for the weather and temperature of the city,and convert the temperature units based on the input parameter.\n :param weather_list: a dictionary of weather information for different cities,dict.\n :param tmp_units: the temperature units to convert to, str.\n :return: the temperature and weather of the city, tuple.\n >>> weatherSystem = WeatherSystem('New York')\n >>> weather_list = {'New York': {'weather': 'sunny','temperature': 27,'temperature units': 'celsius'},'Beijing': {'weather': 'cloudy','temperature': 23,'temperature units': 'celsius'}}\n >>> weatherSystem.query(weather_list)\n (27, 'sunny')\n\n \"\"\"", "test_class": "WeatherSystemTestQuery", "test_code": "class WeatherSystemTestQuery(unittest.TestCase):\n def test_query(self):\n weatherSystem = WeatherSystem('New York')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list), (27, 'sunny'))\n\n def test_query_2(self):\n weatherSystem = WeatherSystem('Shanghai')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list), False)\n\n def test_query_3(self):\n weatherSystem = WeatherSystem('Beijing')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list, 'fahrenheit'), (73.4, 'cloudy'))\n\n def test_query_4(self):\n weatherSystem = WeatherSystem('Beijing')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 73.47,\n 'temperature units': 'fahrenheit'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 73.4,\n 'temperature units': 'fahrenheit'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list, 'celsius'), (23.000000000000004, 'cloudy'))\n\n def test_query_5(self):\n weatherSystem = WeatherSystem('New York')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 80.6,\n 'temperature units': 'fahrenheit'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list, tmp_units='celsius'), (26.999999999999996, 'sunny'))\n\n def test_query_6(self):\n weatherSystem = WeatherSystem('New York')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list, tmp_units='fahrenheit'), (80.6, 'sunny'))", "solution_code": "def query(self, weather_list, tmp_units = 'celsius'):\n self.weather_list = weather_list\n if self.city not in weather_list:\n return False\n else:\n self.temperature = self.weather_list[self.city]['temperature']\n self.weather = self.weather_list[self.city]['weather']\n if self.weather_list[self.city]['temperature units'] != tmp_units:\n if tmp_units == 'celsius':\n return self.fahrenheit_to_celsius(), self.weather\n elif tmp_units == 'fahrenheit':\n return self.celsius_to_fahrenheit(), self.weather\n else:\n return self.temperature, self.weather", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.city", "self.temperature", "self.weather", "self.weather_list" ], "method_dependencies": [ "celsius_to_fahrenheit", "fahrenheit_to_celsius" ] } }, { "method_name": "set_city", "method_description": "def set_city(self, city):\n \"\"\"\n Set the city of the weather system.\n :param city: the city to set, str.\n :return: None\n >>> weatherSystem = WeatherSystem('New York')\n >>> weatherSystem.set_city('Beijing')\n >>> weatherSystem.city\n 'Beijing'\n\n \"\"\"", "test_class": "WeatherSystemTestSetCity", "test_code": "class WeatherSystemTestSetCity(unittest.TestCase):\n def test_set_city(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Beijing')\n self.assertEqual(weatherSystem.city, 'Beijing')\n\n def test_set_city_2(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Shanghai')\n self.assertEqual(weatherSystem.city, 'Shanghai')\n\n def test_set_city_3(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Shanghai')\n self.assertNotEqual(weatherSystem.city, 'Beijing')\n\n def test_set_city_4(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Shanghai')\n self.assertNotEqual(weatherSystem.city, 'New York')\n\n def test_set_city_5(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Shanghai')\n self.assertNotEqual(weatherSystem.city, 'Tokyo')", "solution_code": "def set_city(self, city):\n self.city = city", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.city" ], "method_dependencies": [] } }, { "method_name": "celsius_to_fahrenheit", "method_description": "def celsius_to_fahrenheit(self):\n \"\"\"\n Convert the temperature from Celsius to Fahrenheit.\n :return: the temperature in Fahrenheit, float.\n >>> weatherSystem = WeatherSystem('New York')\n >>> weatherSystem.temperature = 27\n >>> weatherSystem.celsius_to_fahrenheit()\n 80.6\n\n \"\"\"", "test_class": "WeatherSystemTestCelsiusToFahrenheit", "test_code": "class WeatherSystemTestCelsiusToFahrenheit(unittest.TestCase):\n def test_celsius_to_fahrenheit(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 27\n self.assertEqual(weatherSystem.celsius_to_fahrenheit(), 80.6)\n\n def test_celsius_to_fahrenheit_2(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 23\n self.assertEqual(weatherSystem.celsius_to_fahrenheit(), 73.4)\n\n def test_celsius_to_fahrenheit_3(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 23\n self.assertNotEqual(weatherSystem.celsius_to_fahrenheit(), 80.6)\n\n def test_celsius_to_fahrenheit_4(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 27\n self.assertNotEqual(weatherSystem.celsius_to_fahrenheit(), 73.4)\n\n def test_celsius_to_fahrenheit_5(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 27\n self.assertNotEqual(weatherSystem.celsius_to_fahrenheit(), 23)", "solution_code": "def celsius_to_fahrenheit(self):\n return (self.temperature * 9/5) + 32", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.temperature" ], "method_dependencies": [] } }, { "method_name": "fahrenheit_to_celsius", "method_description": "def fahrenheit_to_celsius(self):\n \"\"\"\n Convert the temperature from Fahrenheit to Celsius.\n :return: the temperature in Celsius, float.\n >>> weatherSystem = WeatherSystem('New York')\n >>> weatherSystem.temperature = 80.6\n >>> weatherSystem.fahrenheit_to_celsius()\n 26.999999999999996\n\n \"\"\"", "test_class": "WeatherSystemTestFahrenheitToCelsius", "test_code": "class WeatherSystemTestFahrenheitToCelsius(unittest.TestCase):\n def test_fahrenheit_to_celsius(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 80.6\n self.assertEqual(weatherSystem.fahrenheit_to_celsius(), 26.999999999999996)\n\n def test_fahrenheit_to_celsius_2(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 73.4\n self.assertEqual(weatherSystem.fahrenheit_to_celsius(), 23.000000000000004)\n\n def test_fahrenheit_to_celsius_3(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 80\n self.assertNotEqual(weatherSystem.fahrenheit_to_celsius(), 23)\n\n def test_fahrenheit_to_celsius_4(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 73\n self.assertNotEqual(weatherSystem.fahrenheit_to_celsius(), 27)\n\n def test_fahrenheit_to_celsius_5(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 80\n self.assertNotEqual(weatherSystem.fahrenheit_to_celsius(), 27)", "solution_code": "def fahrenheit_to_celsius(self):\n return (self.temperature - 32) * 5/9", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.temperature" ], "method_dependencies": [] } } ]

[ "WeatherSystemTestQuery", "WeatherSystemTestSetCity", "WeatherSystemTestCelsiusToFahrenheit", "WeatherSystemTestFahrenheitToCelsius", "WeatherSystemTestMain" ]

[ "self.city", "self.temperature", "self.weather", "self.weather_list" ]

[]

[ { "method_name": "text2int", "method_description": "def text2int(self, textnum):\n \"\"\"\n Convert the word string to the corresponding integer string\n :param textnum: string, the word string to be converted\n :return: string, the final converted integer string\n >>> w2n = Words2Numbers()\n >>> w2n.text2int(\"thirty-two\")\n \"32\"\n \"\"\"", "test_class": "Words2NumbersTestText2Int", "test_code": "class Words2NumbersTestText2Int(unittest.TestCase):\n def test_text2int(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"thirty-two\"), \"32\")\n\n def test_text2int2(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"one hundred and twenty-three\"), \"123\")\n\n def test_text2int3(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"two thousand and nineteen\"), \"2019\")\n\n def test_text2int4(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"one hundred and one\"), \"101\")\n\n def test_text2int5(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"one million and eleven\"), \"1000011\")\n\n def test_text2int6(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"one million one hundred sixty-ninth\"), \"1000169\")", "solution_code": "def text2int(self, textnum):\n textnum = textnum.replace('-', ' ')\n\n current = result = 0\n curstring = \"\"\n onnumber = False\n for word in textnum.split():\n if word in self.ordinal_words:\n scale, increment = (1, self.ordinal_words[word])\n current = current * scale + increment\n onnumber = True\n else:\n for ending, replacement in self.ordinal_endings:\n if word.endswith(ending):\n word = \"%s%s\" % (word[:-len(ending)], replacement)\n\n if word not in self.numwords:\n if onnumber:\n curstring += repr(result + current) + \" \"\n curstring += word + \" \"\n result = current = 0\n onnumber = False\n else:\n scale, increment = self.numwords[word]\n current = current * scale + increment\n if scale > 100:\n result += current\n current = 0\n onnumber = True\n\n if onnumber:\n curstring += repr(result + current)\n\n return curstring", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.numwords", "self.ordinal_endings", "self.ordinal_words" ], "method_dependencies": [] } }, { "method_name": "is_valid_input", "method_description": "def is_valid_input(self, textnum):\n \"\"\"\n Check if the input text contains only valid words that can be converted into numbers.\n :param textnum: The input text containing words representing numbers.\n :return: True if input is valid, False otherwise.\n >>> w2n = Words2Numbers()\n >>> w2n.is_valid_input(\"thirty-two\")\n False\n \"\"\"", "test_class": "Words2NumbersTestIsValidInput", "test_code": "class Words2NumbersTestIsValidInput(unittest.TestCase):\n def test_is_valid_input(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"twenty-five thousand three hundred and forty-two\"))\n\n def test_is_valid_input2(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"second hundred and third\"))\n\n def test_is_valid_input3(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"twenty-fifth thousand three hundred and forty-second\"))\n\n def test_is_valid_input4(self):\n w2n = Words2Numbers()\n self.assertFalse(w2n.is_valid_input(\"eleventy thousand and five\"))\n\n def test_is_valid_input5(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"seventy two thousand and hundred eleven\"))\n\n def test_is_valid_input6(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"fifteenth hundred\"))", "solution_code": "def is_valid_input(self, textnum):\n\n textnum = textnum.replace('-', ' ')\n\n for word in textnum.split():\n if word in self.ordinal_words:\n continue\n else:\n for ending, replacement in self.ordinal_endings:\n if word.endswith(ending):\n word = \"%s%s\" % (word[:-len(ending)], replacement)\n\n if word not in self.numwords:\n return False\n\n return True", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.numwords", "self.ordinal_endings", "self.ordinal_words" ], "method_dependencies": [] } } ]

[ "Words2NumbersTestText2Int", "Words2NumbersTestIsValidInput", " Words2NumbersTestMain" ]

[ "self.numwords", "self.ordinal_endings", "self.ordinal_words", "self.scales", "self.tens", "self.units" ]

[ "import xml.etree.ElementTree as ET" ]

[ { "method_name": "read_xml", "method_description": "def read_xml(self):\n \"\"\"\n Reads the XML file and returns the root element.\n :return: Element, the root element of the XML file.\n >>> xml_processor = XMLProcessor('test.xml')\n >>> root_element = xml_processor.read_xml()\n >>> print(root_element)\n <Element 'root' at 0x7f8e3b7eb180>\n \"\"\"", "test_class": "XMLProcessorTestReadXml", "test_code": "class XMLProcessorTestReadXml(unittest.TestCase):\n def test_read_xml_1(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>banana</item>\\n <item>orange</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n root = self.processor.read_xml()\n self.assertIsNotNone(root)\n lst = root.findall('item')\n self.assertEqual(lst[0].text, 'apple')\n self.assertEqual(lst[1].text, 'banana')\n self.assertEqual(lst[2].text, 'orange')\n\n os.remove('test.xml')\n\n def test_read_xml_2(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>aaa</item>\\n <item>bbb</item>\\n <item>ccc</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n root = self.processor.read_xml()\n self.assertIsNotNone(root)\n lst = root.findall('item')\n self.assertEqual(lst[0].text, 'aaa')\n self.assertEqual(lst[1].text, 'bbb')\n self.assertEqual(lst[2].text, 'ccc')\n\n os.remove('test.xml')\n\n def test_read_xml_3(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n root = self.processor.read_xml()\n self.assertIsNotNone(root)\n lst = root.findall('item')\n self.assertEqual(lst[0].text, 'apple')\n\n os.remove('test.xml')\n\n def test_read_xml_4(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>banana</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n root = self.processor.read_xml()\n self.assertIsNotNone(root)\n lst = root.findall('item')\n self.assertEqual(lst[0].text, 'apple')\n self.assertEqual(lst[1].text, 'banana')\n\n os.remove('test.xml')\n\n def test_read_xml_5(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>orange</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n root = self.processor.read_xml()\n self.assertIsNotNone(root)\n lst = root.findall('item')\n self.assertEqual(lst[0].text, 'apple')\n self.assertEqual(lst[1].text, 'orange')\n\n os.remove('test.xml')\n\n def test_read_xml_6(self):\n self.xml_file = ''\n self.processor = XMLProcessor(self.xml_file)\n\n root = self.processor.read_xml()\n self.assertIsNone(root)", "solution_code": "def read_xml(self):\n try:\n tree = ET.parse(self.file_name)\n self.root = tree.getroot()\n return self.root\n except:\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.file_name", "self.root" ], "method_dependencies": [] } }, { "method_name": "write_xml", "method_description": "def write_xml(self, file_name):\n \"\"\"\n Writes the XML data to the specified file.\n :param file_name: string, the name of the file to write the XML data.\n :return: bool, True if the write operation is successful, False otherwise.\n >>> xml_processor = XMLProcessor('test.xml')\n >>> root = xml_processor.read_xml()\n >>> success = xml_processor.write_xml('output.xml')\n >>> print(success)\n True\n \"\"\"", "test_class": "XMLProcessorTestWriteXml", "test_code": "class XMLProcessorTestWriteXml(unittest.TestCase):\n def test_write_xml_1(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>banana</item>\\n <item>orange</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'output.xml'\n result = self.processor.write_xml(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'apple')\n self.assertEqual(lst[1].text, 'banana')\n self.assertEqual(lst[2].text, 'orange')\n\n os.remove('output.xml')\n os.remove('test.xml')\n\n def test_write_xml_2(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>banana</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'output.xml'\n result = self.processor.write_xml(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'apple')\n self.assertEqual(lst[1].text, 'banana')\n\n os.remove('output.xml')\n os.remove('test.xml')\n\n def test_write_xml_3(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'output.xml'\n result = self.processor.write_xml(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'apple')\n\n os.remove('output.xml')\n os.remove('test.xml')\n\n def test_write_xml_4(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>aaa</item>\\n <item>bbb</item>\\n <item>ccc</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'output.xml'\n result = self.processor.write_xml(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'aaa')\n self.assertEqual(lst[1].text, 'bbb')\n self.assertEqual(lst[2].text, 'ccc')\n\n os.remove('output.xml')\n os.remove('test.xml')\n\n def test_write_xml_5(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>orange</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'output.xml'\n result = self.processor.write_xml(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'apple')\n self.assertEqual(lst[1].text, 'orange')\n\n os.remove('output.xml')\n os.remove('test.xml')\n\n def test_write_xml_6(self):\n self.xml_file = ''\n self.processor = XMLProcessor(self.xml_file)\n\n result = self.processor.write_xml(\"\")\n self.assertFalse(result)", "solution_code": "def write_xml(self, file_name):\n try:\n tree = ET.ElementTree(self.root)\n tree.write(file_name)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.root" ], "method_dependencies": [] } }, { "method_name": "process_xml_data", "method_description": "def process_xml_data(self, file_name):\n \"\"\"\n Modifies the data in XML elements and writes the updated XML data to a new file.\n :param file_name: string, the name of the file to write the modified XML data.\n :return: bool, True if the write operation is successful, False otherwise.\n >>> xml_processor = XMLProcessor('test.xml')\n >>> root = xml_processor.read_xml()\n >>> success = xml_processor.process_xml_data('processed.xml')\n >>> print(success)\n True\n \"\"\"", "test_class": "XMLProcessorTestProcessXmlData", "test_code": "class XMLProcessorTestProcessXmlData(unittest.TestCase):\n def test_process_xml_data_1(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>banana</item>\\n <item>orange</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'processed.xml'\n result = self.processor.process_xml_data(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'APPLE')\n self.assertEqual(lst[1].text, 'BANANA')\n self.assertEqual(lst[2].text, 'ORANGE')\n\n os.remove('processed.xml')\n os.remove('test.xml')\n\n def test_process_xml_data_2(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>banana</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'processed.xml'\n result = self.processor.process_xml_data(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'APPLE')\n self.assertEqual(lst[1].text, 'BANANA')\n\n os.remove('processed.xml')\n os.remove('test.xml')\n\n def test_process_xml_data_3(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'processed.xml'\n result = self.processor.process_xml_data(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'APPLE')\n\n os.remove('processed.xml')\n os.remove('test.xml')\n\n def test_process_xml_data_4(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>orange</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'processed.xml'\n result = self.processor.process_xml_data(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'APPLE')\n self.assertEqual(lst[1].text, 'ORANGE')\n\n os.remove('processed.xml')\n os.remove('test.xml')\n\n def test_process_xml_data_5(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>aaa</item>\\n <item>bbb</item>\\n <item>ccc</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n file_name = 'processed.xml'\n result = self.processor.process_xml_data(file_name)\n self.assertTrue(result)\n\n processor1 = XMLProcessor(file_name)\n tree1 = ET.parse(processor1.file_name)\n processor1.root = tree1.getroot()\n\n self.assertIsNotNone(processor1.root)\n lst = processor1.root.findall('item')\n self.assertEqual(lst[0].text, 'AAA')\n self.assertEqual(lst[1].text, 'BBB')\n self.assertEqual(lst[2].text, 'CCC')\n\n os.remove('processed.xml')\n os.remove('test.xml')", "solution_code": "def process_xml_data(self, file_name):\n for element in self.root.iter('item'):\n text = element.text\n element.text = text.upper()\n return self.write_xml(file_name)", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.root" ], "method_dependencies": [ "write_xml" ] } }, { "method_name": "find_element", "method_description": "def find_element(self, element_name):\n \"\"\"\n Finds the XML elements with the specified name.\n :param element_name: string, the name of the elements to find.\n :return: list, a list of found elements with the specified name.\n >>> xml_processor = XMLProcessor('test.xml')\n >>> root = xml_processor.read_xml()\n >>> items = xml_processor.find_element('item')\n >>> for item in items:\n >>> print(item.text)\n apple\n banana\n orange\n \"\"\"", "test_class": "XMLProcessorTestFindElement", "test_code": "class XMLProcessorTestFindElement(unittest.TestCase):\n def test_find_element_1(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>banana</item>\\n <item>orange</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n element_name = 'item'\n root = self.processor.read_xml()\n elements = self.processor.find_element(element_name)\n self.assertEqual(len(elements), 3)\n self.assertEqual(elements[0].text, 'apple')\n self.assertEqual(elements[1].text, 'banana')\n self.assertEqual(elements[2].text, 'orange')\n\n os.remove('test.xml')\n\n def test_find_element_2(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>banana</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n element_name = 'item'\n root = self.processor.read_xml()\n elements = self.processor.find_element(element_name)\n self.assertEqual(len(elements), 2)\n self.assertEqual(elements[0].text, 'apple')\n self.assertEqual(elements[1].text, 'banana')\n\n os.remove('test.xml')\n\n def test_find_element_3(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n element_name = 'item'\n root = self.processor.read_xml()\n elements = self.processor.find_element(element_name)\n self.assertEqual(len(elements), 1)\n self.assertEqual(elements[0].text, 'apple')\n\n os.remove('test.xml')\n\n def test_find_element_4(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>apple</item>\\n <item>orange</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n element_name = 'item'\n root = self.processor.read_xml()\n elements = self.processor.find_element(element_name)\n self.assertEqual(len(elements), 2)\n self.assertEqual(elements[0].text, 'apple')\n self.assertEqual(elements[1].text, 'orange')\n\n os.remove('test.xml')\n\n def test_find_element_5(self):\n with open('test.xml', 'w') as f:\n f.write('<root>\\n <item>aaa</item>\\n <item>bbb</item>\\n <item>ccc</item>\\n</root>')\n self.xml_file = 'test.xml'\n self.processor = XMLProcessor(self.xml_file)\n tree = ET.parse(self.processor.file_name)\n self.processor.root = tree.getroot()\n\n element_name = 'item'\n root = self.processor.read_xml()\n elements = self.processor.find_element(element_name)\n self.assertEqual(len(elements), 3)\n self.assertEqual(elements[0].text, 'aaa')\n self.assertEqual(elements[1].text, 'bbb')\n self.assertEqual(elements[2].text, 'ccc')\n\n os.remove('test.xml')", "solution_code": "def find_element(self, element_name):\n elements = self.root.findall(element_name)\n return elements", "dependencies": { "Standalone": false, "lib_dependencies": [], "field_dependencies": [ "self.root" ], "method_dependencies": [] } } ]

[ "XMLProcessorTestReadXml", "XMLProcessorTestWriteXml", "XMLProcessorTestProcessXmlData", "XMLProcessorTestFindElement", "XMLProcessorTest" ]

[ "self.file_name", "self.root" ]

[ "import zipfile" ]

[ { "method_name": "read_zip_file", "method_description": "def read_zip_file(self):\n \"\"\"\n Get open file object\n :return:If successful, returns the open file object; otherwise, returns None\n >>> zfp = ZipFileProcessor(\"aaa.zip\")\n >>> file = zfp.read_zip_file()\n \"\"\"", "test_class": "ZipFileProcessorTestReadZipFile", "test_code": "class ZipFileProcessorTestReadZipFile(unittest.TestCase):\n def test_read_zip_file_1(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example1.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n\n zip_file = processor.read_zip_file()\n self.assertEqual(zip_file.filename, 'example1.zip')\n self.assertEqual(zip_file.mode, 'r')\n zip_file.close()\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_read_zip_file_2(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example2.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n\n zip_file = processor.read_zip_file()\n self.assertEqual(zip_file.filename, 'example2.zip')\n self.assertEqual(zip_file.mode, 'r')\n zip_file.close()\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_read_zip_file_3(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example3.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n\n zip_file = processor.read_zip_file()\n self.assertEqual(zip_file.filename, 'example3.zip')\n self.assertEqual(zip_file.mode, 'r')\n zip_file.close()\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_read_zip_file_4(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example4.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n\n zip_file = processor.read_zip_file()\n self.assertEqual(zip_file.filename, 'example4.zip')\n self.assertEqual(zip_file.mode, 'r')\n zip_file.close()\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_read_zip_file_5(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example5.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n zip_file = processor.read_zip_file()\n self.assertEqual(zip_file.filename, 'example5.zip')\n self.assertEqual(zip_file.mode, 'r')\n zip_file.close()\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_read_zip_file_6(self):\n processor = ZipFileProcessor(\"\")\n\n zip_file = processor.read_zip_file()\n self.assertIsNone(zip_file)", "solution_code": "def read_zip_file(self):\n try:\n zip_file = zipfile.ZipFile(self.file_name, 'r')\n return zip_file\n except:\n return None", "dependencies": { "Standalone": false, "lib_dependencies": [ "zipfile" ], "field_dependencies": [ "self.file_name" ], "method_dependencies": [] } }, { "method_name": "extract_all", "method_description": "def extract_all(self, output_path):\n \"\"\"\n Extract all zip files and place them in the specified path\n :param output_path: string, The location of the extracted file\n :return: True or False, representing whether the extraction operation was successful\n >>> zfp = ZipFileProcessor(\"aaa.zip\")\n >>> zfp.extract_all(\"result/aaa\")\n \"\"\"", "test_class": "ZipFileProcessorTestExtractAll", "test_code": "class ZipFileProcessorTestExtractAll(unittest.TestCase):\n def test_extract_all_1(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example1.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_all(output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example1.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_all_2(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example2.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_all(output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example2.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_all_3(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example3.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_all(output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example3.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_all_4(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example4.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_all(output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example4.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_all_5(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example5.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_all(output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example5.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_all_6(self):\n processor = ZipFileProcessor(\"\")\n\n success = processor.extract_all(\"\")\n self.assertFalse(success)", "solution_code": "def extract_all(self, output_path):\n try:\n with zipfile.ZipFile(self.file_name, 'r') as zip_file:\n zip_file.extractall(output_path)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "zipfile" ], "field_dependencies": [ "self.file_name" ], "method_dependencies": [] } }, { "method_name": "extract_file", "method_description": "def extract_file(self, file_name, output_path):\n \"\"\"\n Extract the file with the specified name from the zip file and place it in the specified path\n :param file_name:string, The name of the file to be uncompressed\n :param output_path:string, The location of the extracted file\n :return: True or False, representing whether the extraction operation was successful\n >>> zfp = ZipFileProcessor(\"aaa.zip\")\n >>> zfp.extract_file(\"bbb.txt\", \"result/aaa\")\n \"\"\"", "test_class": "ZipFileProcessorTestExtractFile", "test_code": "class ZipFileProcessorTestExtractFile(unittest.TestCase):\n def test_extract_file_1(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example1.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_file('example1.txt', output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example1.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_file_2(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example2.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_file('example2.txt', output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example2.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_file_3(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example3.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_file('example3.txt', output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example3.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_file_4(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example4.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n success = processor.extract_file('example4.txt', output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example4.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_file_5(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example5.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n\n success = processor.extract_file('example5.txt', output_directory)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(os.path.join(output_directory, 'example5.txt')))\n\n os.remove(zip_file_name)\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_extract_file_6(self):\n processor = ZipFileProcessor(\"\")\n\n success = processor.extract_file(\"\", \"\")\n self.assertFalse(success)", "solution_code": "def extract_file(self, file_name, output_path):\n try:\n with zipfile.ZipFile(self.file_name, 'r') as zip_file:\n zip_file.extract(file_name, output_path)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "zipfile" ], "field_dependencies": [ "self.file_name" ], "method_dependencies": [] } }, { "method_name": "create_zip_file", "method_description": "def create_zip_file(self, files, output_file_name):\n \"\"\"\n Compress the specified file list into a zip file and place it in the specified path\n :param files:list of string, List of files to compress\n :param output_file_name: string, Specified output path\n :return:True or False, representing whether the compression operation was successful\n >>> zfp = ZipFileProcessor(\"aaa.zip\")\n >>> zfp.create_zip_file([\"bbb.txt\", \"ccc,txt\", \"ddd.txt\"], \"output/bcd\")\n \"\"\"", "test_class": "ZipFileProcessorTestCreateZipFile", "test_code": "class ZipFileProcessorTestCreateZipFile(unittest.TestCase):\n def test_create_zip_file_1(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example1.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n files_to_zip = [example_file_path]\n success = processor.create_zip_file(files_to_zip, new_zip_file)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(new_zip_file))\n\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_create_zip_file_2(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example2.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n files_to_zip = [example_file_path]\n success = processor.create_zip_file(files_to_zip, new_zip_file)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(new_zip_file))\n\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_create_zip_file_3(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example3.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n files_to_zip = [example_file_path]\n success = processor.create_zip_file(files_to_zip, new_zip_file)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(new_zip_file))\n\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_create_zip_file_4(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example4.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n output_directory = 'output_directory'\n new_zip_file = 'new_zip_file.zip'\n\n files_to_zip = [example_file_path]\n success = processor.create_zip_file(files_to_zip, new_zip_file)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(new_zip_file))\n\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_create_zip_file_5(self):\n test_folder = 'test_folder'\n os.makedirs(test_folder, exist_ok=True)\n example_file_path = os.path.join(test_folder, 'example5.txt')\n with open(example_file_path, 'w') as file:\n file.write('This is an example file.')\n\n zip_file_name = 'example.zip'\n with zipfile.ZipFile(zip_file_name, 'w') as zip_file:\n zip_file.write(example_file_path, os.path.basename(example_file_path))\n\n processor = ZipFileProcessor(zip_file_name)\n new_zip_file = 'new_zip_file.zip'\n\n files_to_zip = [example_file_path]\n success = processor.create_zip_file(files_to_zip, new_zip_file)\n self.assertTrue(success)\n self.assertTrue(os.path.exists(new_zip_file))\n\n os.remove(example_file_path)\n os.rmdir(test_folder)\n\n def test_create_zip_file_6(self):\n processor = ZipFileProcessor(\"\")\n\n success = processor.create_zip_file(\"\", \"\")\n self.assertFalse(success)", "solution_code": "def create_zip_file(self, files, output_file_name):\n try:\n with zipfile.ZipFile(output_file_name, 'w') as zip_file:\n for file in files:\n zip_file.write(file)\n return True\n except:\n return False", "dependencies": { "Standalone": false, "lib_dependencies": [ "zipfile" ], "field_dependencies": [], "method_dependencies": [] } } ]

[ "ZipFileProcessorTestReadZipFile", "ZipFileProcessorTestExtractAll", "ZipFileProcessorTestExtractFile", "ZipFileProcessorTestCreateZipFile", "ZipFileProcessorTest" ]

[ "self.file_name" ]