pygeai 0.7.0b3__py3-none-any.whl → 0.7.0b4__py3-none-any.whl

pygeai/tests/core/utils/test_parsers.py

@@ -0,0 +1,379 @@
+import unittest
+from unittest.mock import Mock
+from json import JSONDecodeError
+
+from pygeai.core.utils.parsers import parse_json_response
+from pygeai.core.common.exceptions import InvalidAPIResponseException
+
+
+class TestParseJsonResponse(unittest.TestCase):
+    """
+    Comprehensive tests for parse_json_response() function.
+    
+    Run with:
+        python -m unittest pygeai.tests.core.utils.test_parsers.TestParseJsonResponse
+    """
+
+    def test_parse_valid_json_simple(self):
+        """Test parsing simple valid JSON response"""
+        mock_response = Mock()
+        mock_response.json.return_value = {"key": "value"}
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        self.assertEqual(result, {"key": "value"})
+        mock_response.json.assert_called_once()
+
+    def test_parse_valid_json_complex(self):
+        """Test parsing complex nested JSON response"""
+        complex_data = {
+            "data": {
+                "items": [1, 2, 3],
+                "metadata": {
+                    "count": 3,
+                    "nested": {
+                        "deep": "value"
+                    }
+                }
+            },
+            "status": "success"
+        }
+        mock_response = Mock()
+        mock_response.json.return_value = complex_data
+        
+        result = parse_json_response(mock_response, "fetch data")
+        
+        self.assertEqual(result, complex_data)
+        self.assertEqual(result["data"]["items"], [1, 2, 3])
+        self.assertEqual(result["data"]["metadata"]["nested"]["deep"], "value")
+
+    def test_parse_valid_json_empty_object(self):
+        """Test parsing empty JSON object"""
+        mock_response = Mock()
+        mock_response.json.return_value = {}
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        self.assertEqual(result, {})
+
+    def test_parse_valid_json_array(self):
+        """Test parsing JSON array"""
+        mock_response = Mock()
+        mock_response.json.return_value = [1, 2, 3, 4, 5]
+        
+        result = parse_json_response(mock_response, "get list")
+        
+        self.assertEqual(result, [1, 2, 3, 4, 5])
+
+    def test_parse_valid_json_null_values(self):
+        """Test parsing JSON with null values"""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "field1": None,
+            "field2": "value",
+            "field3": None
+        }
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        self.assertIsNone(result["field1"])
+        self.assertEqual(result["field2"], "value")
+        self.assertIsNone(result["field3"])
+
+    def test_parse_json_decode_error_no_context(self):
+        """Test JSONDecodeError handling without context"""
+        mock_response = Mock()
+        mock_response.json.side_effect = JSONDecodeError("msg", "doc", 0)
+        mock_response.status_code = 500
+        mock_response.text = "Invalid JSON"
+        
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            parse_json_response(mock_response, "get data")
+        
+        exception_msg = str(context.exception)
+        self.assertIn("Unable to get data", exception_msg)
+        self.assertIn("Invalid JSON", exception_msg)
+
+    def test_parse_json_decode_error_single_context(self):
+        """Test JSONDecodeError with single context parameter"""
+        mock_response = Mock()
+        mock_response.json.side_effect = JSONDecodeError("msg", "doc", 0)
+        mock_response.status_code = 404
+        mock_response.text = "Not found"
+        
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            parse_json_response(
+                mock_response, 
+                "get agent", 
+                agent_id="agent-123"
+            )
+        
+        exception_msg = str(context.exception)
+        self.assertIn("Unable to get agent 'agent-123'", exception_msg)
+        self.assertIn("Not found", exception_msg)
+
+    def test_parse_json_decode_error_multiple_context(self):
+        """Test JSONDecodeError with multiple context parameters"""
+        mock_response = Mock()
+        mock_response.json.side_effect = JSONDecodeError("msg", "doc", 0)
+        mock_response.status_code = 400
+        mock_response.text = "Bad request"
+        
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            parse_json_response(
+                mock_response,
+                "update agent",
+                agent_id="agent-123",
+                project_id="proj-456"
+            )
+        
+        exception_msg = str(context.exception)
+        self.assertIn("Unable to update agent", exception_msg)
+        # Should contain both context values
+        self.assertIn("agent-123", exception_msg)
+        self.assertIn("proj-456", exception_msg)
+
+    def test_parse_json_different_status_codes(self):
+        """Test error handling with various HTTP status codes"""
+        status_codes = [400, 401, 403, 404, 500, 502, 503]
+        
+        for status_code in status_codes:
+            with self.subTest(status_code=status_code):
+                mock_response = Mock()
+                mock_response.json.side_effect = JSONDecodeError("msg", "doc", 0)
+                mock_response.status_code = status_code
+                mock_response.text = f"Error {status_code}"
+                
+                with self.assertRaises(InvalidAPIResponseException):
+                    parse_json_response(mock_response, "test operation")
+
+    def test_parse_json_special_characters(self):
+        """Test parsing JSON with special characters"""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "text": "Hello \"world\"",
+            "unicode": "こんにちは",
+            "symbols": "!@#$%^&*()",
+            "newlines": "line1\nline2\nline3"
+        }
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        self.assertEqual(result["text"], "Hello \"world\"")
+        self.assertEqual(result["unicode"], "こんにちは")
+        self.assertEqual(result["symbols"], "!@#$%^&*()")
+        self.assertEqual(result["newlines"], "line1\nline2\nline3")
+
+    def test_parse_json_large_numbers(self):
+        """Test parsing JSON with large numbers"""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "small": 1,
+            "large_int": 9999999999999999,
+            "float": 123.456789,
+            "scientific": 1.23e-10
+        }
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        self.assertEqual(result["small"], 1)
+        self.assertEqual(result["large_int"], 9999999999999999)
+        self.assertAlmostEqual(result["float"], 123.456789, places=6)
+
+    def test_parse_json_boolean_values(self):
+        """Test parsing JSON with boolean values"""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "true_value": True,
+            "false_value": False,
+            "null_value": None
+        }
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        self.assertTrue(result["true_value"])
+        self.assertFalse(result["false_value"])
+        self.assertIsNone(result["null_value"])
+
+    def test_parse_json_empty_string_response(self):
+        """Test handling of empty string JSON response"""
+        mock_response = Mock()
+        mock_response.json.side_effect = JSONDecodeError("Expecting value", "", 0)
+        mock_response.status_code = 200
+        mock_response.text = ""
+        
+        with self.assertRaises(InvalidAPIResponseException):
+            parse_json_response(mock_response, "test operation")
+
+    def test_parse_json_preserves_order(self):
+        """Test that JSON parsing preserves data structure"""
+        ordered_data = {
+            "first": 1,
+            "second": 2,
+            "third": 3,
+            "array": ["a", "b", "c"]
+        }
+        mock_response = Mock()
+        mock_response.json.return_value = ordered_data
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        self.assertEqual(list(result.keys()), ["first", "second", "third", "array"])
+        self.assertEqual(result["array"], ["a", "b", "c"])
+
+    def test_parse_json_with_context_formatting(self):
+        """Test that context formatting works correctly in error messages"""
+        mock_response = Mock()
+        mock_response.json.side_effect = JSONDecodeError("msg", "doc", 0)
+        mock_response.status_code = 500
+        mock_response.text = "Error"
+        
+        # Test with string context
+        with self.assertRaises(InvalidAPIResponseException) as ctx:
+            parse_json_response(mock_response, "operation", name="test")
+        self.assertIn("'test'", str(ctx.exception))
+        
+        # Test with numeric context
+        with self.assertRaises(InvalidAPIResponseException) as ctx:
+            parse_json_response(mock_response, "operation", id=123)
+        self.assertIn("'123'", str(ctx.exception))
+
+    def test_parse_json_real_world_api_response(self):
+        """Test parsing realistic API response structure"""
+        api_response = {
+            "id": "agent-123",
+            "name": "Test Agent",
+            "status": "active",
+            "created_at": "2024-01-01T00:00:00Z",
+            "metadata": {
+                "version": "1.0",
+                "tags": ["production", "critical"]
+            },
+            "config": {
+                "temperature": 0.7,
+                "max_tokens": 1000
+            }
+        }
+        mock_response = Mock()
+        mock_response.json.return_value = api_response
+        
+        result = parse_json_response(mock_response, "get agent", agent_id="agent-123")
+        
+        self.assertEqual(result["id"], "agent-123")
+        self.assertEqual(result["name"], "Test Agent")
+        self.assertEqual(result["metadata"]["version"], "1.0")
+        self.assertEqual(len(result["metadata"]["tags"]), 2)
+        self.assertEqual(result["config"]["temperature"], 0.7)
+
+
+class TestParseJsonResponseEdgeCases(unittest.TestCase):
+    """
+    Edge case tests for parse_json_response()
+    
+    Run with:
+        python -m unittest pygeai.tests.core.utils.test_parsers.TestParseJsonResponseEdgeCases
+    """
+
+    def test_response_json_method_not_callable(self):
+        """Test behavior when response.json is not callable"""
+        mock_response = Mock()
+        mock_response.json = "not a method"
+        
+        with self.assertRaises(TypeError):
+            parse_json_response(mock_response, "test operation")
+
+    def test_response_without_json_method(self):
+        """Test behavior when response has no json method"""
+        mock_response = Mock(spec=[])  # No methods
+        
+        with self.assertRaises(AttributeError):
+            parse_json_response(mock_response, "test operation")
+
+    def test_json_method_raises_other_exception(self):
+        """Test that non-JSONDecodeError exceptions are not caught"""
+        mock_response = Mock()
+        mock_response.json.side_effect = ValueError("Some other error")
+        
+        # Should raise ValueError, not catch it
+        with self.assertRaises(ValueError):
+            parse_json_response(mock_response, "test operation")
+
+    def test_extremely_nested_json(self):
+        """Test parsing deeply nested JSON structure"""
+        # Create deeply nested structure
+        nested = {"level": 10}
+        for i in range(9, 0, -1):
+            nested = {"level": i, "nested": nested}
+        
+        mock_response = Mock()
+        mock_response.json.return_value = nested
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        # Verify we can access deep nesting
+        current = result
+        for i in range(1, 11):
+            self.assertEqual(current["level"], i)
+            if i < 10:
+                current = current["nested"]
+
+    def test_json_with_mixed_types_in_array(self):
+        """Test parsing array with mixed types"""
+        mock_response = Mock()
+        mock_response.json.return_value = {
+            "mixed": [1, "string", True, None, {"key": "value"}, [1, 2, 3]]
+        }
+        
+        result = parse_json_response(mock_response, "test operation")
+        
+        self.assertEqual(result["mixed"][0], 1)
+        self.assertEqual(result["mixed"][1], "string")
+        self.assertTrue(result["mixed"][2])
+        self.assertIsNone(result["mixed"][3])
+        self.assertEqual(result["mixed"][4], {"key": "value"})
+        self.assertEqual(result["mixed"][5], [1, 2, 3])
+
+    def test_context_with_special_characters(self):
+        """Test context parameters with special characters"""
+        mock_response = Mock()
+        mock_response.json.side_effect = JSONDecodeError("msg", "doc", 0)
+        mock_response.status_code = 400
+        mock_response.text = "Error"
+        
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            parse_json_response(
+                mock_response,
+                "test operation",
+                name="Agent's \"Special\" Name"
+            )
+        
+        exception_msg = str(context.exception)
+        self.assertIn("Unable to test operation", exception_msg)
+
+    def test_response_text_with_html(self):
+        """Test error message when response.text contains HTML"""
+        mock_response = Mock()
+        mock_response.json.side_effect = JSONDecodeError("msg", "doc", 0)
+        mock_response.status_code = 500
+        mock_response.text = "<html><body>Internal Server Error</body></html>"
+        
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            parse_json_response(mock_response, "test operation")
+        
+        exception_msg = str(context.exception)
+        self.assertIn("<html>", exception_msg)
+
+    def test_multiple_calls_same_response(self):
+        """Test that calling parse multiple times works correctly"""
+        mock_response = Mock()
+        mock_response.json.return_value = {"key": "value"}
+        
+        result1 = parse_json_response(mock_response, "operation 1")
+        result2 = parse_json_response(mock_response, "operation 2")
+        
+        self.assertEqual(result1, result2)
+        self.assertEqual(mock_response.json.call_count, 2)
+
+
+if __name__ == '__main__':
+    unittest.main()

{pygeai-0.7.0b3.dist-info → pygeai-0.7.0b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeai
-Version: 0.7.0b3
+Version: 0.7.0b4
 Summary: Software Development Kit to interact with Globant Enterprise AI.
 Author-email: Globant <geai-sdk@globant.com>
 License-Expression: MIT

{pygeai-0.7.0b3.dist-info → pygeai-0.7.0b4.dist-info}/RECORD

@@ -164,7 +164,7 @@ pygeai/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/auth/clients.py,sha256=8ND_iZS3Ac-BOjbh1ZmIadYlAiTc6_WDgoCkO1dBaD8,6264
 pygeai/auth/endpoints.py,sha256=5gScXVyalZgz1R5KyuZcKPGKFT_FLuSroixp5vPUKbo,696
 pygeai/chat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pygeai/chat/clients.py,sha256=Qxdzs63mtNpgdT5Cw6n9rsQ7U0SLI8ePxdlWf2oBkq8,19819
+pygeai/chat/clients.py,sha256=QO95Ncx3vwcYAWRtDMbNsX3RSenf1ao1nsRSiUQwq8U,20189
 pygeai/chat/endpoints.py,sha256=r_zvsL5UIqnqhz9I0CG0eQSKV-egwx6EKdaZXj-HndA,343
 pygeai/chat/iris.py,sha256=-9pDHQpWhR_PvbZ6rD8eMPFk46PI9sCdPQ9aAyvSexs,413
 pygeai/chat/managers.py,sha256=65HfuLD68eTmNpKXf_qE7cyrwhvF6VLR2vbz52v4CEk,3095
@@ -214,7 +214,7 @@ pygeai/cli/commands/lab/utils.py,sha256=uxhgHvCRrV6WYRxR2qd3nED_hhXcxJ1tAU8Mlzos
 pygeai/cli/texts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/cli/texts/help.py,sha256=gZAqxuS6g_t1QqRjoi9Gm0YuIJBWD5k1EZXeBxIw24Q,25459
 pygeai/core/__init__.py,sha256=bbNktFp7t2dOBIvWto-uGVBW8acaKIe8EKcfuLV-HmA,189
-pygeai/core/handlers.py,sha256=la1QcQbLwfiNd-xDQ3jtWRHmeEm6E93Rfx5c-5bkLmw,934
+pygeai/core/handlers.py,sha256=j9fkUHWkkaCx1uZhdLu-wCXrxVym18B-4NNRtEXwJPA,1350
 pygeai/core/models.py,sha256=XLdoqekExCsLTMhF_4UsuzzvlaemPNZdH11hleSIrW8,27443
 pygeai/core/responses.py,sha256=wxlikhw1UAAB6Mib97xjq2eCFyZPWoosPwn9UhpKi7Y,2825
 pygeai/core/singleton.py,sha256=aZ9muxWwkHuEqytwZjTTE9UTlyl272BCQDFhjYrIS1k,1013
@@ -271,7 +271,7 @@ pygeai/core/services/llm/model.py,sha256=dv0vH2uGQDzyXh63A_nr_bmMukr6Q9nO7LuiWgv
 pygeai/core/services/llm/providers.py,sha256=CS1v4qSiibuL51fQlgcARiyPoXxSnCeV5RXwNc1nmgA,293
 pygeai/core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/core/utils/console.py,sha256=wsrKxisnawwqz3w0JkvkgjZqEsrQ1twyDe_WGn1QMzM,5321
-pygeai/core/utils/parsers.py,sha256=783HSQX7CDRKHU7WQQ9o_sS_ucMrYNDXvC_pKw1F-P4,1303
+pygeai/core/utils/parsers.py,sha256=WsKWKv6bqSmFeKixE9M-ptf_4UwpjotUK4WWvVH0ZQw,1933
 pygeai/core/utils/validators.py,sha256=LoDrO5z0K8_axMdoMHGZZHlxdIFQWnzC9L7RbEQFITg,328
 pygeai/dbg/__init__.py,sha256=yVJAWK9z9CGKRH5Mw8ZYQ0w5qOw86nXeqtRVqt_zu64,147
 pygeai/dbg/debugger.py,sha256=xJfKVNFSxIoM6SLDBbThcU0wai6ERxzxB-sUP6wRCs8,35685
@@ -307,7 +307,7 @@ pygeai/lab/agents/endpoints.py,sha256=a3pcvP5ONGEsMyj7sTnpyPjlGPq7mHZY_5qEYK4QxE
 pygeai/lab/agents/mappers.py,sha256=3w12HwWj3tnoSbDmQb-sMXjiCm84X_YU4_iH46GWu6s,12563
 pygeai/lab/processes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/lab/processes/clients.py,sha256=7CSFCzeymFG1eJUM69wGt2LjSyTG66IxiTCzAUsc_bw,43870
-pygeai/lab/processes/endpoints.py,sha256=nFIEcNP22xe4j6URI6KcwTh7h-xgYjYYuHT6PDPiO3I,2100
+pygeai/lab/processes/endpoints.py,sha256=5tuLINk7lBe-4SPgCKxCHC6MlMgpnTQ8RAYc-AmVe98,2105
 pygeai/lab/processes/mappers.py,sha256=YOWcVKdcJmLMAq-f3qevzqQ8L_hjb0_jVXBdCHutpzk,15815
 pygeai/lab/spec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/lab/spec/loader.py,sha256=Dq9MhLqFwF4RPdBBaqKPGqt43-PrNlsHpe-NXe4S0qQ,709
@@ -374,6 +374,7 @@ pygeai/tests/chat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 pygeai/tests/chat/test_clients.py,sha256=W2mhur_v8cLxR2PuQaZqZM1FJchap9x9ZDNwkfT3p5g,15894
 pygeai/tests/chat/test_iris.py,sha256=o9pxXkk8Sv9YZ4twxbG4-ZvIv6pST8GHa3t1F-NOH3w,1179
 pygeai/tests/chat/test_session.py,sha256=yIxUJJGRXWPjwxvsosIE7AygzKoJ45GIx5DCUYgTRqY,2906
+pygeai/tests/chat/test_streaming_json.py,sha256=e-Wx-X0LWxMZu2hjJHLDQ6HFRmNpNH2Tzl4VlR8gbt8,15946
 pygeai/tests/chat/test_ui.py,sha256=9gp8FwiJ8HkDTvd093Ac1bLMcfhbDbJfUwWAUpj78Ro,8868
 pygeai/tests/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/cli/test_credentials_flag.py,sha256=0bqEBGLcUg5frZHOmiB-ZlpYrqqBLTMfBGF8lfH1QFk,12782
@@ -389,6 +390,7 @@ pygeai/tests/cli/commands/test_evaluation.py,sha256=svwVS8DF7G1fuRMLHXqzseL3c0QR
 pygeai/tests/cli/commands/test_feedback.py,sha256=gHJ8Jt8kEemTvlpWLCyZCo73i0iBPlKhONRj4bJfhWU,3192
 pygeai/tests/cli/commands/test_files.py,sha256=cJ0W4f8eg1T2TBZCah1k93nrk7R8ZL6_1HwCOhJOacI,7583
 pygeai/tests/cli/commands/test_gam.py,sha256=oIFj4HJV6z1fQkIU2BmgP1VJ2zJ65UWDM6a3G8AenHM,8318
+pygeai/tests/cli/commands/test_json_parsing.py,sha256=7SmN119ZY5dVNX-hGfQ4ulv-6R0yXg-ursybU9i2oF0,14355
 pygeai/tests/cli/commands/test_llm.py,sha256=Mazqs8eUXjhZ1wWys96QU19XBeE8xNwh3PfCYdQXWbA,5247
 pygeai/tests/cli/commands/test_migrate.py,sha256=k3z7M9fE_5IsWUmsTUDGQz0eNWYo50779jKmc_iVTeo,7834
 pygeai/tests/cli/commands/test_organization.py,sha256=hHmw5sSgL1tWxf5pBuNtnLO-O4CACEv-eV-lQeO3TBs,12728
@@ -443,6 +445,7 @@ pygeai/tests/core/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 pygeai/tests/core/services/test_rest.py,sha256=CmBTpI6INCAfuxMZGraY4DnCCUk6H2Qn6bb0le6NM8U,10820
 pygeai/tests/core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/core/utils/test_console.py,sha256=z6iegGWCZXtl-dUICpK2__jNcev2cGvXHkTpzCqXwmo,3250
+pygeai/tests/core/utils/test_parsers.py,sha256=0dbbI1JjNC0_SEEBB3j9UURfKDk-sUovdcOP5waIydQ,14438
 pygeai/tests/dbg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pygeai/tests/dbg/test_debugger.py,sha256=EN8MDAeUNvB5C5-iqXhZ-yfL1Vldo2jK_v927hRRQ1s,23705
 pygeai/tests/evaluation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -798,9 +801,9 @@ pygeai/vendor/a2a/utils/helpers.py,sha256=6Tbd8SVfXvdNEk6WYmLOjrAxkzFf1aIg8dkFfB
 pygeai/vendor/a2a/utils/message.py,sha256=gc_EKO69CJ4HkR76IFgsy-kENJz1dn7CfSgWJWvt-gs,2197
 pygeai/vendor/a2a/utils/task.py,sha256=BYRA_L1HpoUGJAVlyHML0lCM9Awhf2Ovjj7oPFXKbh0,1647
 pygeai/vendor/a2a/utils/telemetry.py,sha256=VvSp1Ztqaobkmq9-3sNhhPEilJS32-JTSfKzegkj6FU,10861
-pygeai-0.7.0b3.dist-info/licenses/LICENSE,sha256=eHfqo7-AWS8cMq0cg03lq7owsLeCmZA-xS5L0kuHnl8,1474
-pygeai-0.7.0b3.dist-info/METADATA,sha256=elYIOCtPtIsTa_Mu9SL02gE-wjR5UJgNHvQP0SpRyIY,8710
-pygeai-0.7.0b3.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-pygeai-0.7.0b3.dist-info/entry_points.txt,sha256=OAmwuXVCQBTCE3HeVegVd37hbhCcp9TPahvdrCuMYWw,178
-pygeai-0.7.0b3.dist-info/top_level.txt,sha256=bJFwp2tURmCfB94yXDF7ylvdSJXFDDJsyUOb-7PJgwc,7
-pygeai-0.7.0b3.dist-info/RECORD,,
+pygeai-0.7.0b4.dist-info/licenses/LICENSE,sha256=eHfqo7-AWS8cMq0cg03lq7owsLeCmZA-xS5L0kuHnl8,1474
+pygeai-0.7.0b4.dist-info/METADATA,sha256=QcvN2UwJZ0k-9nIREsP1YvyP2NiY3g2MNFOskwxT3Sc,8710
+pygeai-0.7.0b4.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+pygeai-0.7.0b4.dist-info/entry_points.txt,sha256=OAmwuXVCQBTCE3HeVegVd37hbhCcp9TPahvdrCuMYWw,178
+pygeai-0.7.0b4.dist-info/top_level.txt,sha256=bJFwp2tURmCfB94yXDF7ylvdSJXFDDJsyUOb-7PJgwc,7
+pygeai-0.7.0b4.dist-info/RECORD,,