Fix typos

* retreive -> retrieve
* resposne -> response

hishel/_async/_pool.py

@@ -56,7 +56,7 @@ async def handle_async_request(self, request: Request) -> Response:
             request.headers.extend([(b"cache-control", b"no-cache"), (b"cache-control", b"max-age=0")])
 
         key = generate_key(request)
-        stored_data = await self._storage.retreive(key)
+        stored_data = await self._storage.retrieve(key)
 
         request_cache_control = parse_cache_control(extract_header_values_decoded(request.headers, b"Cache-Control"))
 
@@ -66,22 +66,22 @@ async def handle_async_request(self, request: Request) -> Response:
         if stored_data:
             # Try using the stored response if it was discovered.
 
-            stored_resposne, stored_request, metadata = stored_data
+            stored_response, stored_request, metadata = stored_data
 
             res = self._controller.construct_response_from_cache(
                 request=request,
-                response=stored_resposne,
+                response=stored_response,
                 original_request=stored_request,
             )
 
             if isinstance(res, Response):
                 # Simply use the response if the controller determines it is ready for use.
                 metadata["number_of_uses"] += 1
-                stored_resposne.read()
+                stored_response.read()
                 await self._storage.store(
                     key=key,
                     request=request,
-                    response=stored_resposne,
+                    response=stored_response,
                     metadata=metadata,
                 )
                 res.extensions["from_cache"] = True  # type: ignore[index]
@@ -97,14 +97,14 @@ async def handle_async_request(self, request: Request) -> Response:
                 try:
                     response = await self._pool.handle_async_request(res)
                 except ConnectError:
-                    if self._controller._allow_stale and allowed_stale(response=stored_resposne):
-                        stored_resposne.extensions["from_cache"] = True  # type: ignore[index]
-                        stored_resposne.extensions["cache_metadata"] = metadata  # type: ignore[index]
-                        return stored_resposne
+                    if self._controller._allow_stale and allowed_stale(response=stored_response):
+                        stored_response.extensions["from_cache"] = True  # type: ignore[index]
+                        stored_response.extensions["cache_metadata"] = metadata  # type: ignore[index]
+                        return stored_response
                     raise  # pragma: no cover
                 # Merge headers with the stale response.
                 full_response = self._controller.handle_validation_response(
-                    old_response=stored_resposne, new_response=response
+                    old_response=stored_response, new_response=response
                 )
 
                 await full_response.aread()

hishel/_async/_storages.py

@@ -39,7 +39,7 @@ def __init__(
     async def store(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         raise NotImplementedError()
 
-    async def retreive(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
+    async def retrieve(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
         raise NotImplementedError()
 
     async def aclose(self) -> None:
@@ -96,7 +96,7 @@ async def store(self, key: str, response: Response, request: Request, metadata:
             )
         await self._remove_expired_caches()
 
-    async def retreive(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
+    async def retrieve(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
         """
         Retreives the response from the cache using his key.
 
@@ -199,7 +199,7 @@ async def store(self, key: str, response: Response, request: Request, metadata:
             await self._connection.commit()
         await self._remove_expired_caches()
 
-    async def retreive(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
+    async def retrieve(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
         """
         Retreives the response from the cache using his key.
 
@@ -292,7 +292,7 @@ async def store(self, key: str, response: Response, request: Request, metadata:
             key, self._serializer.dumps(response=response, request=request, metadata=metadata), px=px
         )
 
-    async def retreive(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
+    async def retrieve(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
         """
         Retreives the response from the cache using his key.
 

hishel/_async/_transports.py

@@ -95,7 +95,7 @@ async def handle_async_request(self, request: Request) -> Response:
             extensions=request.extensions,
         )
         key = generate_key(httpcore_request)
-        stored_data = await self._storage.retreive(key)
+        stored_data = await self._storage.retrieve(key)
 
         request_cache_control = parse_cache_control(
             extract_header_values_decoded(request.headers.raw, b"Cache-Control")
@@ -107,30 +107,30 @@ async def handle_async_request(self, request: Request) -> Response:
         if stored_data:
             # Try using the stored response if it was discovered.
 
-            stored_resposne, stored_request, metadata = stored_data
+            stored_response, stored_request, metadata = stored_data
 
             res = self._controller.construct_response_from_cache(
                 request=httpcore_request,
-                response=stored_resposne,
+                response=stored_response,
                 original_request=stored_request,
             )
 
             if isinstance(res, httpcore.Response):
                 # Simply use the response if the controller determines it is ready for use.
                 metadata["number_of_uses"] += 1
-                stored_resposne.read()
+                stored_response.read()
                 await self._storage.store(
                     key=key,
                     request=stored_request,
-                    response=stored_resposne,
+                    response=stored_response,
                     metadata=metadata,
                 )
                 res.extensions["from_cache"] = True  # type: ignore[index]
                 res.extensions["cache_metadata"] = metadata  # type: ignore[index]
                 return Response(
                     status_code=res.status,
                     headers=res.headers,
-                    stream=AsyncCacheStream(fake_stream(stored_resposne.content)),
+                    stream=AsyncCacheStream(fake_stream(stored_response.content)),
                     extensions=res.extensions,
                 )
 
@@ -149,15 +149,15 @@ async def handle_async_request(self, request: Request) -> Response:
                 try:
                     response = await self._transport.handle_async_request(revalidation_request)
                 except ConnectError:
-                    if self._controller._allow_stale and allowed_stale(response=stored_resposne):
-                        await stored_resposne.aread()
-                        stored_resposne.extensions["from_cache"] = True  # type: ignore[index]
-                        stored_resposne.extensions["cache_metadata"] = metadata  # type: ignore[index]
+                    if self._controller._allow_stale and allowed_stale(response=stored_response):
+                        await stored_response.aread()
+                        stored_response.extensions["from_cache"] = True  # type: ignore[index]
+                        stored_response.extensions["cache_metadata"] = metadata  # type: ignore[index]
                         return Response(
-                            status_code=stored_resposne.status,
-                            headers=stored_resposne.headers,
-                            stream=AsyncCacheStream(fake_stream(stored_resposne.content)),
-                            extensions=stored_resposne.extensions,
+                            status_code=stored_response.status,
+                            headers=stored_response.headers,
+                            stream=AsyncCacheStream(fake_stream(stored_response.content)),
+                            extensions=stored_response.extensions,
                         )
                     raise  # pragma: no cover
                 assert isinstance(response.stream, tp.AsyncIterable)
@@ -170,7 +170,7 @@ async def handle_async_request(self, request: Request) -> Response:
 
                 # Merge headers with the stale response.
                 full_response = self._controller.handle_validation_response(
-                    old_response=stored_resposne, new_response=httpcore_response
+                    old_response=stored_response, new_response=httpcore_response
                 )
 
                 await full_response.aread()

hishel/_sync/_pool.py

@@ -56,7 +56,7 @@ def handle_request(self, request: Request) -> Response:
             request.headers.extend([(b"cache-control", b"no-cache"), (b"cache-control", b"max-age=0")])
 
         key = generate_key(request)
-        stored_data = self._storage.retreive(key)
+        stored_data = self._storage.retrieve(key)
 
         request_cache_control = parse_cache_control(extract_header_values_decoded(request.headers, b"Cache-Control"))
 
@@ -66,22 +66,22 @@ def handle_request(self, request: Request) -> Response:
         if stored_data:
             # Try using the stored response if it was discovered.
 
-            stored_resposne, stored_request, metadata = stored_data
+            stored_response, stored_request, metadata = stored_data
 
             res = self._controller.construct_response_from_cache(
                 request=request,
-                response=stored_resposne,
+                response=stored_response,
                 original_request=stored_request,
             )
 
             if isinstance(res, Response):
                 # Simply use the response if the controller determines it is ready for use.
                 metadata["number_of_uses"] += 1
-                stored_resposne.read()
+                stored_response.read()
                 self._storage.store(
                     key=key,
                     request=request,
-                    response=stored_resposne,
+                    response=stored_response,
                     metadata=metadata,
                 )
                 res.extensions["from_cache"] = True  # type: ignore[index]
@@ -97,14 +97,14 @@ def handle_request(self, request: Request) -> Response:
                 try:
                     response = self._pool.handle_request(res)
                 except ConnectError:
-                    if self._controller._allow_stale and allowed_stale(response=stored_resposne):
-                        stored_resposne.extensions["from_cache"] = True  # type: ignore[index]
-                        stored_resposne.extensions["cache_metadata"] = metadata  # type: ignore[index]
-                        return stored_resposne
+                    if self._controller._allow_stale and allowed_stale(response=stored_response):
+                        stored_response.extensions["from_cache"] = True  # type: ignore[index]
+                        stored_response.extensions["cache_metadata"] = metadata  # type: ignore[index]
+                        return stored_response
                     raise  # pragma: no cover
                 # Merge headers with the stale response.
                 full_response = self._controller.handle_validation_response(
-                    old_response=stored_resposne, new_response=response
+                    old_response=stored_response, new_response=response
                 )
 
                 full_response.read()

hishel/_sync/_storages.py

@@ -39,7 +39,7 @@ def __init__(
     def store(self, key: str, response: Response, request: Request, metadata: Metadata) -> None:
         raise NotImplementedError()
 
-    def retreive(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
+    def retrieve(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
         raise NotImplementedError()
 
     def close(self) -> None:
@@ -96,7 +96,7 @@ def store(self, key: str, response: Response, request: Request, metadata: Metada
             )
         self._remove_expired_caches()
 
-    def retreive(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
+    def retrieve(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
         """
         Retreives the response from the cache using his key.
 
@@ -199,7 +199,7 @@ def store(self, key: str, response: Response, request: Request, metadata: Metada
             self._connection.commit()
         self._remove_expired_caches()
 
-    def retreive(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
+    def retrieve(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
         """
         Retreives the response from the cache using his key.
 
@@ -292,7 +292,7 @@ def store(self, key: str, response: Response, request: Request, metadata: Metada
             key, self._serializer.dumps(response=response, request=request, metadata=metadata), px=px
         )
 
-    def retreive(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
+    def retrieve(self, key: str) -> tp.Optional[tp.Tuple[Response, Request, Metadata]]:
         """
         Retreives the response from the cache using his key.
 

hishel/_sync/_transports.py

@@ -95,7 +95,7 @@ def handle_request(self, request: Request) -> Response:
             extensions=request.extensions,
         )
         key = generate_key(httpcore_request)
-        stored_data = self._storage.retreive(key)
+        stored_data = self._storage.retrieve(key)
 
         request_cache_control = parse_cache_control(
             extract_header_values_decoded(request.headers.raw, b"Cache-Control")
@@ -107,30 +107,30 @@ def handle_request(self, request: Request) -> Response:
         if stored_data:
             # Try using the stored response if it was discovered.
 
-            stored_resposne, stored_request, metadata = stored_data
+            stored_response, stored_request, metadata = stored_data
 
             res = self._controller.construct_response_from_cache(
                 request=httpcore_request,
-                response=stored_resposne,
+                response=stored_response,
                 original_request=stored_request,
             )
 
             if isinstance(res, httpcore.Response):
                 # Simply use the response if the controller determines it is ready for use.
                 metadata["number_of_uses"] += 1
-                stored_resposne.read()
+                stored_response.read()
                 self._storage.store(
                     key=key,
                     request=stored_request,
-                    response=stored_resposne,
+                    response=stored_response,
                     metadata=metadata,
                 )
                 res.extensions["from_cache"] = True  # type: ignore[index]
                 res.extensions["cache_metadata"] = metadata  # type: ignore[index]
                 return Response(
                     status_code=res.status,
                     headers=res.headers,
-                    stream=CacheStream(fake_stream(stored_resposne.content)),
+                    stream=CacheStream(fake_stream(stored_response.content)),
                     extensions=res.extensions,
                 )
 
@@ -149,15 +149,15 @@ def handle_request(self, request: Request) -> Response:
                 try:
                     response = self._transport.handle_request(revalidation_request)
                 except ConnectError:
-                    if self._controller._allow_stale and allowed_stale(response=stored_resposne):
-                        stored_resposne.read()
-                        stored_resposne.extensions["from_cache"] = True  # type: ignore[index]
-                        stored_resposne.extensions["cache_metadata"] = metadata  # type: ignore[index]
+                    if self._controller._allow_stale and allowed_stale(response=stored_response):
+                        stored_response.read()
+                        stored_response.extensions["from_cache"] = True  # type: ignore[index]
+                        stored_response.extensions["cache_metadata"] = metadata  # type: ignore[index]
                         return Response(
-                            status_code=stored_resposne.status,
-                            headers=stored_resposne.headers,
-                            stream=CacheStream(fake_stream(stored_resposne.content)),
-                            extensions=stored_resposne.extensions,
+                            status_code=stored_response.status,
+                            headers=stored_response.headers,
+                            stream=CacheStream(fake_stream(stored_response.content)),
+                            extensions=stored_response.extensions,
                         )
                     raise  # pragma: no cover
                 assert isinstance(response.stream, tp.Iterable)
@@ -170,7 +170,7 @@ def handle_request(self, request: Request) -> Response:
 
                 # Merge headers with the stale response.
                 full_response = self._controller.handle_validation_response(
-                    old_response=stored_resposne, new_response=httpcore_response
+                    old_response=stored_response, new_response=httpcore_response
                 )
 
                 full_response.read()