PyPI - api-to-dataframe - Versions diffs - 1.5.1__tar.gz → 2.0.0__tar.gz - Mend

api-to-dataframe 1.5.1tar.gz → 2.0.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

{api_to_dataframe-1.5.1 → api_to_dataframe-2.0.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: api-to-dataframe
-Version: 1.5.1
+Version: 2.0.0
 Summary: A package to convert API responses to pandas dataframe
 License: MIT
 Author: IvanildoBarauna
@@ -15,7 +15,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.8
 Requires-Dist: logging (>=0.4.9.6,<0.5.0.0)
-Requires-Dist: otel-wrapper (>=0.1.1,<0.2.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Project-URL: Documentation, https://github.com/IvanildoBarauna/api-to-dataframe/blob/main/README.md

{api_to_dataframe-1.5.1 → api_to_dataframe-2.0.0}/pyproject.toml RENAMED Viewed

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "api-to-dataframe"
-version = "1.5.1"
+version = "2.0.0"
 description = "A package to convert API responses to pandas dataframe"
 authors = ["IvanildoBarauna <ivanildo.jnr@outlook.com>"]
 readme = "README.md"
@@ -27,7 +27,6 @@ python = "^3.9"
 pandas = "^2.2.3"
 requests = "^2.32.3"
 logging = "^0.4.9.6"
-otel-wrapper = "^0.1.1"
 [tool.poetry.group.dev.dependencies]
 poetry-dynamic-versioning = "^1.3.0"

api_to_dataframe-2.0.0/src/api_to_dataframe/controller/client_builder.py ADDED Viewed

@@ -0,0 +1,95 @@
+from api_to_dataframe.models.retainer import retry_strategies, Strategies
+from api_to_dataframe.models.get_data import GetData
+from api_to_dataframe.utils.logger import logger
+class ClientBuilder:
+    def __init__(  # pylint: disable=too-many-positional-arguments,too-many-arguments
+        self,
+        endpoint: str,
+        headers: dict = None,
+        retry_strategy: Strategies = Strategies.NO_RETRY_STRATEGY,
+        retries: int = 3,
+        initial_delay: int = 1,
+        connection_timeout: int = 1,
+    ):
+        """
+        Initializes the ClientBuilder object.
+        Args:
+            endpoint (str): The API endpoint to connect to.
+            headers (dict, optional): The headers to use for the API request. Defaults to None.
+            retry_strategy (Strategies, optional): Defaults to Strategies.NO_RETRY_STRATEGY.
+            retries (int): The number of times to retry a failed request. Defaults to 3.
+            initial_delay (int): The delay between retries in seconds. Defaults to 1.
+            connection_timeout (int): The timeout for the connection in seconds. Defaults to 1.
+        Raises:
+            ValueError: If endpoint is an empty string.
+            ValueError: If retries is not a non-negative integer.
+            ValueError: If delay is not a non-negative integer.
+            ValueError: If connection_timeout is not a non-negative integer.
+        """
+        if headers is None:
+            headers = {}
+        if endpoint == "":
+            error_msg = "endpoint cannot be an empty string"
+            logger.error(error_msg)
+            raise ValueError
+        if not isinstance(retries, int) or retries < 0:
+            error_msg = "retries must be a non-negative integer"
+            logger.error(error_msg)
+            raise ValueError
+        if not isinstance(initial_delay, int) or initial_delay < 0:
+            error_msg = "initial_delay must be a non-negative integer"
+            logger.error(error_msg)
+            raise ValueError
+        if not isinstance(connection_timeout, int) or connection_timeout < 0:
+            error_msg = "connection_timeout must be a non-negative integer"
+            logger.error(error_msg)
+            raise ValueError
+        self.endpoint = endpoint
+        self.retry_strategy = retry_strategy
+        self.connection_timeout = connection_timeout
+        self.headers = headers
+        self.retries = retries
+        self.delay = initial_delay
+    @retry_strategies
+    def get_api_data(self):
+        """
+        Retrieves data from the API using the defined endpoint and retry strategy.
+        This function sends a request to the API using the endpoint, headers, and
+        connection timeout specified in the instance attributes. It uses the
+        defined retry strategy to handle potential failures and retries.
+        Returns:
+            dict: The JSON response from the API as a dictionary.
+        """
+        response = GetData.get_response(
+            endpoint=self.endpoint,
+            headers=self.headers,
+            connection_timeout=self.connection_timeout,
+        )
+        return response.json()
+    @staticmethod
+    def api_to_dataframe(response: dict):
+        """
+        Converts an API response to a DataFrame.
+        This function takes a dictionary response from an API,
+        uses the `to_dataframe` function from the `GetData` class
+        to convert it into a DataFrame, and logs the operation as successful.
+        Args:
+            response (dict): The dictionary containing the API response.
+        Returns:
+            DataFrame: A pandas DataFrame containing the data from the API response.
+        """
+        return GetData.to_dataframe(response)

api_to_dataframe-2.0.0/src/api_to_dataframe/models/get_data.py ADDED Viewed

@@ -0,0 +1,27 @@
+import requests
+import pandas as pd
+from api_to_dataframe.utils.logger import logger
+class GetData:
+    @staticmethod
+    def get_response(endpoint: str, headers: dict, connection_timeout: int):
+        # Make the request
+        response = requests.get(endpoint, timeout=connection_timeout, headers=headers)
+        # Attempt to raise for status to catch errors
+        response.raise_for_status()
+        return response
+    @staticmethod
+    def to_dataframe(response):
+        df = pd.DataFrame(response)
+        # Check if DataFrame is empty
+        if df.empty:
+            error_msg = "::: DataFrame is empty :::"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        return df

api_to_dataframe-2.0.0/src/api_to_dataframe/models/retainer.py ADDED Viewed

@@ -0,0 +1,39 @@
+import time
+from enum import Enum
+from requests.exceptions import RequestException
+from api_to_dataframe.utils.logger import logger
+from api_to_dataframe.utils import Constants
+class Strategies(Enum):
+    NO_RETRY_STRATEGY = 0
+    LINEAR_RETRY_STRATEGY = 1
+    EXPONENTIAL_RETRY_STRATEGY = 2
+def retry_strategies(func):
+    def wrapper(*args, **kwargs):  # pylint: disable=inconsistent-return-statements
+        retry_number = 0
+        while retry_number < args[0].retries:
+            try:
+                if retry_number > 0:
+                    logger.info(
+                        f"Trying for the {retry_number} of {Constants.MAX_OF_RETRIES} retries. Using {args[0].retry_strategy}"
+                    )
+                return func(*args, **kwargs)
+            except RequestException as e:
+                retry_number += 1
+                if args[0].retry_strategy == Strategies.NO_RETRY_STRATEGY:
+                    raise e
+                if args[0].retry_strategy == Strategies.LINEAR_RETRY_STRATEGY:
+                    time.sleep(args[0].delay)
+                elif args[0].retry_strategy == Strategies.EXPONENTIAL_RETRY_STRATEGY:
+                    time.sleep(args[0].delay * retry_number)
+                if retry_number in (args[0].retries, Constants.MAX_OF_RETRIES):
+                    logger.error(f"Failed after {retry_number} retries")
+                    raise e
+    return wrapper

{api_to_dataframe-1.5.1 → api_to_dataframe-2.0.0}/src/api_to_dataframe/utils/logger.py RENAMED Viewed

@@ -1,7 +1,5 @@
 import logging
-from otel_wrapper.deps_injector import wrapper_builder
-# Configure logging once at the start of your program
 logging.basicConfig(
     encoding="utf-8",
     format="%(asctime)s :: api-to-dataframe[%(levelname)s] :: %(message)s",
@@ -11,6 +9,3 @@ logging.basicConfig(
 # Initialize traditional logger
 logger = logging.getLogger("api-to-dataframe")
-# Initialize OpenTelemetry wrapper
-telemetry = wrapper_builder("api-to-dataframe")

api_to_dataframe-1.5.1/src/api_to_dataframe/controller/client_builder.py DELETED Viewed

@@ -1,251 +0,0 @@
-from api_to_dataframe.models.retainer import retry_strategies, Strategies
-from api_to_dataframe.models.get_data import GetData
-from api_to_dataframe.utils.logger import logger, telemetry
-import time
-class ClientBuilder:
-    def __init__(  # pylint: disable=too-many-positional-arguments,too-many-arguments
-        self,
-        endpoint: str,
-        headers: dict = None,
-        retry_strategy: Strategies = Strategies.NO_RETRY_STRATEGY,
-        retries: int = 3,
-        initial_delay: int = 1,
-        connection_timeout: int = 1,
-    ):
-        """
-        Initializes the ClientBuilder object.
-        Args:
-            endpoint (str): The API endpoint to connect to.
-            headers (dict, optional): The headers to use for the API request. Defaults to None.
-            retry_strategy (Strategies, optional): Defaults to Strategies.NO_RETRY_STRATEGY.
-            retries (int): The number of times to retry a failed request. Defaults to 3.
-            initial_delay (int): The delay between retries in seconds. Defaults to 1.
-            connection_timeout (int): The timeout for the connection in seconds. Defaults to 1.
-        Raises:
-            ValueError: If endpoint is an empty string.
-            ValueError: If retries is not a non-negative integer.
-            ValueError: If delay is not a non-negative integer.
-            ValueError: If connection_timeout is not a non-negative integer.
-        """
-        if headers is None:
-            headers = {}
-        if endpoint == "":
-            error_msg = "endpoint cannot be an empty string"
-            logger.error(error_msg)
-            telemetry.logs().new_log(
-                msg=error_msg,
-                tags={"component": "ClientBuilder", "method": "__init__"},
-                level=40  # ERROR level
-            )
-            raise ValueError
-        if not isinstance(retries, int) or retries < 0:
-            error_msg = "retries must be a non-negative integer"
-            logger.error(error_msg)
-            telemetry.logs().new_log(
-                msg=error_msg,
-                tags={"component": "ClientBuilder", "method": "__init__"},
-                level=40  # ERROR level
-            )
-            raise ValueError
-        if not isinstance(initial_delay, int) or initial_delay < 0:
-            error_msg = "initial_delay must be a non-negative integer"
-            logger.error(error_msg)
-            telemetry.logs().new_log(
-                msg=error_msg,
-                tags={"component": "ClientBuilder", "method": "__init__"},
-                level=40  # ERROR level
-            )
-            raise ValueError
-        if not isinstance(connection_timeout, int) or connection_timeout < 0:
-            error_msg = "connection_timeout must be a non-negative integer"
-            logger.error(error_msg)
-            telemetry.logs().new_log(
-                msg=error_msg,
-                tags={"component": "ClientBuilder", "method": "__init__"},
-                level=40  # ERROR level
-            )
-            raise ValueError
-        self.endpoint = endpoint
-        self.retry_strategy = retry_strategy
-        self.connection_timeout = connection_timeout
-        self.headers = headers
-        self.retries = retries
-        self.delay = initial_delay
-        # Record client initialization metric
-        telemetry.metrics().metric_increment(
-            name="client.initialization",
-            tags={
-                "endpoint": endpoint,
-                "retry_strategy": retry_strategy.name,
-                "connection_timeout": str(connection_timeout)
-            }
-        )
-        # Log initialization
-        telemetry.logs().new_log(
-            msg=f"ClientBuilder initialized with endpoint {endpoint}",
-            tags={
-                "endpoint": endpoint,
-                "retry_strategy": retry_strategy.name,
-                "connection_timeout": str(connection_timeout),
-                "component": "ClientBuilder"
-            },
-            level=20  # INFO level
-        )
-    @retry_strategies
-    def get_api_data(self):
-        """
-        Retrieves data from the API using the defined endpoint and retry strategy.
-        This function sends a request to the API using the endpoint, headers, and
-        connection timeout specified in the instance attributes. It uses the
-        defined retry strategy to handle potential failures and retries.
-        Returns:
-            dict: The JSON response from the API as a dictionary.
-        """
-        # Use the telemetry spans with context manager
-        with telemetry.traces().span_in_context("get_api_data") as (span, _):
-            # Add span attributes
-            span.set_attribute("endpoint", self.endpoint)
-            span.set_attribute("retry_strategy", self.retry_strategy.name)
-            span.set_attribute("connection_timeout", self.connection_timeout)
-            # Log the API request
-            telemetry.logs().new_log(
-                msg=f"Making API request to {self.endpoint}",
-                tags={
-                    "endpoint": self.endpoint,
-                    "component": "ClientBuilder",
-                    "method": "get_api_data"
-                },
-                level=20  # INFO level
-            )
-            # Record the start time for response time measurement
-            start_time = time.time()
-            # Make the API request
-            response = GetData.get_response(
-                endpoint=self.endpoint,
-                headers=self.headers,
-                connection_timeout=self.connection_timeout,
-            )
-            # Calculate response time
-            response_time = time.time() - start_time
-            # Record response time as histogram
-            telemetry.metrics().record_histogram(
-                name="api.response_time",
-                tags={"endpoint": self.endpoint},
-                value=response_time
-            )
-            # Record successful request metric
-            telemetry.metrics().metric_increment(
-                name="api.request.success",
-                tags={"endpoint": self.endpoint}
-            )
-            # Log success
-            telemetry.logs().new_log(
-                msg=f"API request to {self.endpoint} successful",
-                tags={
-                    "endpoint": self.endpoint,
-                    "response_status": response.status_code,
-                    "response_time": response_time,
-                    "component": "ClientBuilder",
-                    "method": "get_api_data"
-                },
-                level=20  # INFO level
-            )
-        return response.json()
-    @staticmethod
-    def api_to_dataframe(response: dict):
-        """
-        Converts an API response to a DataFrame.
-        This function takes a dictionary response from an API,
-        uses the `to_dataframe` function from the `GetData` class
-        to convert it into a DataFrame, and logs the operation as successful.
-        Args:
-            response (dict): The dictionary containing the API response.
-        Returns:
-            DataFrame: A pandas DataFrame containing the data from the API response.
-        """
-        # Use telemetry for this operation
-        with telemetry.traces().span_in_context("api_to_dataframe") as (span, _):
-            response_size = len(response) if isinstance(response, list) else 1
-            span.set_attribute("response_size", response_size)
-            # Log conversion start
-            telemetry.logs().new_log(
-                msg="Converting API response to DataFrame",
-                tags={
-                    "response_size": response_size,
-                    "response_type": type(response).__name__,
-                    "component": "ClientBuilder",
-                    "method": "api_to_dataframe"
-                },
-                level=20  # INFO level
-            )
-            try:
-                # Convert to dataframe
-                df = GetData.to_dataframe(response)
-                # Record metrics
-                telemetry.metrics().metric_increment(
-                    name="dataframe.conversion.success",
-                    tags={"size": len(df)}
-                )
-                # Log success
-                telemetry.logs().new_log(
-                    msg="Successfully converted API response to DataFrame",
-                    tags={
-                        "dataframe_rows": len(df),
-                        "dataframe_columns": len(df.columns),
-                        "component": "ClientBuilder",
-                        "method": "api_to_dataframe"
-                    },
-                    level=20  # INFO level
-                )
-                return df
-            except Exception as e:
-                # Record failure metric
-                telemetry.metrics().metric_increment(
-                    name="dataframe.conversion.failure",
-                    tags={"error_type": type(e).__name__}
-                )
-                # Log error
-                error_msg = f"Failed to convert API response to DataFrame: {str(e)}"
-                telemetry.logs().new_log(
-                    msg=error_msg,
-                    tags={
-                        "error": str(e),
-                        "error_type": type(e).__name__,
-                        "component": "ClientBuilder",
-                        "method": "api_to_dataframe"
-                    },
-                    level=40  # ERROR level
-                )
-                # Re-raise the exception
-                raise

api_to_dataframe-1.5.1/src/api_to_dataframe/models/get_data.py DELETED Viewed

@@ -1,215 +0,0 @@
-import requests
-import pandas as pd
-from api_to_dataframe.utils.logger import logger, telemetry
-class GetData:
-    @staticmethod
-    def get_response(endpoint: str, headers: dict, connection_timeout: int):
-        # Start a span for the API request
-        with telemetry.traces().span_in_context("http_request") as (span, _):
-            span.set_attribute("http.url", endpoint)
-            span.set_attribute("http.method", "GET")
-            span.set_attribute("http.timeout", connection_timeout)
-            # Log the request
-            telemetry.logs().new_log(
-                msg=f"Sending HTTP GET request to {endpoint}",
-                tags={
-                    "endpoint": endpoint,
-                    "timeout": connection_timeout,
-                    "component": "GetData",
-                    "method": "get_response"
-                },
-                level=20  # INFO level
-            )
-            try:
-                # Make the request
-                response = requests.get(endpoint, timeout=connection_timeout, headers=headers)
-                # Set response attributes on span
-                span.set_attribute("http.status_code", response.status_code)
-                span.set_attribute("http.response_content_length", len(response.content))
-                # Attempt to raise for status to catch errors
-                response.raise_for_status()
-                # Log successful response
-                telemetry.logs().new_log(
-                    msg=f"Received HTTP {response.status_code} response from {endpoint}",
-                    tags={
-                        "endpoint": endpoint,
-                        "status_code": response.status_code,
-                        "response_size": len(response.content),
-                        "component": "GetData",
-                        "method": "get_response"
-                    },
-                    level=20  # INFO level
-                )
-                # Record successful request metric
-                telemetry.metrics().metric_increment(
-                    name="http.request.success",
-                    tags={
-                        "endpoint": endpoint,
-                        "status_code": response.status_code
-                    }
-                )
-                return response
-            except requests.exceptions.RequestException as e:
-                # Record the exception on the span
-                span.record_exception(e)
-                span.set_attribute("error", True)
-                span.set_attribute("error.type", type(e).__name__)
-                span.set_attribute("error.message", str(e))
-                # Log the error
-                telemetry.logs().new_log(
-                    msg=f"HTTP request failed: {str(e)}",
-                    tags={
-                        "endpoint": endpoint,
-                        "error": str(e),
-                        "error_type": type(e).__name__,
-                        "component": "GetData",
-                        "method": "get_response"
-                    },
-                    level=40  # ERROR level
-                )
-                # Record failure metric
-                telemetry.metrics().metric_increment(
-                    name="http.request.failure",
-                    tags={
-                        "endpoint": endpoint,
-                        "error_type": type(e).__name__
-                    }
-                )
-                # Re-raise the exception
-                raise
-    @staticmethod
-    def to_dataframe(response):
-        # Start a span for dataframe conversion
-        with telemetry.traces().span_in_context("convert_to_dataframe") as (span, _):
-            # Set attributes about the data
-            data_size = len(response) if isinstance(response, list) else 1
-            span.set_attribute("data.size", data_size)
-            span.set_attribute("data.type", type(response).__name__)
-            # Log conversion attempt
-            telemetry.logs().new_log(
-                msg="Converting data to DataFrame",
-                tags={
-                    "data_size": data_size,
-                    "data_type": type(response).__name__,
-                    "component": "GetData",
-                    "method": "to_dataframe"
-                },
-                level=20  # INFO level
-            )
-            try:
-                # Convert to DataFrame
-                df = pd.DataFrame(response)
-                # Check if DataFrame is empty
-                if df.empty:
-                    error_msg = "::: DataFrame is empty :::"
-                    logger.error(error_msg)
-                    # Log the error with OpenTelemetry
-                    telemetry.logs().new_log(
-                        msg=error_msg,
-                        tags={
-                            "data_size": data_size,
-                            "data_type": type(response).__name__,
-                            "component": "GetData",
-                            "method": "to_dataframe"
-                        },
-                        level=40  # ERROR level
-                    )
-                    # Record empty DataFrame metric
-                    telemetry.metrics().metric_increment(
-                        name="dataframe.empty",
-                        tags={"data_type": type(response).__name__}
-                    )
-                    # Set span as error
-                    span.set_attribute("error", True)
-                    span.set_attribute("error.type", "ValueError")
-                    span.set_attribute("error.message", error_msg)
-                    raise ValueError(error_msg)
-                # Log success
-                telemetry.logs().new_log(
-                    msg="Successfully converted data to DataFrame",
-                    tags={
-                        "rows": len(df),
-                        "columns": len(df.columns),
-                        "component": "GetData",
-                        "method": "to_dataframe"
-                    },
-                    level=20  # INFO level
-                )
-                # Record dataframe metrics
-                telemetry.metrics().record_gauge(
-                    name="dataframe.rows",
-                    tags={"data_type": type(response).__name__},
-                    value=float(len(df))
-                )
-                telemetry.metrics().record_gauge(
-                    name="dataframe.columns",
-                    tags={"data_type": type(response).__name__},
-                    value=float(len(df.columns))
-                )
-                # Set additional span attributes
-                span.set_attribute("dataframe.rows", len(df))
-                span.set_attribute("dataframe.columns", len(df.columns))
-                return df
-            except ValueError:
-                # Re-raise ValueErrors (like empty DataFrame)
-                raise
-            except Exception as err:
-                # Log the error
-                error_msg = f"Invalid response for transform in dataframe: {err}"
-                logger.error(error_msg)
-                # Log with OpenTelemetry
-                telemetry.logs().new_log(
-                    msg=error_msg,
-                    tags={
-                        "error": str(err),
-                        "error_type": type(err).__name__,
-                        "data_type": type(response).__name__,
-                        "component": "GetData",
-                        "method": "to_dataframe"
-                    },
-                    level=40  # ERROR level
-                )
-                # Record conversion failure metric
-                telemetry.metrics().metric_increment(
-                    name="dataframe.conversion.error",
-                    tags={"error_type": type(err).__name__}
-                )
-                # Record the exception on the span
-                span.record_exception(err)
-                span.set_attribute("error", True)
-                span.set_attribute("error.type", type(err).__name__)
-                span.set_attribute("error.message", str(err))
-                # Raise TypeError with original error as cause
-                raise TypeError(error_msg) from err

api_to_dataframe-1.5.1/src/api_to_dataframe/models/retainer.py DELETED Viewed

@@ -1,188 +0,0 @@
-import time
-from enum import Enum
-from requests.exceptions import RequestException
-from api_to_dataframe.utils.logger import logger, telemetry
-from api_to_dataframe.utils import Constants
-class Strategies(Enum):
-    NO_RETRY_STRATEGY = 0
-    LINEAR_RETRY_STRATEGY = 1
-    EXPONENTIAL_RETRY_STRATEGY = 2
-def retry_strategies(func):
-    def wrapper(*args, **kwargs):  # pylint: disable=inconsistent-return-statements
-        retry_number = 0
-        # Get the endpoint for better observability context
-        endpoint = args[0].endpoint if hasattr(args[0], 'endpoint') else 'unknown'
-        # Start a span for this entire retry operation
-        with telemetry.traces().span_in_context("retry_operation") as (span, _):
-            span.set_attribute("endpoint", endpoint)
-            span.set_attribute("retry_strategy", args[0].retry_strategy.name)
-            span.set_attribute("max_retries", args[0].retries)
-            while retry_number < args[0].retries:
-                try:
-                    # Log retry attempt if not the first attempt
-                    if retry_number > 0:
-                        # Log using traditional logger
-                        logger.info(f"Trying for the {retry_number} of {Constants.MAX_OF_RETRIES} retries. Using {args[0].retry_strategy}")
-                        # Log using OpenTelemetry
-                        telemetry.logs().new_log(
-                            msg=f"Retry attempt {retry_number} of {args[0].retries}",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_number": retry_number,
-                                "max_retries": args[0].retries,
-                                "retry_strategy": args[0].retry_strategy.name,
-                                "component": "RetryStrategy"
-                            },
-                            level=20  # INFO level
-                        )
-                        # Record retry metric
-                        telemetry.metrics().metric_increment(
-                            name="api.request.retry",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_strategy": args[0].retry_strategy.name
-                            }
-                        )
-                        # Update span with current retry count
-                        span.set_attribute("current_retry", retry_number)
-                    # Execute the wrapped function
-                    result = func(*args, **kwargs)
-                    # If we got here, it succeeded - record success metric after retries
-                    if retry_number > 0:
-                        telemetry.metrics().metric_increment(
-                            name="api.request.retry.success",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_count": retry_number,
-                                "retry_strategy": args[0].retry_strategy.name
-                            }
-                        )
-                        telemetry.logs().new_log(
-                            msg=f"Request succeeded after {retry_number} retries",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_count": retry_number,
-                                "retry_strategy": args[0].retry_strategy.name,
-                                "component": "RetryStrategy"
-                            },
-                            level=20  # INFO level
-                        )
-                    return result
-                except RequestException as e:
-                    retry_number += 1
-                    # Record exception in the span
-                    span.record_exception(e)
-                    span.set_attribute("failed_attempt", retry_number)
-                    # Handle different retry strategies
-                    if args[0].retry_strategy == Strategies.NO_RETRY_STRATEGY:
-                        # Log failure with OpenTelemetry
-                        telemetry.logs().new_log(
-                            msg=f"Request failed with {type(e).__name__}, no retry strategy configured",
-                            tags={
-                                "endpoint": endpoint,
-                                "error": str(e),
-                                "error_type": type(e).__name__,
-                                "component": "RetryStrategy"
-                            },
-                            level=40  # ERROR level
-                        )
-                        # Record failure metric
-                        telemetry.metrics().metric_increment(
-                            name="api.request.failure",
-                            tags={
-                                "endpoint": endpoint,
-                                "error_type": type(e).__name__,
-                                "retry_strategy": "none"
-                            }
-                        )
-                        raise e
-                    # Apply delay based on strategy
-                    if args[0].retry_strategy == Strategies.LINEAR_RETRY_STRATEGY:
-                        delay = args[0].delay
-                        strategy_name = "linear"
-                    elif args[0].retry_strategy == Strategies.EXPONENTIAL_RETRY_STRATEGY:
-                        delay = args[0].delay * retry_number
-                        strategy_name = "exponential"
-                    # Log retry delay
-                    telemetry.logs().new_log(
-                        msg=f"Request failed, retrying in {delay}s (strategy: {strategy_name})",
-                        tags={
-                            "endpoint": endpoint,
-                            "retry_count": retry_number,
-                            "delay": delay,
-                            "strategy": strategy_name,
-                            "error": str(e),
-                            "error_type": type(e).__name__,
-                            "component": "RetryStrategy"
-                        },
-                        level=30  # WARNING level
-                    )
-                    # Record the delay time in metrics
-                    telemetry.metrics().record_gauge(
-                        name="api.retry.delay",
-                        tags={
-                            "endpoint": endpoint,
-                            "retry_count": retry_number,
-                            "strategy": strategy_name
-                        },
-                        value=float(delay)
-                    )
-                    # Sleep for the calculated delay
-                    time.sleep(delay)
-                    # Check if we've reached max retries
-                    if retry_number in (args[0].retries, Constants.MAX_OF_RETRIES):
-                        # Log final failure
-                        error_msg = f"Failed after {retry_number} retries"
-                        logger.error(error_msg)
-                        telemetry.logs().new_log(
-                            msg=error_msg,
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_count": retry_number,
-                                "max_retries": args[0].retries,
-                                "error": str(e),
-                                "error_type": type(e).__name__,
-                                "component": "RetryStrategy"
-                            },
-                            level=40  # ERROR level
-                        )
-                        # Record final failure metric
-                        telemetry.metrics().metric_increment(
-                            name="api.request.retry.exhausted",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_strategy": args[0].retry_strategy.name,
-                                "error_type": type(e).__name__
-                            }
-                        )
-                        raise e
-    return wrapper

{api_to_dataframe-1.5.1 → api_to_dataframe-2.0.0}/LICENSE RENAMED Viewed

File without changes

{api_to_dataframe-1.5.1 → api_to_dataframe-2.0.0}/README.md RENAMED Viewed

File without changes

{api_to_dataframe-1.5.1 → api_to_dataframe-2.0.0}/src/api_to_dataframe/__init__.py RENAMED Viewed

File without changes

{api_to_dataframe-1.5.1 → api_to_dataframe-2.0.0}/src/api_to_dataframe/utils/__init__.py RENAMED Viewed

File without changes

api-to-dataframe 1.5.1__tar.gz → 2.0.0__tar.gz

api-to-dataframe 1.5.1tar.gz → 2.0.0tar.gz