Migrate cookie handling to shared library and prepare for 2.0.0 release

- Remove upcoming breaking changes section from README
- Refactor cookie implementation to use standard http.cookiejar
- Update cffi layer with async cookie management methods
- Replace requests dependency with nocasedict for header handling
- Implement new session class with native cookie delegation
- Deprecate direct manipulation of session.cookies
- Add comprehensive cookie test suite
- Bump version to 2.0.0

Author: diprog

README.md

@@ -43,32 +43,6 @@ The fork was created due to the lack of updates in the original repository, whil
 library [tls-client](https://github.com/bogdanfinn/tls-client) continues to evolve actively. This project aims to keep
 up with the latest developments in the GoLang library and provide a modern, asynchronous interface for Python users.
 
-## Upcoming Breaking Changes 🚧
-
-The library plans several breaking changes in future major releases to improve maintainability and reduce technical
-debt:
-
-### Key Changes Planned:
-
-1. **Syntax Divergence from `requests`**
-    - The API will evolve to be less similar to `requests` to avoid dependency on its internal implementations.
-    - This may affect session/request patterns and method signatures.
-
-2. **Direct Import of `CaseInsensitiveDict`**
-    - The current custom `CaseInsensitiveDict` (copied from `requests.structures`) will be replaced by direct imports
-      from `requests` or standard library alternatives.
-    - Users relying on `async_tls_client.structures.CaseInsensitiveDict` should prepare for import path changes.
-
-3. **Standard `http.cookiejar.CookieJar` Implementation**
-    - The custom `RequestsCookieJar` (borrowed from `requests`) will be replaced with `http.cookiejar.CookieJar` for
-      cookie management.
-    - This may impact cookie handling APIs and persistence behavior.
-
-4. **Response Class Refactoring**
-    - The `Response` class may undergo structural changes to simplify implementation and align with modern Python
-      practices.
-    - Potential impacts include changes to attribute access, content handling, or JSON parsing methods.
-
 ### Recommendations:
 
 - Monitor changelogs for deprecation warnings in future minor releases

async_tls_client/__init__.py

@@ -12,4 +12,4 @@
 # tls-client: https://github.com/bogdanfinn/tls-client
 # requests: https://github.com/psf/requests
 
-from async_tls_client.session.async_session import AsyncSession
+from async_tls_client.session.session import AsyncSession

async_tls_client/cffi.py

@@ -1,8 +1,12 @@
+import asyncio
 import ctypes
+import json
 import os
 from platform import machine
 from sys import platform
 
+from .exceptions import TLSClientException
+
 if platform == 'darwin':
     file_ext = '-arm64.dylib' if machine() == "arm64" else '-x86.dylib'
 elif platform in ('win32', 'cygwin'):
@@ -19,15 +23,81 @@
 binary_filepath = os.path.join(root_dir, 'dependencies', f'tls-client{file_ext}')
 library = ctypes.cdll.LoadLibrary(binary_filepath)
 
-# extract the exposed request function from the shared package
-request = library.request
-request.argtypes = [ctypes.c_char_p]
-request.restype = ctypes.c_char_p
+# Extract methods from the shared library
+_freeMemory = library.freeMemory
+_freeMemory.argtypes = [ctypes.c_char_p]
+_freeMemory.restype = ctypes.c_char_p
+
+_request = library.request
+_request.argtypes = [ctypes.c_char_p]
+_request.restype = ctypes.c_char_p
+
+_destroySession = library.destroySession
+_destroySession.argtypes = [ctypes.c_char_p]
+_destroySession.restype = ctypes.c_char_p
+
+_getCookiesFromSession = library.getCookiesFromSession
+_getCookiesFromSession.argtypes = [ctypes.c_char_p]
+_getCookiesFromSession.restype = ctypes.c_char_p
+
+_addCookiesToSession = library.addCookiesToSession
+_addCookiesToSession.argtypes = [ctypes.c_char_p]
+_addCookiesToSession.restype = ctypes.c_char_p
+
+
+async def free_memory(response_id: str):
+    await asyncio.to_thread(_freeMemory, response_id.encode('utf-8'))
+
+
+async def request(payload: dict) -> dict:
+    response = await asyncio.to_thread(
+        _request,
+        json.dumps(payload).encode('utf-8')
+    )
+    response_bytes = ctypes.string_at(response)
+    response_string = response_bytes.decode('utf-8')
+    response_object = json.loads(response_string)
+
+    await free_memory(response_object["id"])
+
+    if response_object["status"] == 0:
+        raise TLSClientException(response_object["body"])
+
+    return response_object
+
+
+async def destroy_session(session_id: str) -> dict:
+    destroy_session_response = await asyncio.to_thread(
+        _destroySession,
+        json.dumps({"sessionId": session_id}).encode('utf-8')
+    )
+    destroy_session_response_bytes = ctypes.string_at(destroy_session_response)
+    destroy_session_response_string = destroy_session_response_bytes.decode('utf-8')
+    destroy_session_response_object = json.loads(destroy_session_response_string)
+    await free_memory(destroy_session_response_object['id'])
+    return destroy_session_response_object
+
+
+async def get_cookies_from_session(session_id: str, url: str) -> dict:
+    cookies_response = await asyncio.to_thread(
+        _getCookiesFromSession,
+        json.dumps({"sessionId": session_id, "url": url}).encode('utf-8')
+    )
+    # we dereference the pointer to a byte array
+    cookies_response_bytes = ctypes.string_at(cookies_response)
+    # convert our byte array to a string (tls client returns json)
+    cookies_response_string = cookies_response_bytes.decode('utf-8')
+    # convert response string to json
+    cookies_response_object = json.loads(cookies_response_string)
+    return cookies_response_object
 
-freeMemory = library.freeMemory
-freeMemory.argtypes = [ctypes.c_char_p]
-freeMemory.restype = ctypes.c_char_p
 
-destroySession = library.destroySession
-destroySession.argtypes = [ctypes.c_char_p]
-destroySession.restype = ctypes.c_char_p
+async def add_cookies_to_session(session_id, cookies: list[dict], url: str) -> dict:
+    add_cookies_to_session_response = await asyncio.to_thread(
+        _addCookiesToSession,
+        json.dumps({"cookies": cookies, "sessionId": session_id, "url": url}).encode('utf-8')
+    )
+    add_cookies_bytes = ctypes.string_at(add_cookies_to_session_response)
+    add_cookies_string = add_cookies_bytes.decode('utf-8')
+    add_cookies_object = json.loads(add_cookies_string)
+    return add_cookies_object