mseep-agentops 0.4.18__py3-none-any.whl

mseep_agentops-0.4.18.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: mseep-agentops
+Version: 0.4.18
+Summary: Observability and DevTool Platform for AI Agents
+Home-page: https://github.com/mseep
+Author: mseep
+Author-email: support@skydeck.ai
+Maintainer: mseep
+Maintainer-email: support@skydeck.ai
+Keywords: mseep
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: requests<3.0.0,>=2.0.0
+Requires-Dist: psutil<7.0.1,>=5.9.8
+Requires-Dist: termcolor<2.5.0,>=2.3.0
+Requires-Dist: PyYAML<7.0,>=5.3
+Requires-Dist: packaging<25.0,>=21.0
+Requires-Dist: httpx<0.29.0,>=0.24.0
+Requires-Dist: opentelemetry-sdk==1.29.0; python_version < "3.10"
+Requires-Dist: opentelemetry-sdk>1.29.0; python_version >= "3.10"
+Requires-Dist: opentelemetry-api==1.29.0; python_version < "3.10"
+Requires-Dist: opentelemetry-api>1.29.0; python_version >= "3.10"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http==1.29.0; python_version < "3.10"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>1.29.0; python_version >= "3.10"
+Requires-Dist: ordered-set<5.0.0,>=4.0.0
+Requires-Dist: wrapt<2.0.0,>=1.0.0
+Requires-Dist: opentelemetry-instrumentation==0.50b0; python_version < "3.10"
+Requires-Dist: opentelemetry-instrumentation>=0.50b0; python_version >= "3.10"
+Requires-Dist: opentelemetry-semantic-conventions==0.50b0; python_version < "3.10"
+Requires-Dist: opentelemetry-semantic-conventions>=0.50b0; python_version >= "3.10"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Package managed by MseeP.ai

mseep_agentops-0.4.18.dist-info/RECORD

@@ -0,0 +1,94 @@
+agentops/__init__.py,sha256=YvY0zsWTEpAhAZOrcb2T2dDs2PxJv-q8rUPuqgdpY0k,18788
+agentops/config.py,sha256=7eu3crglngSeKK0fQ_pFsHGiOjr1gPCaqual8VP0hCA,10090
+agentops/enums.py,sha256=mRvxU_EFzcfXAmlc0vEj2RBe8An0FnIF-3jZdw3ZMa0,980
+agentops/exceptions.py,sha256=HjHLvB20ZadA4ZGsmMlQxh-SVhPYQLFzKv0Q_1Ujbx8,1177
+agentops/validation.py,sha256=Dsxsoa7RbRagcXK56fCWWqgQ5OyUdbM2KjIQjHUp5XA,13294
+agentops/client/__init__.py,sha256=9ot9lZs-zqk50W3zT87Bgql9Cb77mvCaXNpl2x3IhPs,120
+agentops/client/client.py,sha256=jaqzPYSi2Jyyd0Nxjzo97aerN9gsGTIqG4Gjgam0vXQ,10667
+agentops/client/api/__init__.py,sha256=LJJfrjVmm7weWrIRkc28WcV0iogSxU6XR49rOGv7wfI,1906
+agentops/client/api/base.py,sha256=-SkPZyfR1W0KsCpn05u2F0cMfyc5OXEuRkE859DL66g,4439
+agentops/client/api/types.py,sha256=GOhpOPnZF1QCYJ-_qZudbHayD8l6hebJDImZFJGYElk,407
+agentops/client/api/versions/__init__.py,sha256=nyZyYD0dY2I8B7opmIxExlBQnH26lVGWgVXc1zDwi3I,254
+agentops/client/api/versions/v3.py,sha256=MvClQ6_G2DiXCUNIFv36d_wNidKtIQsAt-rRv8Yng0M,2067
+agentops/client/api/versions/v4.py,sha256=PsexNJ5h_AwJXbaKn-6ftoW480ZkHMM3u7ow0vocRfg,3532
+agentops/client/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentops/client/http/http_adapter.py,sha256=M4LHvj8LFFptHSy-60LHLi_oTBWl1D7Y4_Bsq5W0P4U,4351
+agentops/client/http/http_client.py,sha256=O9fggGMgqs5eyKF9jEUAgSoBlbPHvxk0lWQTiOQpuxw,8661
+agentops/helpers/__init__.py,sha256=0YVuyl6CVYUiL5mpkPbsADj_Z_4rgSE8XzCK4OuE0p0,1075
+agentops/helpers/dashboard.py,sha256=T80flB8GlB4ubPj61mB-seAuDTj4lYTa_U-WDstDg4Q,1552
+agentops/helpers/deprecation.py,sha256=Ndv0FVa52OznNUu_lAOrF698IrIFL-EF_alrRqXtDpw,1573
+agentops/helpers/env.py,sha256=cENhgB4QBSG-aZuENI15wUajskT4xLbSZ4NSQj5_tF0,1215
+agentops/helpers/serialization.py,sha256=1XSCfkZGl51R1FQ4NXYu9ceYuDa4Almp0n7ECgHKI5o,3896
+agentops/helpers/system.py,sha256=4DEnWHMu6ulgIAzSt6bzNFa_O7nzwcCp8Me5zVWD3bg,4872
+agentops/helpers/time.py,sha256=XyCknaPCgDBI-FM-n-2lfKJwXUsMPvHzWlK8hc5RPaU,301
+agentops/helpers/version.py,sha256=3kErXu8dtC27L_3BVG1RFbfO4OKtHMgusHxLz-5s5uI,1056
+agentops/instrumentation/__init__.py,sha256=084qkc1Kggo4PPVc5q2GpUbYk-2RoX5O0nLsd7EoN20,25486
+agentops/instrumentation/common/__init__.py,sha256=CYgIOTPUbxpLh47kjeLwLxhLZVA0lpZM9uzJCkr_c40,2287
+agentops/instrumentation/common/attributes.py,sha256=WelUjg80CQKKNENAipz2t9vuSIUNuQ6Rdz_poxovRck,9337
+agentops/instrumentation/common/instrumentor.py,sha256=qOaukvOjXRWN0ltw0eupsVZkWfMoESX0oFK-U1IK5JY,4926
+agentops/instrumentation/common/metrics.py,sha256=sRHuKKTBttU8LE1VTuoU6jLv7d9U2dGvMRC96fr4zQU,3885
+agentops/instrumentation/common/objects.py,sha256=zpMJTsTNDJ-Qgjzqke47uDDYexlmwpGQC83opdmHnkI,982
+agentops/instrumentation/common/span_management.py,sha256=WluRQTrFwFNtVsERfT2Q4W6xntwPsupyfhwLEVSFwMk,6090
+agentops/instrumentation/common/streaming.py,sha256=rSjGhsN8k-so0YjyoqFVtpCeateeApwu5jqOB_De0B0,8085
+agentops/instrumentation/common/token_counting.py,sha256=ZRrmgcR3YCT568l3MU9GH8eb4wO1qu31d0ohWJAkxy8,6502
+agentops/instrumentation/common/version.py,sha256=6HIqtkLEKql_OkpQo1rbOitwTFGWEmlgSVYjXaybi0E,2474
+agentops/instrumentation/common/wrappers.py,sha256=utVwTHxjhS4wCsjPPWtGlFaBy-sBpd4mzy9-I9ftLp0,8242
+agentops/legacy/__init__.py,sha256=8aiLMhFFuzpm_EvwXHAj4mWvYODkBvWFePOjWcBZffc,9749
+agentops/legacy/event.py,sha256=mLlDOaI_WWVOF0uHLYWU0PG5UY3VM8qcux2LCCALcv8,5892
+agentops/logging/__init__.py,sha256=xIz15LVBsdaMzZze-K-vf3z0v467vAz87Khq46Jr7KA,228
+agentops/logging/config.py,sha256=KnX3W1YplmqpuI3j3gAbmuegr3wUsffl2avC2JeDg24,3168
+agentops/logging/formatters.py,sha256=dgi78SUc_yQpL5iga99LNone6OqKeDi-Brgf6ZHjdwY,1062
+agentops/logging/instrument_logging.py,sha256=WurISKObv0eK70FCHw_21V3Dw_OPbQ7smmD_71qPl34,2870
+agentops/sdk/__init__.py,sha256=W9SBzJ9dLnbqaSbsJJ2vmJXMtsWDHttdx2FHdWsjE3s,657
+agentops/sdk/attributes.py,sha256=eSZnHaTRdYFOkoCECuuXPS8Wl-tNM4hZaE6dpDrofAc,4521
+agentops/sdk/core.py,sha256=FdxI0qRfyoppST3WBJYF16kmBsX52PMdTwaq254P7Mk,23993
+agentops/sdk/exporters.py,sha256=lDsydlo-mU4C8_7M4WZ8v5n71pjkYkGIHaViWJkaoJA,3145
+agentops/sdk/processors.py,sha256=kAp70nj_tnO32J-7C9thY0BSS2Ku7qje2qCrH_giO0Y,2451
+agentops/sdk/types.py,sha256=7RMcA65zwiv5zx2-g8z8abtui2UVqpaNujJa7ItY6Yg,889
+agentops/sdk/decorators/__init__.py,sha256=aq1mcjyG6HqxbJIP3JhgjwE_DU1-vKseroWFpbWDg_c,1936
+agentops/sdk/decorators/factory.py,sha256=yR8Z5cS2l2W8ehPwvAP2rt3bASHXygW4Th4Cj9GcWDs,26621
+agentops/sdk/decorators/utility.py,sha256=TxL9hYucmFqiCBOGQ4xaLejBQCjJDo_SaP8qRR3Hkh0,8005
+agentops/semconv/__init__.py,sha256=DxZe_8vlZMsOjlDGGVxysfScfHlRIXHZLOfwyrJLjiA,1357
+agentops/semconv/agent.py,sha256=55fv7BTbYBa_NokK80QBfrloZBx_NyVODhNMaMUaNWQ,1086
+agentops/semconv/core.py,sha256=RI9p6fnSROWjdSI6WolHGrxeoyhNjQy1P5aqmklBxa0,609
+agentops/semconv/enum.py,sha256=oxlWfUyrowFixJDq3fLzbRi9PQQZqr7MU93Ho3oYAKE,215
+agentops/semconv/instrumentation.py,sha256=YKMfXoKS5zDmUHYXwrWKSlVomts9x9sTB4XCwHAnJZA,470
+agentops/semconv/langchain.py,sha256=YIxGgyCWpDMkkNbs5916PBr7-uVFk-dyRICMoPka2Zs,2015
+agentops/semconv/message.py,sha256=YbFwx2ccCs-lrbaeW6kFAF0UhruieGAACdzSQBBJM_M,3644
+agentops/semconv/meters.py,sha256=DCEH0oD745E78k-iEvGmTJjQLIAg3Bkxd_gApvQt8zw,1099
+agentops/semconv/resource.py,sha256=MAj8hHSPrHGGCaMbz1C4Lm0CkJ_JR3BLXto4FKbnmWE,1377
+agentops/semconv/span_attributes.py,sha256=hyTW7KsLB9sp-HDEvbCUiBlkfGXoC5sKMaSSHbcd6JI,5102
+agentops/semconv/span_kinds.py,sha256=NjvowyBDKkWiNW6xND4wuWMYGGcUIxB4bb5xWzTkijc,1564
+agentops/semconv/status.py,sha256=dQ6q-B-kEPWqSPNV7VHF7gojtMgbC-nGvLP_kZe5McY,195
+agentops/semconv/tool.py,sha256=lW1GQWMuMn449TC-Kz-CQCZy7bC76U7fwUbsihWkhSs,514
+agentops/semconv/workflow.py,sha256=N7WsN9DgOPd3lZulS9MJeJRv4zeVnUwC8ZRl0fUbD5o,4290
+mseep_agentops-0.4.18.dist-info/licenses/LICENSE,sha256=zWW9oSZpJVAMBUk-iWOCWBk7c7ITYX2BUU-feXmjKYU,1068
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=JqkAW8DASuGo8kKnc3reM-AUHVu40rbxp5Ko_vUv3bw,156
+tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/unit/conftest.py,sha256=xXtm0ej-As6TQdCMg6JWuxIMbGqIcar9s_c4VPL34nY,1205
+tests/unit/test_config.py,sha256=OWbUvB5-a39bnAJIBYCP5tg0tozYwQA3gCfGCCHYWW8,2811
+tests/unit/test_context_manager.py,sha256=abmPx2Xi0wyRCyWK2Hiq1ykpS0RCgtFHQWRLV2I6ufg,31724
+tests/unit/test_events.py,sha256=nr8DQdhZffW52Eq_Q713G8V5T6LzsVMGhi-w0PdKR1U,657
+tests/unit/test_host_env.py,sha256=991m9TL-AIDs2w-mhWGin043p9Ygp0DrysRG3g1hhWk,1777
+tests/unit/test_init_py.py,sha256=ZsLjj5TOi25uIJn1cOrVeeE1ZEQeyK7o-se17g31RP4,19813
+tests/unit/test_serialization.py,sha256=xKJLpP5CwFJHnJ6Ipog_BxjHycSgJuucZ2rlpngrq_g,13817
+tests/unit/test_session.py,sha256=n9qSNIums64NRPd4cTHbr2OraozFRwexj7PD5tn4_Hk,24303
+tests/unit/test_user_agent.py,sha256=nV02OvG6DCbLYW1I70ty-gtZMrARNHy6wtY7ehgHFig,1329
+tests/unit/test_validation.py,sha256=GgBZGiiOo5tKaQOva2WsHh44xboMsqop9o_37ldKlRQ,16248
+tests/unit/client/__init__.py,sha256=wTTEld19ez6ToxcPNsz6CyTm4edP8SLrav0NUNrFjB4,50
+tests/unit/client/test_http_adapter.py,sha256=pMSCfT0Zk7X-LsGsFRiDDtdgfxnXQpyT3h6ifE7VxMc,9316
+tests/unit/client/test_http_client.py,sha256=qFWzntM1-aLV03xBFjeEVB7fQ-ZTkBZ5gYV1y-KsWgA,7699
+tests/unit/sdk/__init__.py,sha256=pSE-h4UCp-teG9p-a4T0aXHdSCVuVQhw1gyVq-T57JQ,27
+tests/unit/sdk/instrumentation_tester.py,sha256=_LYJRP-SEmfb9FUcAYrzdgC3JbC-gFF-y2-Z3PT_1Ck,7011
+tests/unit/sdk/test_attributes.py,sha256=a4ecfgdoaVpj41upEzNR92_oXsuGU0uTxUx6vMW2_Ng,16759
+tests/unit/sdk/test_concurrent_instrumentation.py,sha256=B047ExN8CJgp_AVCrYWV-rgaKS76NIkFVhRcdjoSovg,20606
+tests/unit/sdk/test_decorators.py,sha256=CQ1OXOmYfJKfPpfBQuSGfXf578YRX0XXkq6AnecY9IY,31492
+tests/unit/sdk/test_exporters.py,sha256=7rnw3UIi1uZWni9wVd99jb7Rayk1v3y0Z_eUp3TvZeU,10091
+tests/unit/sdk/test_factory.py,sha256=ju7CyyV1vyL6TqGGRq4YfqMDpp-jrP918z7GEIgTQuo,47627
+tests/unit/sdk/test_internal_span_processor.py,sha256=Sbs_4QHtQMYqcNUS6yHtRmI7JUXFSpwpShooVOrH8AY,15917
+tests/unit/sdk/test_resource_attributes.py,sha256=476tVAr4Q-EyyNtBtbkRgA02EMuAGju3NSj9iFLAl8Q,1415
+mseep_agentops-0.4.18.dist-info/METADATA,sha256=Zn6ty9CDZJEApqphvjX5c1R4DBrzLZhvSfFyRgYrEMo,1868
+mseep_agentops-0.4.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mseep_agentops-0.4.18.dist-info/top_level.txt,sha256=UrI_CYrHsaaH2rfrGxmVR9jKHfHV2lv1HVENlV8xEeI,15
+mseep_agentops-0.4.18.dist-info/RECORD,,

mseep_agentops-0.4.18.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mseep_agentops-0.4.18.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 AgentOps-AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mseep_agentops-0.4.18.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+agentops
+tests

tests/conftest.py

@@ -0,0 +1,10 @@
+import pytest
+
+
+@pytest.fixture
+def runtime():
+    class _BagOfGoodies(object):
+        config_mock_applied = False
+        pass
+
+    yield _BagOfGoodies()

tests/unit/client/__init__.py

@@ -0,0 +1 @@
+"""Unit tests for the agentops.client package."""

tests/unit/client/test_http_adapter.py

@@ -0,0 +1,221 @@
+"""Tests for the HTTP adapter classes."""
+
+from urllib3.util import Retry
+
+from agentops.client.http.http_adapter import BaseHTTPAdapter
+
+# from agentops.client.auth_manager import AuthManager
+
+
+class TestBaseHTTPAdapter:
+    """Tests for the BaseHTTPAdapter class."""
+
+    def test_init_with_default_params(self):
+        """Test that the adapter initializes with default parameters."""
+        adapter = BaseHTTPAdapter()
+
+        # Verify the adapter was created with the expected parameters
+        assert adapter.poolmanager is not None
+
+        # Check that max_retries was set
+        assert adapter.max_retries is not None
+        assert isinstance(adapter.max_retries, Retry)
+        assert adapter.max_retries.total == 3
+        assert adapter.max_retries.backoff_factor == 0.1
+        assert adapter.max_retries.status_forcelist == [500, 502, 503, 504]
+
+    def test_init_with_custom_params(self):
+        """Test that the adapter initializes with custom parameters."""
+        custom_retry = Retry(total=5, backoff_factor=0.5, status_forcelist=[429, 500, 502, 503, 504])
+
+        adapter = BaseHTTPAdapter(pool_connections=20, pool_maxsize=300, max_retries=custom_retry)
+
+        # Verify the adapter was created with the expected parameters
+        assert adapter.poolmanager is not None
+
+        # Check that max_retries was set to our custom value
+        assert adapter.max_retries is custom_retry
+        assert adapter.max_retries.total == 5
+        assert adapter.max_retries.backoff_factor == 0.5
+        assert adapter.max_retries.status_forcelist == [429, 500, 502, 503, 504]
+
+
+# class TestAuthenticatedHttpAdapter:
+#     """Tests for the AuthenticatedHttpAdapter class."""
+#
+#     @pytest.fixture
+#     def auth_manager(self):
+#         """Create an AuthManager for testing."""
+#         return AuthManager(token_endpoint="https://api.example.com/auth/token")
+#
+#     @pytest.fixture
+#     def token_fetcher(self):
+#         """Create a token fetcher function for testing."""
+#         return mock.Mock(return_value={"token": "test-token", "project_id": "test-project"})
+#
+#     def test_init(self, auth_manager, token_fetcher):
+#         """Test that the adapter initializes correctly."""
+#         adapter = AuthenticatedHttpAdapter(
+#             auth_manager=auth_manager,
+#             api_key="test-api-key",
+#             token_fetcher=token_fetcher
+#         )
+#
+#         # Verify the adapter was created with the expected parameters
+#         assert adapter.auth_manager is auth_manager
+#         assert adapter.api_key == "test-api-key"
+#         assert adapter.token_fetcher is token_fetcher
+#
+#         # Verify it's a subclass of BaseHTTPAdapter
+#         assert isinstance(adapter, BaseHTTPAdapter)
+#
+#     def test_add_headers(self, auth_manager, token_fetcher):
+#         """Test that add_headers adds authentication headers to the request."""
+#         # Setup
+#         adapter = AuthenticatedHttpAdapter(
+#             auth_manager=auth_manager,
+#             api_key="test-api-key",
+#             token_fetcher=token_fetcher
+#         )
+#
+#         # Mock the auth manager methods
+#         auth_manager.maybe_fetch = mock.Mock(return_value={"token": "test-token", "project_id": "test-project"})
+#         auth_manager.prepare_auth_headers = mock.Mock(return_value={
+#             "Authorization": "Bearer test-token",
+#             "Content-Type": "application/json; charset=UTF-8",
+#             "X-Agentops-Api-Key": "test-api-key"
+#         })
+#
+#         # Create a request
+#         request = requests.Request('GET', 'https://api.example.com/test').prepare()
+#
+#         # Call add_headers
+#         modified_request = adapter.add_headers(request)
+#
+#         # Verify the auth manager methods were called
+#         auth_manager.maybe_fetch.assert_called_once_with("test-api-key", token_fetcher)
+#         auth_manager.prepare_auth_headers.assert_called_once_with("test-api-key")
+#
+#         # Verify the headers were added to the request
+#         assert modified_request.headers["Authorization"] == "Bearer test-token"
+#         assert modified_request.headers["Content-Type"] == "application/json; charset=UTF-8"
+#         assert modified_request.headers["X-Agentops-Api-Key"] == "test-api-key"
+#
+#     def test_send_success(self, auth_manager, token_fetcher, mocker: MockerFixture):
+#         """Test that send successfully sends a request."""
+#         # Setup
+#         adapter = AuthenticatedHttpAdapter(
+#             auth_manager=auth_manager,
+#             api_key="test-api-key",
+#             token_fetcher=token_fetcher
+#         )
+#
+#         # Mock the add_headers method
+#         mocker.patch.object(adapter, 'add_headers', side_effect=lambda r, **kw: r)
+#
+#         # Mock the parent send method
+#         mock_response = mock.Mock(spec=requests.Response)
+#         mock_response.status_code = 200
+#         mocker.patch.object(BaseHTTPAdapter, 'send', return_value=mock_response)
+#
+#         # Mock the is_token_expired_response method
+#         auth_manager.is_token_expired_response = mock.Mock(return_value=False)
+#
+#         # Create a request
+#         request = requests.Request('GET', 'https://api.example.com/test').prepare()
+#
+#         # Call send
+#         response = adapter.send(request)
+#
+#         # Verify the response
+#         assert response is mock_response
+#         assert response.status_code == 200
+#
+#         # Verify the methods were called
+#         adapter.add_headers.assert_called_once()
+#         BaseHTTPAdapter.send.assert_called_once()
+#         auth_manager.is_token_expired_response.assert_called_once_with(mock_response)
+#
+#     def test_send_with_token_refresh(self, auth_manager, token_fetcher, mocker: MockerFixture):
+#         """Test that send refreshes the token if it's expired."""
+#         # Setup
+#         adapter = AuthenticatedHttpAdapter(
+#             auth_manager=auth_manager,
+#             api_key="test-api-key",
+#             token_fetcher=token_fetcher
+#         )
+#
+#         # Mock the add_headers method
+#         mocker.patch.object(adapter, 'add_headers', side_effect=lambda r, **kw: r)
+#
+#         # Mock the parent send method to return a 401 response first, then a 200 response
+#         expired_response = mock.Mock(spec=requests.Response)
+#         expired_response.status_code = 401
+#
+#         success_response = mock.Mock(spec=requests.Response)
+#         success_response.status_code = 200
+#
+#         mocker.patch.object(
+#             BaseHTTPAdapter,
+#             'send',
+#             side_effect=[expired_response, success_response]
+#         )
+#
+#         # Mock the auth manager methods
+#         auth_manager.is_token_expired_response = mock.Mock(return_value=True)
+#         auth_manager.clear_token = mock.Mock()
+#         auth_manager.maybe_fetch = mock.Mock(return_value={"token": "new-token", "project_id": "test-project"})
+#
+#         # Create a request
+#         request = requests.Request('GET', 'https://api.example.com/test').prepare()
+#
+#         # Call send
+#         response = adapter.send(request)
+#
+#         # Verify the auth manager methods were called
+#         auth_manager.is_token_expired_response.assert_called_once_with(expired_response)
+#         auth_manager.clear_token.assert_called_once()
+#         auth_manager.maybe_fetch.assert_called_once_with("test-api-key", token_fetcher)
+#
+#         # Verify the response is the success response
+#         assert response is success_response
+#
+#     def test_send_with_token_refresh_failure(self, auth_manager, token_fetcher, mocker: MockerFixture):
+#         """Test that send handles token refresh failures gracefully."""
+#         # Setup
+#         adapter = AuthenticatedHttpAdapter(
+#             auth_manager=auth_manager,
+#             api_key="test-api-key",
+#             token_fetcher=token_fetcher
+#         )
+#
+#         # Mock the add_headers method
+#         mocker.patch.object(adapter, 'add_headers', side_effect=lambda r, **kw: r)
+#
+#         # Mock the parent send method to return a 401 response
+#         expired_response = mock.Mock(spec=requests.Response)
+#         expired_response.status_code = 401
+#
+#         mocker.patch.object(BaseHTTPAdapter, 'send', return_value=expired_response)
+#
+#         # Mock the auth manager methods
+#         auth_manager.is_token_expired_response = mock.Mock(return_value=True)
+#         auth_manager.clear_token = mock.Mock()
+#         auth_manager.maybe_fetch = mock.Mock(side_effect=AgentOpsApiJwtExpiredException("Failed to refresh token"))
+#
+#         # Create a request
+#         request = requests.Request('GET', 'https://api.example.com/test').prepare()
+#
+#         # Call send
+#         response = adapter.send(request)
+#
+#         # Verify the response is the original 401 response
+#         assert response is expired_response
+#         assert response.status_code == 401
+#
+#         # Verify the methods were called
+#         adapter.add_headers.assert_called_once()  # Only called for initial request
+#         BaseHTTPAdapter.send.assert_called_once()  # Only called for initial request
+#         auth_manager.is_token_expired_response.assert_called_once_with(expired_response)
+#         auth_manager.clear_token.assert_called_once()
+#         auth_manager.maybe_fetch.assert_called_once_with("test-api-key", token_fetcher)

tests/unit/client/test_http_client.py

@@ -0,0 +1,206 @@
+# """Tests for the HttpClient class."""
+#
+# import pytest
+# import requests
+# from unittest import mock
+# from pytest_mock import MockerFixture
+#
+# from agentops.client.http.http_client import HttpClient
+# from agentops.client.http.http_adapter import AuthenticatedHttpAdapter, BaseHTTPAdapter
+# from agentops.client.auth_manager import AuthManager
+#
+#
+# class TestHttpClient:
+#     """Tests for the HttpClient class."""
+#
+#     def test_get_session_creates_new_session_if_none_exists(self):
+#         """Test that get_session creates a new session if none exists."""
+#         # Reset the session to ensure we're testing from a clean state
+#         HttpClient._session = None
+#
+#         # Call get_session
+#         session = HttpClient.get_session()
+#
+#         # Verify a session was created
+#         assert session is not None
+#         assert isinstance(session, requests.Session)
+#
+#         # Verify the session has the expected adapters
+#         assert any(isinstance(adapter, BaseHTTPAdapter) for adapter in session.adapters.values())
+#
+#         # Verify the session has the expected headers
+#         assert "Content-Type" in session.headers
+#         assert "Connection" in session.headers
+#         assert "Keep-Alive" in session.headers
+#
+#     def test_get_session_returns_existing_session(self):
+#         """Test that get_session returns the existing session if one exists."""
+#         # Create a session
+#         HttpClient._session = None
+#         session1 = HttpClient.get_session()
+#
+#         # Call get_session again
+#         session2 = HttpClient.get_session()
+#
+#         # Verify the same session was returned
+#         assert session2 is session1
+#
+#     def test_get_authenticated_session_creates_new_session(self):
+#         """Test that get_authenticated_session creates a new authenticated session."""
+#         # Call get_authenticated_session
+#         session = HttpClient.get_authenticated_session(
+#             endpoint="https://api.example.com",
+#             api_key="test-api-key"
+#         )
+#
+#         # Verify a session was created
+#         assert session is not None
+#         assert isinstance(session, requests.Session)
+#
+#         # Verify the session has the expected adapters
+#         assert any(isinstance(adapter, AuthenticatedHttpAdapter) for adapter in session.adapters.values())
+#
+#         # Verify the session has the expected headers
+#         assert "Content-Type" in session.headers
+#         assert "Connection" in session.headers
+#         assert "Keep-Alive" in session.headers
+#
+#     def test_get_authenticated_session_with_custom_token_fetcher(self, mocker: MockerFixture):
+#         """Test that get_authenticated_session accepts a custom token fetcher."""
+#         # Create a mock token fetcher
+#         mock_token_fetcher = mock.Mock(return_value="test-token")
+#
+#         # Call get_authenticated_session with the custom token fetcher
+#         session = HttpClient.get_authenticated_session(
+#             endpoint="https://api.example.com",
+#             api_key="test-api-key",
+#             token_fetcher=mock_token_fetcher
+#         )
+#
+#         # Verify a session was created
+#         assert session is not None
+#         assert isinstance(session, requests.Session)
+#
+#         # Get the adapter
+#         adapter = next(adapter for adapter in session.adapters.values()
+#                       if isinstance(adapter, AuthenticatedHttpAdapter))
+#
+#         # Verify the adapter has the custom token fetcher
+#         assert adapter.token_fetcher is mock_token_fetcher
+#
+#     def test_request_get(self, mocker: MockerFixture):
+#         """Test that request makes a GET request."""
+#         # Mock the session
+#         mock_session = mock.Mock()
+#         mock_get = mock.Mock()
+#         mock_session.get = mock_get
+#
+#         # Mock get_session to return our mock session
+#         mocker.patch.object(HttpClient, "get_session", return_value=mock_session)
+#
+#         # Call request
+#         HttpClient.request(
+#             method="get",
+#             url="https://api.example.com/test",
+#             headers={"X-Test": "test"},
+#             timeout=10
+#         )
+#
+#         # Verify the session method was called with the expected arguments
+#         mock_get.assert_called_once_with(
+#             "https://api.example.com/test",
+#             headers={"X-Test": "test"},
+#             timeout=10,
+#             allow_redirects=False
+#         )
+#
+#     def test_request_post(self, mocker: MockerFixture):
+#         """Test that request makes a POST request."""
+#         # Mock the session
+#         mock_session = mock.Mock()
+#         mock_post = mock.Mock()
+#         mock_session.post = mock_post
+#
+#         # Mock get_session to return our mock session
+#         mocker.patch.object(HttpClient, "get_session", return_value=mock_session)
+#
+#         # Call request
+#         HttpClient.request(
+#             method="post",
+#             url="https://api.example.com/test",
+#             data={"test": "data"},
+#             headers={"X-Test": "test"},
+#             timeout=10
+#         )
+#
+#         # Verify the session method was called with the expected arguments
+#         mock_post.assert_called_once_with(
+#             "https://api.example.com/test",
+#             json={"test": "data"},
+#             headers={"X-Test": "test"},
+#             timeout=10,
+#             allow_redirects=False
+#         )
+#
+#     def test_request_put(self, mocker: MockerFixture):
+#         """Test that request makes a PUT request."""
+#         # Mock the session
+#         mock_session = mock.Mock()
+#         mock_put = mock.Mock()
+#         mock_session.put = mock_put
+#
+#         # Mock get_session to return our mock session
+#         mocker.patch.object(HttpClient, "get_session", return_value=mock_session)
+#
+#         # Call request
+#         HttpClient.request(
+#             method="put",
+#             url="https://api.example.com/test",
+#             data={"test": "data"},
+#             headers={"X-Test": "test"},
+#             timeout=10
+#         )
+#
+#         # Verify the session method was called with the expected arguments
+#         mock_put.assert_called_once_with(
+#             "https://api.example.com/test",
+#             json={"test": "data"},
+#             headers={"X-Test": "test"},
+#             timeout=10,
+#             allow_redirects=False
+#         )
+#
+#     def test_request_delete(self, mocker: MockerFixture):
+#         """Test that request makes a DELETE request."""
+#         # Mock the session
+#         mock_session = mock.Mock()
+#         mock_delete = mock.Mock()
+#         mock_session.delete = mock_delete
+#
+#         # Mock get_session to return our mock session
+#         mocker.patch.object(HttpClient, "get_session", return_value=mock_session)
+#
+#         # Call request
+#         HttpClient.request(
+#             method="delete",
+#             url="https://api.example.com/test",
+#             headers={"X-Test": "test"},
+#             timeout=10
+#         )
+#
+#         # Verify the session method was called with the expected arguments
+#         mock_delete.assert_called_once_with(
+#             "https://api.example.com/test",
+#             headers={"X-Test": "test"},
+#             timeout=10,
+#             allow_redirects=False
+#         )
+#
+#     def test_request_unsupported_method(self):
+#         """Test that request raises an error for unsupported methods."""
+#         # Call request with an unsupported method
+#         with pytest.raises(ValueError, match="Unsupported HTTP method: patch"):
+#             HttpClient.request(
+#                 method="patch",
+#                 url="https://api.example.com/test"
+#             )