cloudbridge 4.1.0__tar.gz → 4.2.0__tar.gz

{cloudbridge-4.1.0 → cloudbridge-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudbridge
-Version: 4.1.0
+Version: 4.2.0
 Summary: A simple layer of abstraction over multiple cloud providers.
 Author-email: Galaxy and GVL Projects <help@genome.edu.au>
 License-Expression: MIT
@@ -22,7 +22,6 @@ Requires-Python: >=3.13
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: tenacity>=6.0
-Requires-Dist: deprecation>=2.0.7
 Requires-Dist: pyeventsystem<2
 Provides-Extra: aws
 Requires-Dist: boto3<2.0.0,>=1.9.86; extra == "aws"
@@ -60,6 +59,7 @@ Requires-Dist: sphinx>=1.3.1; extra == "dev"
 Requires-Dist: pydevd; extra == "dev"
 Requires-Dist: flake8>=3.3.0; extra == "dev"
 Requires-Dist: flake8-import-order>=0.12; extra == "dev"
+Requires-Dist: mypy<3,>=2.1; extra == "dev"
 Dynamic: license-file
 
 CloudBridge provides a consistent layer of abstraction over different

{cloudbridge-4.1.0 → cloudbridge-4.2.0}/cloudbridge/__init__.py

@@ -1,11 +1,12 @@
 """Library setup."""
 import logging
+from typing import Any
 
 # Current version of the library
-__version__ = '4.1.0'
+__version__ = '4.2.0'
 
 
-def get_version():
+def get_version() -> str:
     """
     Return a string with the current version of the library.
 
@@ -15,7 +16,7 @@ def get_version():
     return __version__
 
 
-def init_logging():
+def init_logging() -> None:
     """
     Initialize logging for testing.
 
@@ -35,7 +36,7 @@ class CBLogger(logging.Logger):
     Add a ``trace`` log level, numeric value 5: ``log.trace("Log message")``
     """
 
-    def trace(self, msg, *args, **kwargs):
+    def trace(self, msg: object, *args: object, **kwargs: Any) -> None:
         """Add ``trace`` log level."""
         self.log(TRACE, msg, *args, **kwargs)
 
@@ -61,7 +62,8 @@ log.addHandler(logging.NullHandler())
 #   cloudbridge.set_file_logger(__name__, '/tmp/log')
 
 
-def set_stream_logger(name, level=TRACE, format_string=None):
+def set_stream_logger(name: str, level: int = TRACE,
+                      format_string: str | None = None) -> None:
     """A convenience method to set the global logger to stream."""
     global log
     if not format_string:
@@ -76,7 +78,8 @@ def set_stream_logger(name, level=TRACE, format_string=None):
     log = logger
 
 
-def set_file_logger(name, filepath, level=logging.INFO, format_string=None):
+def set_file_logger(name: str, filepath: str, level: int = logging.INFO,
+                    format_string: str | None = None) -> None:
     """A convenience method to set the global logger to a file."""
     global log
     if not format_string:

{cloudbridge-4.1.0 → cloudbridge-4.2.0}/cloudbridge/base/helpers.py

@@ -1,24 +1,26 @@
 import fnmatch
-import functools
 import logging
 import os
 import re
+from collections.abc import Callable
+from collections.abc import Iterator
 from contextlib import contextmanager
+from typing import Any
+from typing import TypeVar
+from typing import overload
 
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import serialization as crypt_serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
 
-from deprecation import deprecated
-
-import cloudbridge
-
 from ..interfaces.exceptions import InvalidParamException
 
 log = logging.getLogger(__name__)
 
+T = TypeVar("T")
+
 
-def generate_key_pair():
+def generate_key_pair() -> tuple[str, str]:
     """
     This method generates a keypair and returns it as a tuple
     of (public, private) keys.
@@ -38,7 +40,8 @@ def generate_key_pair():
     return public_key, private_key
 
 
-def filter_by(prop_name, kwargs, objs):
+def filter_by(prop_name: str, kwargs: dict[str, Any],
+              objs: list[T]) -> list[T]:
     """
     Utility method for filtering a list of objects by a property.
     If the given property has a non empty value in kwargs, then
@@ -60,7 +63,8 @@ def filter_by(prop_name, kwargs, objs):
         return objs
 
 
-def generic_find(filter_names, kwargs, objs):
+def generic_find(filter_names: list[str], kwargs: dict[str, Any],
+                 objs: list[T]) -> list[T]:
     """
     Utility method for filtering a list of objects by a list of filters.
     """
@@ -78,7 +82,7 @@ def generic_find(filter_names, kwargs, objs):
 
 
 @contextmanager
-def cleanup_action(cleanup_func):
+def cleanup_action(cleanup_func: Callable[[], object]) -> Iterator[None]:
     """
     Context manager to carry out a given
     cleanup action after carrying out a set
@@ -109,7 +113,17 @@ def cleanup_action(cleanup_func):
         log.exception("Error during exception cleanup: ")
 
 
-def get_env(varname, default_value=None):
+@overload
+def get_env(varname: str) -> str | None:
+    ...
+
+
+@overload
+def get_env(varname: str, default_value: T) -> str | T:
+    ...
+
+
+def get_env(varname: str, default_value: object = None) -> object:
     """
     Return the value of the environment variable or default_value.
 
@@ -125,39 +139,10 @@ def get_env(varname, default_value=None):
     return os.environ.get(varname, default_value)
 
 
-# Alias deprecation decorator, following:
-# https://stackoverflow.com/questions/49802412/
-# how-to-implement-deprecation-in-python-with-argument-alias
-def deprecated_alias(**aliases):
-    def deco(f):
-        @functools.wraps(f)
-        def wrapper(*args, **kwargs):
-            rename_kwargs(f.__name__, kwargs, aliases)
-            return f(*args, **kwargs)
-        return wrapper
-    return deco
-
-
-def rename_kwargs(func_name, kwargs, aliases):
-    for alias, new in aliases.items():
-        if alias in kwargs:
-            if new in kwargs:
-                raise InvalidParamException(
-                    '{} received both {} and {}'.format(func_name, alias, new))
-            # Manually invoke the deprecated decorator with an empty lambda
-            # to signal deprecation
-            deprecated(deprecated_in='1.1',
-                       removed_in='2.0',
-                       current_version=cloudbridge.__version__,
-                       details='{} is deprecated, use {} instead'.format(
-                           alias, new))(lambda: None)()
-            kwargs[new] = kwargs.pop(alias)
-
-
 NON_ALPHA_NUM = re.compile(r"[^A-Za-z0-9]+")
 
 
-def to_resource_name(value, replace_with="-"):
+def to_resource_name(value: str, replace_with: str = "-") -> str:
     """
     Converts a given string to a valid resource name by stripping
     all characters that are not alphanumeric.

{cloudbridge-4.1.0 → cloudbridge-4.2.0}/cloudbridge/base/middleware.py

@@ -1,4 +1,5 @@
 import logging
+from typing import Any
 
 from pyeventsystem.middleware import dispatch as pyevent_dispatch
 from pyeventsystem.middleware import intercept
@@ -19,12 +20,14 @@ class EventDebugLoggingMiddleware(object):
     access keys.
     """
     @observe(event_pattern="*", priority=100)
-    def pre_log_event(self, event_args, *args, **kwargs):
+    def pre_log_event(self, event_args: dict[str, Any],
+                      *args: Any, **kwargs: Any) -> None:
         log.debug("Event: {0}, args: {1} kwargs: {2}".format(
             event_args.get("event"), args, kwargs))
 
     @observe(event_pattern="*", priority=4900)
-    def post_log_event(self, event_args, *args, **kwargs):
+    def post_log_event(self, event_args: dict[str, Any],
+                       *args: Any, **kwargs: Any) -> None:
         log.debug("Event: {0}, result: {1}".format(
             event_args.get("event"), event_args.get("result")))
 
@@ -34,7 +37,8 @@ class ExceptionWrappingMiddleware(object):
     Wraps all unhandled exceptions in cloudbridge exceptions.
     """
     @intercept(event_pattern="*", priority=1050)
-    def wrap_exception(self, event_args, *args, **kwargs):
+    def wrap_exception(self, event_args: dict[str, Any],
+                       *args: Any, **kwargs: Any) -> Any:
         next_handler = event_args.pop("next_handler")
         if not next_handler:
             return

{cloudbridge-4.1.0 → cloudbridge-4.2.0}/cloudbridge/base/provider.py

@@ -5,13 +5,17 @@ import logging
 import os
 from configparser import ConfigParser
 from os.path import expanduser
+from typing import Any
+from typing import cast
 
+from pyeventsystem.middleware import MiddlewareManager
 from pyeventsystem.middleware import SimpleMiddlewareManager
 
 from ..base.middleware import ExceptionWrappingMiddleware
 from ..interfaces import CloudProvider
 from ..interfaces.exceptions import ProviderConnectionException
 from ..interfaces.resources import Configuration
+from ..interfaces.resources import PlacementZone
 
 log = logging.getLogger(__name__)
 
@@ -28,11 +32,11 @@ CloudBridgeConfigLocations.append(UserConfigPath)
 
 class BaseConfiguration(Configuration):
 
-    def __init__(self, user_config):
+    def __init__(self, user_config: dict[str, Any]) -> None:
         self.update(user_config)
 
     @property
-    def default_result_limit(self):
+    def default_result_limit(self) -> int:
         """
         Get the maximum number of results to return for a
         list method
@@ -42,28 +46,30 @@ class BaseConfiguration(Configuration):
         """
         log.debug("Maximum number of results for list methods %s",
                   DEFAULT_RESULT_LIMIT)
-        return self.get('default_result_limit', DEFAULT_RESULT_LIMIT)
+        return cast(int, self.get('default_result_limit', DEFAULT_RESULT_LIMIT))
 
     @property
-    def default_wait_timeout(self):
+    def default_wait_timeout(self) -> int:
         """
         Gets the default wait timeout for LifeCycleObjects.
         """
         log.debug("Default wait timeout for LifeCycleObjects %s",
                   DEFAULT_WAIT_TIMEOUT)
-        return self.get('default_wait_timeout', DEFAULT_WAIT_TIMEOUT)
+        return cast(int, self.get('default_wait_timeout',
+                                  DEFAULT_WAIT_TIMEOUT))
 
     @property
-    def default_wait_interval(self):
+    def default_wait_interval(self) -> int:
         """
         Gets the default wait interval for LifeCycleObjects.
         """
         log.debug("Default wait interfal for LifeCycleObjects %s",
                   DEFAULT_WAIT_INTERVAL)
-        return self.get('default_wait_interval', DEFAULT_WAIT_INTERVAL)
+        return cast(int, self.get('default_wait_interval',
+                                  DEFAULT_WAIT_INTERVAL))
 
     @property
-    def debug_mode(self):
+    def debug_mode(self) -> bool:
         """
         A flag indicating whether CloudBridge is in debug mode. Setting
         this to True will cause the underlying provider's debug
@@ -75,59 +81,63 @@ class BaseConfiguration(Configuration):
         :rtype: ``bool``
         :return: Whether debug mode is on.
         """
-        return self.get('cb_debug', os.environ.get('CB_DEBUG', False))
+        return cast(bool, self.get('cb_debug',
+                                   os.environ.get('CB_DEBUG', False)))
 
 
 class BaseCloudProvider(CloudProvider):
-    def __init__(self, config):
+
+    PROVIDER_ID: str
+
+    def __init__(self, config: dict[str, Any]) -> None:
         self._config = BaseConfiguration(config)
         self._config_parser = ConfigParser()
         self._config_parser.read(CloudBridgeConfigLocations)
         self._middleware = SimpleMiddlewareManager()
         self.add_required_middleware()
-        self._region_name = None
-        self._zone_name = None
+        self._region_name: str | None = None
+        self._zone_name: str | None = None
 
     @property
-    def region_name(self):
+    def region_name(self) -> str | None:
         return self._region_name
 
     @property
-    def zone_name(self):
+    def zone_name(self) -> str | None:
         if not self._zone_name:
             region = self.compute.regions.current
-            zone = region.default_zone
+            zone = region.default_zone if region else None
             self._zone_name = zone.name if zone else None
             return self._zone_name
         else:
             try:
                 zone_dict = ast.literal_eval(self._zone_name)
                 if isinstance(zone_dict, dict):
-                    return zone_dict
+                    return cast("str | None", zone_dict)
             except (ValueError, SyntaxError):
                 pass
             return self._zone_name
 
     @property
-    def config(self):
+    def config(self) -> Configuration:
         return self._config
 
     @property
-    def name(self):
+    def name(self) -> str:
         return str(self.__class__.__name__)
 
     @property
-    def middleware(self):
+    def middleware(self) -> MiddlewareManager:
         return self._middleware
 
-    def add_required_middleware(self):
+    def add_required_middleware(self) -> None:
         """
         Adds common middleware that is essential for cloudbridge to function.
         Any other extra middleware can be added through the provider factory.
         """
         self.middleware.add(ExceptionWrappingMiddleware())
 
-    def authenticate(self):
+    def authenticate(self) -> bool:
         """
         A basic implementation which simply runs a low impact command to
         check whether cloud credentials work. Providers should override with
@@ -142,7 +152,7 @@ class BaseCloudProvider(CloudProvider):
             raise ProviderConnectionException(
                 "Authentication with cloud provider failed: %s" % (e,))
 
-    def clone(self, zone=None):
+    def clone(self, zone: PlacementZone | None = None) -> CloudProvider:
         cloned_config = self.config.copy()
         cloned_provider = self.__class__(cloned_config)
         if zone:
@@ -150,11 +160,11 @@ class BaseCloudProvider(CloudProvider):
             cloned_provider._zone_name = zone.name
         return cloned_provider
 
-    def _deepgetattr(self, obj, attr):
+    def _deepgetattr(self, obj: object, attr: str) -> Any:
         """Recurses through an attribute chain to get the ultimate value."""
         return functools.reduce(getattr, attr.split('.'), obj)
 
-    def has_service(self, service_type):
+    def has_service(self, service_type: str) -> bool:
         """
         Checks whether this provider supports a given service.
 
@@ -178,7 +188,8 @@ class BaseCloudProvider(CloudProvider):
                  service_type)
         return False
 
-    def _get_config_value(self, key, default_value=None):
+    def _get_config_value(self, key: str,
+                          default_value: Any = None) -> Any:
         """
         A convenience method to extract a configuration value.