prompt: You will be provided with a partial code base and an issue statement explaining a problem to resolve.
  <issue>
  Static typing: aws_lambda_powertools.logging.utils.copy_config_to_registered_loggers argument log_level should accept int
  ### Static type checker used
  
  mypy (project's standard)
  
  ### AWS Lambda function runtime
  
  3.9
  
  ### AWS Lambda Powertools for Python version
  
  latest
  
  ### Static type checker info
  
  ```
  $ mypy repro.py
  repro.py:5: error: Argument "log_level" to "copy_config_to_registered_loggers" has incompatible type "int"; expected "Optional[str]"
  Found 1 error in 1 file (checked 1 source file)
  ```
  
  
  ```
  mypy --version
  mypy 0.971 (compiled: yes)
  ```
  
  ### Code snippet
  
  ```python
  from aws_lambda_powertools.logging import utils
  from aws_lambda_powertools import Logger
  
  logger = Logger()
  utils.copy_config_to_registered_loggers(source_logger=logger, log_level=30)
  ```
  
  
  ### Possible Solution
  
  Update signature to accept `Union[str, int]`
  
  </issue>
  <code>
  [start of aws_lambda_powertools/logging/utils.py]
  1 import logging
  2 from typing import Callable, List, Optional, Set, Union
  3 
  4 from .logger import Logger
  5 
  6 PACKAGE_LOGGER = "aws_lambda_powertools"
  7 
  8 
  9 def copy_config_to_registered_loggers(
  10     source_logger: Logger,
  11     log_level: Optional[str] = None,
  12     exclude: Optional[Set[str]] = None,
  13     include: Optional[Set[str]] = None,
  14 ) -> None:
  15 
  16     """Copies source Logger level and handler to all registered loggers for consistent formatting.
  17 
  18     Parameters
  19     ----------
  20     source_logger : Logger
  21         Powertools Logger to copy configuration from
  22     log_level : str, optional
  23         Logging level to set to registered loggers, by default uses source_logger logging level
  24     include : Optional[Set[str]], optional
  25         List of logger names to include, by default all registered loggers are included
  26     exclude : Optional[Set[str]], optional
  27         List of logger names to exclude, by default None
  28     """
  29     level = log_level or source_logger.level
  30 
  31     # Assumptions: Only take parent loggers not children (dot notation rule)
  32     # Steps:
  33     # 1. Default operation: Include all registered loggers
  34     # 2. Only include set? Only add Loggers in the list and ignore all else
  35     # 3. Include and exclude set? Add Logger if it’s in include and not in exclude
  36     # 4. Only exclude set? Ignore Logger in the excluding list
  37 
  38     # Exclude source and powertools package logger by default
  39     # If source logger is a child ensure we exclude parent logger to not break child logger
  40     # from receiving/pushing updates to keys being added/removed
  41     source_logger_name = source_logger.name.split(".")[0]
  42 
  43     if exclude:
  44         exclude.update([source_logger_name, PACKAGE_LOGGER])
  45     else:
  46         exclude = {source_logger_name, PACKAGE_LOGGER}
  47 
  48     # Prepare loggers set
  49     if include:
  50         loggers = include.difference(exclude)
  51         filter_func = _include_registered_loggers_filter
  52     else:
  53         loggers = exclude
  54         filter_func = _exclude_registered_loggers_filter
  55 
  56     registered_loggers = _find_registered_loggers(source_logger, loggers, filter_func)
  57     for logger in registered_loggers:
  58         _configure_logger(source_logger, logger, level)
  59 
  60 
  61 def _include_registered_loggers_filter(loggers: Set[str]):
  62     return [logging.getLogger(name) for name in logging.root.manager.loggerDict if "." not in name and name in loggers]
  63 
  64 
  65 def _exclude_registered_loggers_filter(loggers: Set[str]) -> List[logging.Logger]:
  66     return [
  67         logging.getLogger(name) for name in logging.root.manager.loggerDict if "." not in name and name not in loggers
  68     ]
  69 
  70 
  71 def _find_registered_loggers(
  72     source_logger: Logger, loggers: Set[str], filter_func: Callable[[Set[str]], List[logging.Logger]]
  73 ) -> List[logging.Logger]:
  74     """Filter root loggers based on provided parameters."""
  75     root_loggers = filter_func(loggers)
  76     source_logger.debug(f"Filtered root loggers: {root_loggers}")
  77     return root_loggers
  78 
  79 
  80 def _configure_logger(source_logger: Logger, logger: logging.Logger, level: Union[int, str]) -> None:
  81     logger.handlers = []
  82     logger.setLevel(level)
  83     logger.propagate = False  # ensure we don't propagate logs to existing loggers, #1073
  84     source_logger.debug(f"Logger {logger} reconfigured to use logging level {level}")
  85     for source_handler in source_logger.handlers:
  86         logger.addHandler(source_handler)
  87         source_logger.debug(f"Logger {logger} reconfigured to use {source_handler}")
  88
  [end of aws_lambda_powertools/logging/utils.py]
  </code>
  
  I need you to solve this issue by generating a single patch file that I can apply directly to this repository using git apply. Please respond with a single patch file in the following format.
  <patch>
  diff --git a/file.py b/file.py
  --- a/file.py
  +++ b/file.py
  @@ -1,27 +1,35 @@
   def euclidean(a, b):
  -    while b:
  -        a, b = b, a % b
  -    return a
  +    if b == 0:
  +        return a
  +    return euclidean(b, a % b)
   
   
   def bresenham(x0, y0, x1, y1):
       points = []
       dx = abs(x1 - x0)
       dy = abs(y1 - y0)
  -    sx = 1 if x0 < x1 else -1
  -    sy = 1 if y0 < y1 else -1
  -    err = dx - dy
  +    x, y = x0, y0
  +    sx = -1 if x0 > x1 else 1
  +    sy = -1 if y0 > y1 else 1
   
  -    while True:
  -        points.append((x0, y0))
  -        if x0 == x1 and y0 == y1:
  -            break
  -        e2 = 2 * err
  -        if e2 > -dy:
  -            err -= dy
  -            x0 += sx
  -        if e2 < dx:
  -            err += dx
  -            y0 += sy
  +    if dx > dy:
  +        err = dx / 2.0
  +        while x != x1:
  +            points.append((x, y))
  +            err -= dy
  +            if err < 0:
  +                y += sy
  +                err += dx
  +            x += sx
  +    else:
  +        err = dy / 2.0
  +        while y != y1:
  +            points.append((x, y))
  +            err -= dx
  +            if err < 0:
  +                x += sx
  +                err += dy
  +            y += sy
  +
  +    points.append((x, y))
       return points
  
  </patch>
golden_diff: diff --git a/aws_lambda_powertools/logging/utils.py b/aws_lambda_powertools/logging/utils.py
  --- a/aws_lambda_powertools/logging/utils.py
  +++ b/aws_lambda_powertools/logging/utils.py
  @@ -8,7 +8,7 @@
   
   def copy_config_to_registered_loggers(
       source_logger: Logger,
  -    log_level: Optional[str] = None,
  +    log_level: Optional[Union[int, str]] = None,
       exclude: Optional[Set[str]] = None,
       include: Optional[Set[str]] = None,
   ) -> None:
  @@ -19,7 +19,7 @@
       ----------
       source_logger : Logger
           Powertools Logger to copy configuration from
  -    log_level : str, optional
  +    log_level : Union[int, str], optional
           Logging level to set to registered loggers, by default uses source_logger logging level
       include : Optional[Set[str]], optional
           List of logger names to include, by default all registered loggers are included
  
verification_info: {"golden_diff": "diff --git a/aws_lambda_powertools/logging/utils.py b/aws_lambda_powertools/logging/utils.py\n--- a/aws_lambda_powertools/logging/utils.py\n+++ b/aws_lambda_powertools/logging/utils.py\n@@ -8,7 +8,7 @@\n \n def copy_config_to_registered_loggers(\n     source_logger: Logger,\n-    log_level: Optional[str] = None,\n+    log_level: Optional[Union[int, str]] = None,\n     exclude: Optional[Set[str]] = None,\n     include: Optional[Set[str]] = None,\n ) -> None:\n@@ -19,7 +19,7 @@\n     ----------\n     source_logger : Logger\n         Powertools Logger to copy configuration from\n-    log_level : str, optional\n+    log_level : Union[int, str], optional\n         Logging level to set to registered loggers, by default uses source_logger logging level\n     include : Optional[Set[str]], optional\n         List of logger names to include, by default all registered loggers are included\n", "issue": "Static typing: aws_lambda_powertools.logging.utils.copy_config_to_registered_loggers argument log_level should accept int\n### Static type checker used\r\n\r\nmypy (project's standard)\r\n\r\n### AWS Lambda function runtime\r\n\r\n3.9\r\n\r\n### AWS Lambda Powertools for Python version\r\n\r\nlatest\r\n\r\n### Static type checker info\r\n\r\n```\r\n$ mypy repro.py\r\nrepro.py:5: error: Argument \"log_level\" to \"copy_config_to_registered_loggers\" has incompatible type \"int\"; expected \"Optional[str]\"\r\nFound 1 error in 1 file (checked 1 source file)\r\n```\r\n\r\n\r\n```\r\nmypy --version\r\nmypy 0.971 (compiled: yes)\r\n```\r\n\r\n### Code snippet\r\n\r\n```python\r\nfrom aws_lambda_powertools.logging import utils\r\nfrom aws_lambda_powertools import Logger\r\n\r\nlogger = Logger()\r\nutils.copy_config_to_registered_loggers(source_logger=logger, log_level=30)\r\n```\r\n\r\n\r\n### Possible Solution\r\n\r\nUpdate signature to accept `Union[str, int]`\n", "before_files": [{"content": "import logging\nfrom typing import Callable, List, Optional, Set, Union\n\nfrom .logger import Logger\n\nPACKAGE_LOGGER = \"aws_lambda_powertools\"\n\n\ndef copy_config_to_registered_loggers(\n    source_logger: Logger,\n    log_level: Optional[str] = None,\n    exclude: Optional[Set[str]] = None,\n    include: Optional[Set[str]] = None,\n) -> None:\n\n    \"\"\"Copies source Logger level and handler to all registered loggers for consistent formatting.\n\n    Parameters\n    ----------\n    source_logger : Logger\n        Powertools Logger to copy configuration from\n    log_level : str, optional\n        Logging level to set to registered loggers, by default uses source_logger logging level\n    include : Optional[Set[str]], optional\n        List of logger names to include, by default all registered loggers are included\n    exclude : Optional[Set[str]], optional\n        List of logger names to exclude, by default None\n    \"\"\"\n    level = log_level or source_logger.level\n\n    # Assumptions: Only take parent loggers not children (dot notation rule)\n    # Steps:\n    # 1. Default operation: Include all registered loggers\n    # 2. Only include set? Only add Loggers in the list and ignore all else\n    # 3. Include and exclude set? Add Logger if it\u2019s in include and not in exclude\n    # 4. Only exclude set? Ignore Logger in the excluding list\n\n    # Exclude source and powertools package logger by default\n    # If source logger is a child ensure we exclude parent logger to not break child logger\n    # from receiving/pushing updates to keys being added/removed\n    source_logger_name = source_logger.name.split(\".\")[0]\n\n    if exclude:\n        exclude.update([source_logger_name, PACKAGE_LOGGER])\n    else:\n        exclude = {source_logger_name, PACKAGE_LOGGER}\n\n    # Prepare loggers set\n    if include:\n        loggers = include.difference(exclude)\n        filter_func = _include_registered_loggers_filter\n    else:\n        loggers = exclude\n        filter_func = _exclude_registered_loggers_filter\n\n    registered_loggers = _find_registered_loggers(source_logger, loggers, filter_func)\n    for logger in registered_loggers:\n        _configure_logger(source_logger, logger, level)\n\n\ndef _include_registered_loggers_filter(loggers: Set[str]):\n    return [logging.getLogger(name) for name in logging.root.manager.loggerDict if \".\" not in name and name in loggers]\n\n\ndef _exclude_registered_loggers_filter(loggers: Set[str]) -> List[logging.Logger]:\n    return [\n        logging.getLogger(name) for name in logging.root.manager.loggerDict if \".\" not in name and name not in loggers\n    ]\n\n\ndef _find_registered_loggers(\n    source_logger: Logger, loggers: Set[str], filter_func: Callable[[Set[str]], List[logging.Logger]]\n) -> List[logging.Logger]:\n    \"\"\"Filter root loggers based on provided parameters.\"\"\"\n    root_loggers = filter_func(loggers)\n    source_logger.debug(f\"Filtered root loggers: {root_loggers}\")\n    return root_loggers\n\n\ndef _configure_logger(source_logger: Logger, logger: logging.Logger, level: Union[int, str]) -> None:\n    logger.handlers = []\n    logger.setLevel(level)\n    logger.propagate = False  # ensure we don't propagate logs to existing loggers, #1073\n    source_logger.debug(f\"Logger {logger} reconfigured to use logging level {level}\")\n    for source_handler in source_logger.handlers:\n        logger.addHandler(source_handler)\n        source_logger.debug(f\"Logger {logger} reconfigured to use {source_handler}\")\n", "path": "aws_lambda_powertools/logging/utils.py"}]}