moto 4.1.9.dev13__tar.gz → 4.1.9.dev14__tar.gz

{moto-4.1.9.dev13/moto.egg-info → moto-4.1.9.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 4.1.9.dev13
+Version: 4.1.9.dev14
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: "spulec@gmail.com"

{moto-4.1.9.dev13 → moto-4.1.9.dev14}/moto/__init__.py

@@ -195,7 +195,7 @@ mock_all = MockAll
 # logging.getLogger('boto').setLevel(logging.CRITICAL)
 
 __title__ = "moto"
-__version__ = "4.1.9.dev13"
+__version__ = "4.1.9.dev14"
 
 
 try:

{moto-4.1.9.dev13 → moto-4.1.9.dev14}/moto/sdb/exceptions.py

@@ -1,4 +1,5 @@
 """Exceptions raised by the sdb service."""
+from typing import Any
 from moto.core.exceptions import RESTError
 
 
@@ -18,7 +19,7 @@ SDB_ERROR = """<?xml version="1.0"?>
 class InvalidParameterError(RESTError):
     code = 400
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Any):
         kwargs.setdefault("template", "sdb_error")
         self.templates["sdb_error"] = SDB_ERROR
         kwargs["error_type"] = "InvalidParameterValue"
@@ -28,7 +29,7 @@ class InvalidParameterError(RESTError):
 class InvalidDomainName(InvalidParameterError):
     code = 400
 
-    def __init__(self, domain_name):
+    def __init__(self, domain_name: str):
         super().__init__(
             message=f"Value ({domain_name}) for parameter DomainName is invalid. "
         )
@@ -37,7 +38,7 @@ class InvalidDomainName(InvalidParameterError):
 class UnknownDomainName(RESTError):
     code = 400
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Any):
         kwargs.setdefault("template", "sdb_error")
         self.templates["sdb_error"] = SDB_ERROR
         kwargs["error_type"] = "NoSuchDomain"

{moto-4.1.9.dev13 → moto-4.1.9.dev14}/moto/sdb/models.py

@@ -1,23 +1,24 @@
 """SimpleDBBackend class with methods for supported APIs."""
 import re
 from collections import defaultdict
-from moto.core import BaseBackend, BackendDict, BaseModel
 from threading import Lock
+from typing import Any, Dict, List, Iterable, Optional
 
+from moto.core import BaseBackend, BackendDict, BaseModel
 from .exceptions import InvalidDomainName, UnknownDomainName
 
 
 class FakeItem(BaseModel):
-    def __init__(self):
-        self.attributes = []
+    def __init__(self) -> None:
+        self.attributes: List[Dict[str, Any]] = []
         self.lock = Lock()
 
-    def get_attributes(self, names):
+    def get_attributes(self, names: Optional[List[str]]) -> List[Dict[str, Any]]:
         if not names:
             return self.attributes
         return [attr for attr in self.attributes if attr["name"] in names]
 
-    def put_attributes(self, attributes):
+    def put_attributes(self, attributes: List[Dict[str, Any]]) -> None:
         # Replacing attributes involves quite a few loops
         # Lock this, so we know noone else touches this list while we're operating on it
         with self.lock:
@@ -26,56 +27,58 @@ class FakeItem(BaseModel):
                     self._remove_attributes(attr["name"])
                 self.attributes.append(attr)
 
-    def _remove_attributes(self, name):
+    def _remove_attributes(self, name: str) -> None:
         self.attributes = [attr for attr in self.attributes if attr["name"] != name]
 
 
 class FakeDomain(BaseModel):
-    def __init__(self, name):
+    def __init__(self, name: str):
         self.name = name
-        self.items = defaultdict(FakeItem)
+        self.items: Dict[str, FakeItem] = defaultdict(FakeItem)
 
-    def get(self, item_name, attribute_names):
+    def get(self, item_name: str, attribute_names: List[str]) -> List[Dict[str, Any]]:
         item = self.items[item_name]
         return item.get_attributes(attribute_names)
 
-    def put(self, item_name, attributes):
+    def put(self, item_name: str, attributes: List[Dict[str, Any]]) -> None:
         item = self.items[item_name]
         item.put_attributes(attributes)
 
 
 class SimpleDBBackend(BaseBackend):
-    def __init__(self, region_name, account_id):
+    def __init__(self, region_name: str, account_id: str):
         super().__init__(region_name, account_id)
-        self.domains = dict()
+        self.domains: Dict[str, FakeDomain] = dict()
 
-    def create_domain(self, domain_name):
+    def create_domain(self, domain_name: str) -> None:
         self._validate_domain_name(domain_name)
         self.domains[domain_name] = FakeDomain(name=domain_name)
 
-    def list_domains(self):
+    def list_domains(self) -> Iterable[str]:
         """
         The `max_number_of_domains` and `next_token` parameter have not been implemented yet - we simply return all domains.
         """
         return self.domains.keys()
 
-    def delete_domain(self, domain_name):
+    def delete_domain(self, domain_name: str) -> None:
         self._validate_domain_name(domain_name)
         # Ignore unknown domains - AWS does the same
         self.domains.pop(domain_name, None)
 
-    def _validate_domain_name(self, domain_name):
+    def _validate_domain_name(self, domain_name: str) -> None:
         # Domain Name needs to have at least 3 chars
         # Can only contain characters: a-z, A-Z, 0-9, '_', '-', and '.'
         if not re.match("^[a-zA-Z0-9-_.]{3,}$", domain_name):
             raise InvalidDomainName(domain_name)
 
-    def _get_domain(self, domain_name):
+    def _get_domain(self, domain_name: str) -> FakeDomain:
         if domain_name not in self.domains:
             raise UnknownDomainName()
         return self.domains[domain_name]
 
-    def get_attributes(self, domain_name, item_name, attribute_names):
+    def get_attributes(
+        self, domain_name: str, item_name: str, attribute_names: List[str]
+    ) -> List[Dict[str, Any]]:
         """
         Behaviour for the consistent_read-attribute is not yet implemented
         """
@@ -83,7 +86,9 @@ class SimpleDBBackend(BaseBackend):
         domain = self._get_domain(domain_name)
         return domain.get(item_name, attribute_names)
 
-    def put_attributes(self, domain_name, item_name, attributes):
+    def put_attributes(
+        self, domain_name: str, item_name: str, attributes: List[Dict[str, Any]]
+    ) -> None:
         """
         Behaviour for the expected-attribute is not yet implemented.
         """

{moto-4.1.9.dev13 → moto-4.1.9.dev14}/moto/sdb/responses.py

@@ -1,33 +1,33 @@
 from moto.core.responses import BaseResponse
-from .models import sdb_backends
+from .models import sdb_backends, SimpleDBBackend
 
 
 class SimpleDBResponse(BaseResponse):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(service_name="sdb")
 
     @property
-    def sdb_backend(self):
+    def sdb_backend(self) -> SimpleDBBackend:
         return sdb_backends[self.current_account][self.region]
 
-    def create_domain(self):
+    def create_domain(self) -> str:
         domain_name = self._get_param("DomainName")
         self.sdb_backend.create_domain(domain_name=domain_name)
         template = self.response_template(CREATE_DOMAIN_TEMPLATE)
         return template.render()
 
-    def delete_domain(self):
+    def delete_domain(self) -> str:
         domain_name = self._get_param("DomainName")
         self.sdb_backend.delete_domain(domain_name=domain_name)
         template = self.response_template(DELETE_DOMAIN_TEMPLATE)
         return template.render()
 
-    def list_domains(self):
+    def list_domains(self) -> str:
         domain_names = self.sdb_backend.list_domains()
         template = self.response_template(LIST_DOMAINS_TEMPLATE)
         return template.render(domain_names=domain_names, next_token=None)
 
-    def get_attributes(self):
+    def get_attributes(self) -> str:
         domain_name = self._get_param("DomainName")
         item_name = self._get_param("ItemName")
         attribute_names = self._get_multi_param("AttributeName.")
@@ -39,7 +39,7 @@ class SimpleDBResponse(BaseResponse):
         template = self.response_template(GET_ATTRIBUTES_TEMPLATE)
         return template.render(attributes=attributes)
 
-    def put_attributes(self):
+    def put_attributes(self) -> str:
         domain_name = self._get_param("DomainName")
         item_name = self._get_param("ItemName")
         attributes = self._get_list_prefix("Attribute")

{moto-4.1.9.dev13 → moto-4.1.9.dev14}/moto/server.py

@@ -3,6 +3,7 @@ import os
 import signal
 import sys
 import warnings
+from typing import Any, List, Optional
 
 from werkzeug.serving import run_simple
 
@@ -15,11 +16,11 @@ from moto.moto_server.threaded_moto_server import (  # noqa # pylint: disable=un
 )
 
 
-def signal_handler(signum, frame):  # pylint: disable=unused-argument
+def signal_handler(signum: Any, frame: Any) -> None:  # pylint: disable=unused-argument
     sys.exit(0)
 
 
-def main(argv=None):
+def main(argv: Optional[List[str]] = None) -> None:
     argv = argv or sys.argv[1:]
     parser = argparse.ArgumentParser()
 
@@ -79,9 +80,9 @@ def main(argv=None):
 
     # Wrap the main application
     main_app = DomainDispatcherApplication(create_backend_app, service=args.service)
-    main_app.debug = True
+    main_app.debug = True  # type: ignore
 
-    ssl_context = None
+    ssl_context: Any = None
     if args.ssl_key and args.ssl_cert:
         ssl_context = (args.ssl_cert, args.ssl_key)
     elif args.ssl:

{moto-4.1.9.dev13 → moto-4.1.9.dev14}/moto/servicediscovery/exceptions.py

@@ -3,20 +3,20 @@ from moto.core.exceptions import JsonRESTError
 
 
 class OperationNotFound(JsonRESTError):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__("OperationNotFound", "")
 
 
 class NamespaceNotFound(JsonRESTError):
-    def __init__(self, ns_id):
+    def __init__(self, ns_id: str):
         super().__init__("NamespaceNotFound", f"{ns_id}")
 
 
 class ServiceNotFound(JsonRESTError):
-    def __init__(self, ns_id):
+    def __init__(self, ns_id: str):
         super().__init__("ServiceNotFound", f"{ns_id}")
 
 
 class ConflictingDomainExists(JsonRESTError):
-    def __init__(self, vpc_id):
+    def __init__(self, vpc_id: str):
         super().__init__("ConflictingDomainExists", f"{vpc_id}")

{moto-4.1.9.dev13 → moto-4.1.9.dev14}/moto/servicediscovery/models.py

@@ -1,4 +1,5 @@
 import string
+from typing import Any, Dict, Iterable, List, Optional
 
 from moto.core import BaseBackend, BackendDict, BaseModel
 from moto.core.utils import unix_time
@@ -13,7 +14,7 @@ from .exceptions import (
 )
 
 
-def random_id(size):
+def random_id(size: int) -> str:
     return "".join(
         [random.choice(string.ascii_lowercase + string.digits) for _ in range(size)]
     )
@@ -22,17 +23,16 @@ def random_id(size):
 class Namespace(BaseModel):
     def __init__(
         self,
-        account_id,
-        region,
-        name,
-        ns_type,
-        creator_request_id,
-        description,
-        dns_properties,
-        http_properties,
-        vpc=None,
+        account_id: str,
+        region: str,
+        name: str,
+        ns_type: str,
+        creator_request_id: str,
+        description: str,
+        dns_properties: Dict[str, Any],
+        http_properties: Dict[str, Any],
+        vpc: Optional[str] = None,
     ):
-        super().__init__()
         self.id = f"ns-{random_id(20)}"
         self.arn = f"arn:aws:servicediscovery:{region}:{account_id}:namespace/{self.id}"
         self.name = name
@@ -45,7 +45,7 @@ class Namespace(BaseModel):
         self.created = unix_time()
         self.updated = unix_time()
 
-    def to_json(self):
+    def to_json(self) -> Dict[str, Any]:
         return {
             "Arn": self.arn,
             "Id": self.id,
@@ -65,31 +65,30 @@ class Namespace(BaseModel):
 class Service(BaseModel):
     def __init__(
         self,
-        account_id,
-        region,
-        name,
-        namespace_id,
-        description,
-        creator_request_id,
-        dns_config,
-        health_check_config,
-        health_check_custom_config,
-        service_type,
+        account_id: str,
+        region: str,
+        name: str,
+        namespace_id: str,
+        description: str,
+        creator_request_id: str,
+        dns_config: Dict[str, Any],
+        health_check_config: Dict[str, Any],
+        health_check_custom_config: Dict[str, int],
+        service_type: str,
     ):
-        super().__init__()
         self.id = f"srv-{random_id(8)}"
         self.arn = f"arn:aws:servicediscovery:{region}:{account_id}:service/{self.id}"
         self.name = name
         self.namespace_id = namespace_id
         self.description = description
         self.creator_request_id = creator_request_id
-        self.dns_config = dns_config
+        self.dns_config: Optional[Dict[str, Any]] = dns_config
         self.health_check_config = health_check_config
         self.health_check_custom_config = health_check_custom_config
         self.service_type = service_type
         self.created = unix_time()
 
-    def update(self, details):
+    def update(self, details: Dict[str, Any]) -> None:
         if "Description" in details:
             self.description = details["Description"]
         if "DnsConfig" in details:
@@ -104,7 +103,7 @@ class Service(BaseModel):
         if "HealthCheckConfig" in details:
             self.health_check_config = details["HealthCheckConfig"]
 
-    def to_json(self):
+    def to_json(self) -> Dict[str, Any]:
         return {
             "Arn": self.arn,
             "Id": self.id,
@@ -121,7 +120,7 @@ class Service(BaseModel):
 
 
 class Operation(BaseModel):
-    def __init__(self, operation_type, targets):
+    def __init__(self, operation_type: str, targets: Dict[str, str]):
         super().__init__()
         self.id = f"{random_id(32)}-{random_id(8)}"
         self.status = "SUCCESS"
@@ -130,7 +129,7 @@ class Operation(BaseModel):
         self.updated = unix_time()
         self.targets = targets
 
-    def to_json(self, short=False):
+    def to_json(self, short: bool = False) -> Dict[str, Any]:
         if short:
             return {"Id": self.id, "Status": self.status}
         else:
@@ -147,20 +146,26 @@ class Operation(BaseModel):
 class ServiceDiscoveryBackend(BaseBackend):
     """Implementation of ServiceDiscovery APIs."""
 
-    def __init__(self, region_name, account_id):
+    def __init__(self, region_name: str, account_id: str):
         super().__init__(region_name, account_id)
-        self.operations = dict()
-        self.namespaces = dict()
-        self.services = dict()
+        self.operations: Dict[str, Operation] = dict()
+        self.namespaces: Dict[str, Namespace] = dict()
+        self.services: Dict[str, Service] = dict()
         self.tagger = TaggingService()
 
-    def list_namespaces(self):
+    def list_namespaces(self) -> Iterable[Namespace]:
         """
         Pagination or the Filters-parameter is not yet implemented
         """
         return self.namespaces.values()
 
-    def create_http_namespace(self, name, creator_request_id, description, tags):
+    def create_http_namespace(
+        self,
+        name: str,
+        creator_request_id: str,
+        description: str,
+        tags: List[Dict[str, str]],
+    ) -> str:
         namespace = Namespace(
             account_id=self.account_id,
             region=self.region_name,
@@ -179,13 +184,12 @@ class ServiceDiscoveryBackend(BaseBackend):
         )
         return operation_id
 
-    def _create_operation(self, op_type, targets):
+    def _create_operation(self, op_type: str, targets: Dict[str, str]) -> str:
         operation = Operation(operation_type=op_type, targets=targets)
         self.operations[operation.id] = operation
-        operation_id = operation.id
-        return operation_id
+        return operation.id
 
-    def delete_namespace(self, namespace_id):
+    def delete_namespace(self, namespace_id: str) -> str:
         if namespace_id not in self.namespaces:
             raise NamespaceNotFound(namespace_id)
         del self.namespaces[namespace_id]
@@ -194,12 +198,12 @@ class ServiceDiscoveryBackend(BaseBackend):
         )
         return operation_id
 
-    def get_namespace(self, namespace_id):
+    def get_namespace(self, namespace_id: str) -> Namespace:
         if namespace_id not in self.namespaces:
             raise NamespaceNotFound(namespace_id)
         return self.namespaces[namespace_id]
 
-    def list_operations(self):
+    def list_operations(self) -> Iterable[Operation]:
         """
         Pagination or the Filters-argument is not yet implemented
         """
@@ -211,23 +215,31 @@ class ServiceDiscoveryBackend(BaseBackend):
         }
         return self.operations.values()
 
-    def get_operation(self, operation_id):
+    def get_operation(self, operation_id: str) -> Operation:
         if operation_id not in self.operations:
             raise OperationNotFound()
         return self.operations[operation_id]
 
-    def tag_resource(self, resource_arn, tags):
+    def tag_resource(self, resource_arn: str, tags: List[Dict[str, str]]) -> None:
         self.tagger.tag_resource(resource_arn, tags)
 
-    def untag_resource(self, resource_arn, tag_keys):
+    def untag_resource(self, resource_arn: str, tag_keys: List[str]) -> None:
         self.tagger.untag_resource_using_names(resource_arn, tag_keys)
 
-    def list_tags_for_resource(self, resource_arn):
+    def list_tags_for_resource(
+        self, resource_arn: str
+    ) -> Dict[str, List[Dict[str, str]]]:
         return self.tagger.list_tags_for_resource(resource_arn)
 
     def create_private_dns_namespace(
-        self, name, creator_request_id, description, vpc, tags, properties
-    ):
+        self,
+        name: str,
+        creator_request_id: str,
+        description: str,
+        vpc: str,
+        tags: List[Dict[str, str]],
+        properties: Dict[str, Any],
+    ) -> str:
         for namespace in self.namespaces.values():
             if namespace.vpc == vpc:
                 raise ConflictingDomainExists(vpc)
@@ -253,8 +265,13 @@ class ServiceDiscoveryBackend(BaseBackend):
         return operation_id
 
     def create_public_dns_namespace(
-        self, name, creator_request_id, description, tags, properties
-    ):
+        self,
+        name: str,
+        creator_request_id: str,
+        description: str,
+        tags: List[Dict[str, str]],
+        properties: Dict[str, Any],
+    ) -> str:
         dns_properties = (properties or {}).get("DnsProperties", {})
         dns_properties["HostedZoneId"] = "hzi"
         namespace = Namespace(
@@ -277,16 +294,16 @@ class ServiceDiscoveryBackend(BaseBackend):
 
     def create_service(
         self,
-        name,
-        namespace_id,
-        creator_request_id,
-        description,
-        dns_config,
-        health_check_config,
-        health_check_custom_config,
-        tags,
-        service_type,
-    ):
+        name: str,
+        namespace_id: str,
+        creator_request_id: str,
+        description: str,
+        dns_config: Dict[str, Any],
+        health_check_config: Dict[str, Any],
+        health_check_custom_config: Dict[str, Any],
+        tags: List[Dict[str, str]],
+        service_type: str,
+    ) -> Service:
         service = Service(
             account_id=self.account_id,
             region=self.region_name,
@@ -304,21 +321,21 @@ class ServiceDiscoveryBackend(BaseBackend):
             self.tagger.tag_resource(service.arn, tags)
         return service
 
-    def get_service(self, service_id):
+    def get_service(self, service_id: str) -> Service:
         if service_id not in self.services:
             raise ServiceNotFound(service_id)
         return self.services[service_id]
 
-    def delete_service(self, service_id):
+    def delete_service(self, service_id: str) -> None:
         self.services.pop(service_id, None)
 
-    def list_services(self):
+    def list_services(self) -> Iterable[Service]:
         """
         Pagination or the Filters-argument is not yet implemented
         """
         return self.services.values()
 
-    def update_service(self, service_id, details):
+    def update_service(self, service_id: str, details: Dict[str, Any]) -> str:
         service = self.get_service(service_id)
         service.update(details=details)
         operation_id = self._create_operation(