elapi 2.4.1__tar.gz → 2.4.3__tar.gz

{elapi-2.4.1 → elapi-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elapi
-Version: 2.4.1
+Version: 2.4.3
 Summary: elAPI is a powerful, extensible API client for eLabFTW.
 Keywords: elabftw,api
 Author: Alexander Haller, Mahadi Xion
@@ -29,6 +29,7 @@ Requires-Dist: pyyaml==6.0.2
 Requires-Dist: mistune==3.1.3
 Requires-Dist: click>=8.1.8,<8.2
 Requires-Dist: httpx-limiter>=0.3.0,<0.4.0
+Requires-Dist: httpx-aiohttp>=0.1.8,<0.2
 Requires-Dist: jinja2>=3.1.6,<3.2 ; extra == 'mail'
 Requires-Dist: nameparser>=1.1.3 ; extra == 'mail'
 Requires-Dist: yagmail>=0.15.293,<0.16 ; extra == 'mail'
@@ -133,7 +134,9 @@ $ elapi init
 <video src='https://github.com/user-attachments/assets/8d5f69ed-b644-4d75-b816-d06d4e937105'> </video>
 <p align="center">elapi init demo</p>
 
-That's all! Run [`elapi show-config`](#show-config) to view your configuration details.
+That's all! Run [`elapi whoami`](#elapi-whoami) to see a short summary of your eLab user. Run [
+`elapi show-config`](#show-config) to view
+your configuration details.
 
 ## Compatibility
 
@@ -176,7 +179,8 @@ unsafe_api_token_warning: true
 enable_http2: false
 verify_ssl: true
 timeout: 90
-async_rate_limit: 100
+async_rate_limit: 20
+async_capacity: 500
 development_mode: false
 ```
 
@@ -192,9 +196,13 @@ development_mode: false
 - `timeout` can be modified to your needs. E.g., a poor internet connection might benefit from a higher timeout number.
   The default timeout is `90` seconds.
 - `async_rate_limit` controls the maximum number of requests per second (i.e., throughput) you want to make to the
-  server. Default `async_rate_limit` is `null` which is to say no limit. An eLab server might be configured to limit
+  server. The default `async_rate_limit` is `null` which means no limit. An eLab server might be configured to limit
   a high number of requests to prevent spam, `async_rate_limit` can then be set to the maximum number of requests
   allowed by the server.
+- `async_capacity` controls the maximum number of in-flight async requests. The default `async_capacity` is `null` which
+  means no limit on capacity. Both `async_rate_limit` and `async_capacity` can be used to better limit the traffic load
+  put on the server. See this [SA answer](https://stackoverflow.com/a/52100884/7696241) about how they differ from each
+  other.
 - `development_mode` can be set to `True` to show debug logs, Python traceback on the CLI instead of a clean exit, etc.
   This mode should not be turned on for production-ready scripts.
 
@@ -218,6 +226,33 @@ as detected by `elapi show-config`. All plugins will also automatically listen t
 be useful to set certain configurations temporarily. E.g., `elapi --OC '{"timeout": 300"}' get info` will override
 the `timeout` from the configuration files.
 
+## elAPI `whoami`
+
+Oftentimes, you work with multiple API tokens/keys for multiple teams on multiple eLab servers. elAPI enables robust
+workflow management with built-in [advanced configuration](#advanced-configuration) orchestration. During development
+though,
+juggling between multiple API keys can still lead to confusion as to which API key is being actually used. elAPI version
+`2.4.1` adds the `whomai` command that shows the essential information about the requesting eLab user.
+
+```shell
+$ elapi whoami
+```
+
+![elapi whoami output](https://heibox.uni-heidelberg.de/f/e3096d5659db45e58a94/?dl=1)
+
+So, if your API task requires write permission, but only `Read-only` is shown next to the API key, you know you're using
+the wrong API key. But having to run `elapi whoami` every single time for this would be cumbersome. So, we added the
+`whoami` information to the debug messages. To enable debug messages, set `development_mode` to `True` in
+the [configuration file](#configuration). Once set, before any elAPI command and plugin is run, elAPI will show the
+`whoami` information in the debug messages.
+
+```shell
+DEBUG    Based on the detected configuration, the requests will be made to the server                                         get_whoami.py:114
+         https://elabftw-dev-002.uni-heidelberg.de (eLabFTW version: 5.2.8), with API token '84-fc******2a384' (Read/Write),
+         by user 'John Doe' (ID: 2607), from team 'North Kathy' (ID: 19), in user group 'User', not as a sysadmin. Scopes:
+         experiments = 'Team', items = 'Team', experiments_templates = 'Team', teamgroups = 'Everything'
+```
+
 ## Examples and usage
 
 Check out the [examples directory](https://github.com/uhd-urz/elAPI/tree/main/examples) for some comprehensive code
@@ -318,7 +353,8 @@ $ elapi experiments upload-attachment --id <experiment ID> --path <path to attac
 
 Sometimes when a script has finished, you and your team would want to receive an email about its success/failure. elAPI
 offers a no-code solution for this: the `mail` plugin. The `mail` plugin is not enabled by default. To enable it,
-install elAPI with the optional dependency `mail`: `pip install elapi[mail]` or `uv add elapi[mail]`. [__See the wiki__](https://github.com/uhd-urz/elAPI/wiki/mail-plugin) to read more about how to configure the `mail` plugin with your
+install elAPI with the optional dependency `mail`: `pip install elapi[mail]` or `uv add elapi[mail]`. [__See the wiki
+__](https://github.com/uhd-urz/elAPI/wiki/mail-plugin) to read more about how to configure the `mail` plugin with your
 mail server configuration and trigger conditions. In a
 nutshell, the `mail` plugin will scan the logs when a script/plugin is done to look for pre-configured trigger
 conditions, and if found, it will send an email. The trigger conditions can be atomic and scope-based, i.e., an email

{elapi-2.4.1 → elapi-2.4.3}/README.md

@@ -85,7 +85,9 @@ $ elapi init
 <video src='https://github.com/user-attachments/assets/8d5f69ed-b644-4d75-b816-d06d4e937105'> </video>
 <p align="center">elapi init demo</p>
 
-That's all! Run [`elapi show-config`](#show-config) to view your configuration details.
+That's all! Run [`elapi whoami`](#elapi-whoami) to see a short summary of your eLab user. Run [
+`elapi show-config`](#show-config) to view
+your configuration details.
 
 ## Compatibility
 
@@ -128,7 +130,8 @@ unsafe_api_token_warning: true
 enable_http2: false
 verify_ssl: true
 timeout: 90
-async_rate_limit: 100
+async_rate_limit: 20
+async_capacity: 500
 development_mode: false
 ```
 
@@ -144,9 +147,13 @@ development_mode: false
 - `timeout` can be modified to your needs. E.g., a poor internet connection might benefit from a higher timeout number.
   The default timeout is `90` seconds.
 - `async_rate_limit` controls the maximum number of requests per second (i.e., throughput) you want to make to the
-  server. Default `async_rate_limit` is `null` which is to say no limit. An eLab server might be configured to limit
+  server. The default `async_rate_limit` is `null` which means no limit. An eLab server might be configured to limit
   a high number of requests to prevent spam, `async_rate_limit` can then be set to the maximum number of requests
   allowed by the server.
+- `async_capacity` controls the maximum number of in-flight async requests. The default `async_capacity` is `null` which
+  means no limit on capacity. Both `async_rate_limit` and `async_capacity` can be used to better limit the traffic load
+  put on the server. See this [SA answer](https://stackoverflow.com/a/52100884/7696241) about how they differ from each
+  other.
 - `development_mode` can be set to `True` to show debug logs, Python traceback on the CLI instead of a clean exit, etc.
   This mode should not be turned on for production-ready scripts.
 
@@ -170,6 +177,33 @@ as detected by `elapi show-config`. All plugins will also automatically listen t
 be useful to set certain configurations temporarily. E.g., `elapi --OC '{"timeout": 300"}' get info` will override
 the `timeout` from the configuration files.
 
+## elAPI `whoami`
+
+Oftentimes, you work with multiple API tokens/keys for multiple teams on multiple eLab servers. elAPI enables robust
+workflow management with built-in [advanced configuration](#advanced-configuration) orchestration. During development
+though,
+juggling between multiple API keys can still lead to confusion as to which API key is being actually used. elAPI version
+`2.4.1` adds the `whomai` command that shows the essential information about the requesting eLab user.
+
+```shell
+$ elapi whoami
+```
+
+![elapi whoami output](https://heibox.uni-heidelberg.de/f/e3096d5659db45e58a94/?dl=1)
+
+So, if your API task requires write permission, but only `Read-only` is shown next to the API key, you know you're using
+the wrong API key. But having to run `elapi whoami` every single time for this would be cumbersome. So, we added the
+`whoami` information to the debug messages. To enable debug messages, set `development_mode` to `True` in
+the [configuration file](#configuration). Once set, before any elAPI command and plugin is run, elAPI will show the
+`whoami` information in the debug messages.
+
+```shell
+DEBUG    Based on the detected configuration, the requests will be made to the server                                         get_whoami.py:114
+         https://elabftw-dev-002.uni-heidelberg.de (eLabFTW version: 5.2.8), with API token '84-fc******2a384' (Read/Write),
+         by user 'John Doe' (ID: 2607), from team 'North Kathy' (ID: 19), in user group 'User', not as a sysadmin. Scopes:
+         experiments = 'Team', items = 'Team', experiments_templates = 'Team', teamgroups = 'Everything'
+```
+
 ## Examples and usage
 
 Check out the [examples directory](https://github.com/uhd-urz/elAPI/tree/main/examples) for some comprehensive code
@@ -270,7 +304,8 @@ $ elapi experiments upload-attachment --id <experiment ID> --path <path to attac
 
 Sometimes when a script has finished, you and your team would want to receive an email about its success/failure. elAPI
 offers a no-code solution for this: the `mail` plugin. The `mail` plugin is not enabled by default. To enable it,
-install elAPI with the optional dependency `mail`: `pip install elapi[mail]` or `uv add elapi[mail]`. [__See the wiki__](https://github.com/uhd-urz/elAPI/wiki/mail-plugin) to read more about how to configure the `mail` plugin with your
+install elAPI with the optional dependency `mail`: `pip install elapi[mail]` or `uv add elapi[mail]`. [__See the wiki
+__](https://github.com/uhd-urz/elAPI/wiki/mail-plugin) to read more about how to configure the `mail` plugin with your
 mail server configuration and trigger conditions. In a
 nutshell, the `mail` plugin will scan the logs when a script/plugin is done to look for pre-configured trigger
 conditions, and if found, it will send an email. The trigger conditions can be atomic and scope-based, i.e., an email

{elapi-2.4.1 → elapi-2.4.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "elapi"
-version = "2.4.1"
+version = "2.4.3"
 description = "elAPI is a powerful, extensible API client for eLabFTW."
 authors = [{ name = "Alexander Haller, Mahadi Xion", email = "elabftw@uni-heidelberg.de" }]
 requires-python = ">=3.11.0,<4"
@@ -34,6 +34,7 @@ dependencies = [
     "mistune==3.1.3",
     "click>=8.1.8,<8.2",
     "httpx-limiter>=0.3.0,<0.4.0",
+    "httpx-aiohttp>=0.1.8,<0.2",
 ]
 license-files = [
     "LICENSE",

elapi-2.4.3/src/elapi/VERSION

@@ -0,0 +1 @@
+2.4.3

{elapi-2.4.1 → elapi-2.4.3}/src/elapi/_names.py

@@ -27,7 +27,6 @@ ELAB_HOST_URL_API_SUFFIX: str = f"/api/v{ELAB_API_EXPECTED_VERSION}"
 ENV_XDG_DATA_HOME: str = "XDG_DATA_HOME"
 ENV_XDG_DOWNLOAD_DIR: str = "XDG_DOWNLOAD_DIR"
 ENV_XDG_CONFIG_HOME: str = "XDG_CONFIG_HOME"
-TMP_DIR: Path = Path(f"/var/tmp/{APP_NAME}")
 
 # Fallback definitions
 FALLBACK_DIR: Path = user_home / ".local/share" / APP_NAME
@@ -48,6 +47,7 @@ KEY_API_TOKEN: str = "API_TOKEN"
 KEY_EXPORT_DIR: str = "EXPORT_DIR"
 KEY_UNSAFE_TOKEN_WARNING: str = "UNSAFE_API_TOKEN_WARNING"
 KEY_ENABLE_HTTP2: str = "ENABLE_HTTP2"
+KEY_ASYNC_CAPACITY: str = "ASYNC_CAPACITY"
 KEY_VERIFY_SSL: str = "VERIFY_SSL"
 KEY_TIMEOUT: str = "TIMEOUT"
 KEY_ASYNC_RATE_LIMIT: str = "ASYNC_RATE_LIMIT"

elapi-2.4.3/src/elapi/api/__init__.py

@@ -0,0 +1,36 @@
+__all__ = [
+    "SessionDefaults",
+    "SimpleClient",
+    "GlobalSharedSession",
+    "APIRequest",
+    "ElabFTWURLError",
+    "ElabFTWURL",
+    "GETRequest",
+    "AsyncGETRequest",
+    "POSTRequest",
+    "AsyncPOSTRequest",
+    "PATCHRequest",
+    "AsyncPATCHRequest",
+    "DELETERequest",
+    "AsyncDELETERequest",
+    "FixedEndpoint",
+    "FixedAsyncEndpoint",
+]
+
+from .api import (
+    APIRequest,
+    AsyncDELETERequest,
+    AsyncGETRequest,
+    AsyncPATCHRequest,
+    AsyncPOSTRequest,
+    DELETERequest,
+    ElabFTWURL,
+    ElabFTWURLError,
+    GETRequest,
+    GlobalSharedSession,
+    PATCHRequest,
+    POSTRequest,
+    SessionDefaults,
+    SimpleClient,
+)
+from .endpoint import FixedAsyncEndpoint, FixedEndpoint

{elapi-2.4.1 → elapi-2.4.3}/src/elapi/api/api.py

@@ -8,29 +8,50 @@ from typing import Literal, Optional, Tuple, Union
 
 # noinspection PyProtectedMember
 import httpx._client as httpx_private_client_module
-from httpx import AsyncBaseTransport, AsyncClient, Client, Limits, Response
+from httpx import (
+    AsyncBaseTransport,
+    AsyncClient,
+    BaseTransport,
+    Client,
+    Limits,
+    Response,
+)
 
 # noinspection PyProtectedMember
 from httpx._client import BaseClient
 
 # noinspection PyProtectedMember
 from httpx._types import AuthTypes
+from httpx_aiohttp import AiohttpTransport
 from httpx_auth import HeaderApiKey
 from httpx_limiter import AsyncRateLimitedTransport, Rate
 
-from .. import APP_BRAND_NAME, APP_NAME
+from .. import APP_BRAND_NAME
 from ..configuration import (
+    KEY_API_TOKEN,
+    KEY_ASYNC_RATE_LIMIT,
+    KEY_ENABLE_HTTP2,
+    KEY_HOST,
+    KEY_TIMEOUT,
+    KEY_VERIFY_SSL,
     TOKEN_BEARER,
+    MinimalActiveConfiguration,
     get_active_api_token,
+    get_active_async_capacity,
     get_active_async_rate_limit,
     get_active_enable_http2,
     get_active_host,
     get_active_timeout,
     get_active_verify_ssl,
+    preventive_missing_warning,
 )
+from ..configuration.config import APIToken
 from ..loggers import Logger
 from ..styles import Missing
-from ..utils import get_app_version, update_kwargs_with_defaults
+from ..utils import (
+    get_app_version,
+    update_kwargs_with_defaults,
+)
 
 USER_AGENT: str = (
     f"{APP_BRAND_NAME}/{get_app_version()} {httpx_private_client_module.USER_AGENT}"
@@ -55,90 +76,126 @@ class SessionDefaults:
 session_defaults = SessionDefaults()
 
 
-class _CustomHeaderApiKey(HeaderApiKey): ...
+class _CustomHeaderApiKey(HeaderApiKey):
+    def __init__(self):
+        self.api_key = str(Missing())
+        self.header_name = TOKEN_BEARER
+        super().__init__(self.api_key, self.header_name)
 
 
 class SimpleClient(BaseClient):
-    def __new__(
-        cls,
-        *,
-        is_async_client: bool,
-        auth: Optional[AuthTypes] = _CustomHeaderApiKey(
-            api_key=str(Missing()), header_name=TOKEN_BEARER
-        ),
-        transport: Optional[AsyncBaseTransport] = None,
-        **kwargs,
-    ) -> Union[Client, AsyncClient]:
-        from .._names import CONFIG_FILE_NAME
-        from ..configuration import (
-            KEY_API_TOKEN,
-            KEY_ASYNC_RATE_LIMIT,
-            KEY_ENABLE_HTTP2,
-            KEY_HOST,
-            KEY_TIMEOUT,
-            KEY_VERIFY_SSL,
-            preventive_missing_warning,
-        )
-        from ..utils import check_reserved_keyword
-
-        host: str = get_active_host()
-        api_token: str = get_active_api_token().token
-        enable_http2: bool = get_active_enable_http2()
-        verify_ssl: bool = get_active_verify_ssl()
-        timeout: float = get_active_timeout()
-        active_async_rate_limit: Optional[int] = get_active_async_rate_limit()
-
-        if isinstance(auth, _CustomHeaderApiKey):
-            auth.api_key = api_token
-        for config_field in (
+    def __new__(cls, *, is_async_client: bool, **kwargs) -> Union[Client, AsyncClient]:
+        host: str = kwargs.pop("host", get_active_host())
+        api_token: str | APIToken = kwargs.pop("api_token", get_active_api_token())
+        if not isinstance(api_token, APIToken):
+            api_token = APIToken(api_token)
+        auth: Optional[AuthTypes] = kwargs.pop("auth", _CustomHeaderApiKey())
+        if auth is None:
+            auth: AuthTypes = _CustomHeaderApiKey()
+            auth.api_key = api_token.token
+            logger.debug(
+                f"Argument 'auth' passed to {SimpleClient.__name__} is {None}. "
+                f"It has been be set to {HeaderApiKey} with "
+                f"API key/token '{api_token}'."
+            )
+        elif isinstance(auth, HeaderApiKey):
+            auth.api_key = api_token.token
+        else:
+            logger.debug(
+                f"'auth' has been set to {auth!r} for {SimpleClient.__name__} "
+                f"by an external method."
+                f"API token from configuration file '{api_token}' will be ignored."
+            )
+        enable_http2: bool = kwargs.pop("http2", get_active_enable_http2())
+        verify_ssl: bool = kwargs.pop("verify", get_active_verify_ssl())
+        timeout: float = kwargs.pop("timeout", get_active_timeout())
+        async_rate_limit: Optional[int] = kwargs.pop(
+            "async_rate_limit", get_active_async_rate_limit()
+        )
+        async_capacity: Optional[int] = kwargs.pop(
+            "async_capacity", get_active_async_capacity()
+        )
+        async_transport: Optional[AsyncBaseTransport] = kwargs.pop(
+            "async_transport", None
+        )
+        sync_transport: Optional[BaseTransport] = kwargs.pop("sync_transport", None)
+
+        for key_name, value in (
             (KEY_HOST, host),
             (KEY_API_TOKEN, api_token),
             (KEY_ENABLE_HTTP2, enable_http2),
             (KEY_VERIFY_SSL, verify_ssl),
             (KEY_TIMEOUT, timeout),
         ):
-            preventive_missing_warning(config_field)
-        try:
-            if is_async_client is True:
-                if transport is None and active_async_rate_limit is not None:
-                    transport = AsyncRateLimitedTransport.create(
-                        rate=Rate.create(magnitude=active_async_rate_limit, duration=1),
-                        # see more: https://midnighter.github.io/httpx-limiter/latest/tutorial/#single-rate-limit
-                        # In our case, magnitude=1, duration=1/active_async_rate_limit yields worse results.
-                        http2=enable_http2,  # type: ignore
-                        # See: https://github.com/Midnighter/httpx-limiter/issues/7#issuecomment-3197487921
-                        # http2 needs to be passed here if AsyncRateLimitedTransport is used
-                        verify=verify_ssl,  # type: ignore
-                    )
-                elif transport is not None and active_async_rate_limit is not None:
+            preventive_missing_warning((key_name, value))
+            if MinimalActiveConfiguration().get_value(key_name) != value:
+                logger.debug(
+                    f"Configuration value for '{key_name}' "
+                    f"is set to '{value}' for {SimpleClient.__name__} by an "
+                    f"external method."
+                )
+        if is_async_client is True:
+            if async_transport is None and async_rate_limit is not None:
+                # noinspection PyTypeChecker
+                async_transport = AsyncRateLimitedTransport.create(
+                    rate=Rate.create(magnitude=async_rate_limit, duration=1),
+                    # see more: https://midnighter.github.io/httpx-limiter/latest/tutorial/#single-rate-limit
+                    # In our case, magnitude=1, duration=1/async_rate_limit yields worse results.
+                    http2=enable_http2,  # type: ignore
+                    # See: https://github.com/Midnighter/httpx-limiter/issues/7#issuecomment-3197487921
+                    # http2 needs to be passed here if AsyncRateLimitedTransport is used
+                    verify=verify_ssl,  # type: ignore
+                )
+                logger.debug(
+                    f"Async rate limit is set to {async_transport.__class__.__name__} "
+                    f"instance {async_transport!r}: {async_rate_limit}"
+                )
+            elif async_transport is not None:
+                logger.debug(
+                    f"Async transport has been set to {async_transport!r} by an "
+                    f"external method."
+                )
+                if async_rate_limit is not None:
                     logger.warning(
                         f"When a manual transport parameter is passed to {SimpleClient}, "
                         f"the '{KEY_ASYNC_RATE_LIMIT}' in the configuration file is ignored. "
                     )
-                return AsyncClient(
-                    auth=auth,
+            elif async_transport is None:
+                async_transport = AiohttpTransport(
                     http2=enable_http2,
                     verify=verify_ssl,
-                    timeout=timeout,
-                    transport=transport,
-                    **kwargs,
+                    timeout=timeout,  # type: ignore
+                )
+                logger.debug(
+                    f"Async transport has been to {async_transport!r} by {APP_BRAND_NAME}."
                 )
-            return Client(
+            async_client = AsyncClient(
                 auth=auth,
                 http2=enable_http2,
                 verify=verify_ssl,
                 timeout=timeout,
+                transport=async_transport,
                 **kwargs,
             )
-        except TypeError as e:
-            check_reserved_keyword(
-                e,
-                what=f"{APP_NAME}",
-                against=f"class {SimpleClient.__name__}, "
-                f"so the parameter remains user-configurable "
-                f"through {CONFIG_FILE_NAME} configuration file",
+            if async_capacity is not None:
+                async_client._async_semaphore_ = asyncio.Semaphore(async_capacity)
+                logger.debug(
+                    f"Async semaphore is set to {async_client.__class__.__name__} "
+                    f"instance {async_client!r}: {async_capacity}"
+                )
+            return async_client
+        if sync_transport is not None:
+            logger.debug(
+                f"Sync transport has been set to {sync_transport!r} by an external method."
             )
-            raise e
+        return Client(
+            auth=auth,
+            http2=enable_http2,
+            verify=verify_ssl,
+            timeout=timeout,
+            transport=sync_transport,
+            **kwargs,
+        )
 
 
 class GlobalSharedSession:
@@ -172,13 +229,23 @@ class GlobalSharedSession:
         @cached_property
         def sync_client(self) -> Optional[Client]:
             if self.limited_to in ("sync", "all"):
-                return SimpleClient(is_async_client=False, **self._kwargs)
+                client = SimpleClient(is_async_client=False, **self._kwargs)
+                logger.debug(
+                    f"{GlobalSharedSession.__name__} instance {self!r} "
+                    f"injected sync client {client!r}."
+                )
+                return client
             return None
 
         @cached_property
         def async_client(self) -> Optional[AsyncClient]:
             if self.limited_to in ("async", "all"):
-                return SimpleClient(is_async_client=True, **self._kwargs)
+                client = SimpleClient(is_async_client=True, **self._kwargs)
+                logger.debug(
+                    f"{GlobalSharedSession.__name__} instance {self!r} "
+                    f"injected async client {client!r}."
+                )
+                return client
             return None
 
         def close(self) -> None:
@@ -186,6 +253,9 @@ class GlobalSharedSession:
             if self.sync_client is not None:
                 if self.sync_client.is_closed is False:
                     self.sync_client.close()
+                    logger.debug(
+                        f"{self.__class__.__name__} has closed sync client {self.sync_client!r}."
+                    )
             if self.async_client is not None:
                 if self.async_client.is_closed is False:
                     # nest_asyncio is needed if there are multiple asyncio.run.
@@ -209,8 +279,15 @@ class GlobalSharedSession:
                             ) from e
                         else:
                             event_loop.close()
+                            logger.debug(
+                                f"{self.__class__.__name__} has closed async client {self.async_client!r}."
+                            )
                     else:
                         event_loop.create_task(self.async_client.aclose())
+                        logger.debug(
+                            f"{self.__class__.__name__} has added a task for async client "
+                            f"{self.async_client!r} to be closed."
+                        )
 
         def __enter__(self):
             self._outer_instance = GlobalSharedSession._instance
@@ -339,6 +416,7 @@ class APIRequest(ABC):
             return NotImplemented
         if not self.client.is_closed:
             self.client.close()
+            logger.debug(f"Sync client {self.client!r} is closed.")
         return None
 
     @abstractmethod
@@ -347,6 +425,7 @@ class APIRequest(ABC):
             return NotImplemented
         if not self.client.is_closed:
             await self.client.aclose()
+            logger.debug(f"Async client {self.client!r} is closed.")
         return None
 
     @abstractmethod
@@ -721,6 +800,14 @@ class AsyncGETRequest(APIRequest, is_async_client=True):
         url = ElabFTWURL(
             endpoint_name, endpoint_id, sub_endpoint_name, sub_endpoint_id, query
         )
+        client = super().client
+        if async_semaphore := getattr(client, "_async_semaphore_", None):
+            async with async_semaphore:
+                return await client.get(
+                    url.get(),
+                    headers=headers or {"Accept": "application/json"},
+                    **kwargs,
+                )
         return await super().client.get(
             url.get(), headers=headers or {"Accept": "application/json"}, **kwargs
         )

{elapi-2.4.1 → elapi-2.4.3}/src/elapi/api/endpoint.py

@@ -112,7 +112,7 @@ class FixedAsyncEndpoint:
         )
 
     async def aclose(self) -> Optional[NotImplementedType]:
-        if self._is_global_shared_instance_none is False:
+        if self._is_global_shared_instance_none is True:
             await self._client.aclose()
         return NotImplemented