$ nameko run service

starting services: payment
Connected to amqp://guest:**@127.0.0.1:5672//

# config.yaml

AMQP_URI: "amqp://guest:guest@localhost:5672"
WEB_SERVER_ADDRESS: "0.0.0.0:8000"

# payment.service.py

from nameko.rpc import rpc


class PaymentService:

    name = "payment"
        
    @rpc
    def pay_order(self, order_id):
        """Business logic to pay orders."""
      

from nameko.standalone.rpc import ServiceRpcProxy


AMQP_URI = "amqp://guest:guest@localhost:5672"


class NonNamekoService:

    def process_order(self, order_id):
        # ...

        with ServiceRpcProxy("payment", AMQP_URI) as rpc:
            rpc.pay_order(order_id)

        # ...

# messaging.service.py

from nameko.events import event_handler


PAYMENT_SERVICE_NAME = "payment"
PAYMENT_TAKEN_EVENT = "payment_taken"


class MessagingService:

    name = "messaging"
    
    @event_handler(PAYMENT_SERVICE_NAME, PAYMENT_TAKEN_EVENT)
    def send_order_receipt_email(self, payload):
        #  handler_type = "service_pool"

        order = payload["order"]
        project = payload["project"]
        payment_method = payload["payment_method"]
        paid_by = payload["paid_by"]
        
        # ...
      

worker = Service()
worker.other_rpc = worker.other_rpc.get_dependency()
worker.method()
del worker

# service.py

from nameko.dependency_providers import Config
from nameko.rpc import rpc


class PaymentService:

    name = "payment"

    config = Config()

    @rpc
    def healthcheck(self):
        amqp_uri = self.config.get("AMQP_URI")
        return "OK"

    @rpc
    def confirm_payment_intent(self, payment_intent_id):
        # ...

    @rpc
    def get_viewer_scores(self, streaming_session_id, email):
        # ...

    @rpc
    def get_multiple_transactions_by_id(self, transaction_ids):
        # ...

PAYMENT_TAKEN_EVENT = "payment_taken"

class TaxCalculationError(Exception):
    pass

def validate_country_format(country):
    # ...

from nameko_sqlalchemy import DatabaseSession

class PaymentMethod(marshmallow.Schema):
    # ...

class PaymentService():

    name = "payment"
    
    db = Database()
    stripe = Stripe()

    @rpc
    def list_payment_methods(self, customer_id):
    	# ...
    	return schemas.dump(
          schemas.PaymentMethod, payment_methods, many=True
        )

self.db.transactions.get_by_order_id

self.stripe.list_payment_methods

self.db.NotFound
remote_err.NotFound
http_err.NotFound

schemas.dump
schemas.Payment

# admin_facade.schemas.py

# Responsible of the service messages serializations (in/out)
# Defines the (data) contract with the app that it serves


from marshmallow import fields, Schema


class Payment(Schema):
  
    """Contract with the Admin CP application."""

    id = fields.Str()
    status = fields.Str(required=True)
    # ...


def dump(schema_cls, data, strict=True, **schema_kwargs):
    schema = schema_cls(strict=strict, **schema_kwargs)
    return schema.dump(data).data

# admin_facade.http_handlers.py

import json

from werkzeug.wrappers import Response


JSON_CONTENT_TYPE = "application/json"


def json_response(data, status=200, content_type=JSON_CONTENT_TYPE):
    return Response(
        response=json.dumps(data),
        content_type=content_type,
        status=status
    )

# admin_facade.http_errors.py

class HttpError(Exception):

    status_code = 500

    def __init__(self, description):
        self.payload = description
        super().__init__(self.payload)


class BadRequest(HttpError):

    status_code = 400


class NotFound(HttpError):

    status_code = 404

# admin_facade.remote_errors.py

from nameko.exceptions import registry


def remote_error(exc_path):

    def _wrapper(exc_type):
        registry[exc_path] = exc_type
        return exc_type

    return _wrapper


@remote_error('payment.exceptions.BadRequest')
class BadRequest(Exception):
    pass


@remote_error('payment.exceptions.NotFound')
class NotFound(Exception):
    pass
  

@remote_error('payment.exceptions.TransactionNotFound')
class TransactionNotFound(Exception):
    pass

# admin_facade.service.py

from nameko.rpc import RpcProxy
from nameko.web.handlers import http
from nameko_sentry import SentryReporter

from . import http_errors as http_err  # Namespaces
from . import remote_errors as remote_err
from . import schemas
from .http_handlers import json_response  # Widely used / not ambiguous


PAYMENT_SERVICE_NAME = "payment"


class AdminFacade:

    name = "admin-facade"
    
    # Dependencies
    payment_service = RpcProxy(PAYMENT_SERVICE_NAME)
    sentry = SentryReporter()
    
    # ...

    # ...
    
    @http(
        "POST",
        "/projects/<int:project_id>/orders/<int:order_id>"
    )
    def confirm_order_payment(self, request, project_id, order_id):
      	# ...
      	
      	try:
      	    payment = self.payment_service.pay_order(order_id)
        # Translate remote "expected exceptions"
        except remote_err.BadRequest as err:
            raise http_err.BadRequest(err.args[0])
        except remote_err.NotFound as err:
            raise http_err.NotFound(err.args[0])
        except remote_err.TransactionNotFound as err:
            # Translate to a different HTTP error
            raise http_err.BadRequest(err.args[0])
        
        # Endpoint does not know about formatting/serializing the response
        response = schemas.dump(schemas.Payment, payment)

        return json_response(response)
      

# payment.dependencies.db.py

from nameko_sqlalchemy import DatabaseSession

from .. import models  # The dependency uses the SQLAlchemy models


# Logic related to the dependency lives in the dependency module / package:
#   - Constants, exceptions, functions...

# Service endpoints:
#   - Do not know about SQL-related objects/actions
#   - Interact with the DB objects through "collections"
 

# Dependency exceptions live in the dependency namespace
class NotFound(LookupError):
    pass

# ...

class Transaction:
  
    """Collection class to provide an interface for the DB.
    
    Provide an abstraction (contract) between the service and the dependency.
    """

    name = "transactions"
    model = models.Transaction
    
    def __init__(self, session):
        self.session = session

    def get_by_order_id(self, order_id):
        """Logic to interact with the DB to get the transaction.
        
        Raises `NotFound`
        
        "Intelligent endpoints", like services, not just CRUD operations.
        """

# ...

class DatabaseWrapper:

    # Services access the dependency expcetions through the wrapper object
    NotFound = NotFound

    def __init__(self, session, collections):
        for collection in collections:
            setattr(self, collection.name, collection(session))


class Database(DatabaseSession):
  
    """Database dependency provider.
    
    Wrapper around the Nameko SQLAlchemy dependeny provider.
    """

    def __init__(self):
        super().__init__(models.DeclarativeBase)

    def get_dependency(self, worker_ctx):
        # A `DatabaseWrapper` instance will be injected to the service
        # as a dependency.
        return DatabaseWrapper(
            session=super().get_dependency(worker_ctx),
            collections=[Transaction]
        )

# payment.schemas.py


# Responsible of the service messages serializations (in/out)
# Defines the (data) contract with the rest of the platform services


from marshmallow import fields, Schema


class Payment(Schema):
  
    """Contract with the rest of the platform services."""

    id = fields.Str()
    status = fields.Str(required=True)
    # ...


def dump(schema_cls, data, strict=True, **schema_kwargs):
    schema = schema_cls(strict=strict, **schema_kwargs)
    return schema.dump(data).data

# payment.exceptions.py

# Remote exceptions are as explicit and simple as possible:
#   - Exception name: specific and explicit
#   - Exception argument: error message (string)


class NotFound(Exception):
    pass


class BadRequest(Exception):
    pass


class TransactionNotFound(Exception):
    pass

# payment.states.py

from enum import auto, Enum


class AutoName(Enum):

    def _generate_next_value_(name, start, count, last_values):
        return name.lower()


class PaymentState(AutoName):

    """Used to define all the states a Payment can be in.
    
    Encapsulate the states in the `PaymentState` class and 
    all the logic around them in the `states` module.
    """

    AWAITING_CONFIRM = auto()
    PAID = auto()
    # ...

# payment.service.py

from nameko.events import EventDispatcher
from nameko.rpc import rpc
from nameko_sentry import SentryReporter

from .dependencies.db import Database
from .dependencies.nameko_stripe import Stripe
from . import exceptions as exc  # Namespaces
from . import schemas
from . import states


PAYMENT_TAKEN_EVENT = "payment_taken"


class PaymentService:

    name = "payment"
    
    # Dependencies
    db = Database()
    dispatch = EventDispatcher()
    sentry = SentryReporter()
    stripe = Stripe()

    # ...

    # ...  
    
    @rpc
    def pay_order(self, order_id):
        try:
            # Endpoint does not know about SQL-related objects/actions
            # Interacts with the DB objects through "collections"
            transaction = self.db.transactions.get_by_order_id(order_id)
        # Translate dependency "expected exceptions"
        # Services provide their own exception (contract)
        except self.db.NotFound as err:
            message = f"Unable to pay order ID {order_id}."
            raise exc.TransactionNotFound(message)

        try:
            payment_methods = self.stripe.list_payment_methods(customer_id)
        # Translate dependency "expected exceptions"
        # Services provide their own exception (contract)
        except self.stripe.NotFound as err:
            raise exc.NotFound(err.args[0])
        except self.stripe.PaymentMethodError as err:
            raise exc.BadRequest(err.args[0])

        # ...

        # ...
        
        # Compare `transaction` DB collection with payment state
        if transaction.state is states.PaymentState.PAID:
            raise exc.BadRequest(f"Order {order_id} is already paid.")

        try:
            payment = self.stripe.make_payment(
                customer_id, order_id, payment_method_id
            )
        # Translate dependency "expected exceptions"
        # Services provide their own exception (contract)
        except self.stripe.NotFound as err:
            raise exc.NotFound(err.args[0])

        # Dispatch an event (async) with the payment info
        event_body = {
            "order": {"id": order_id},
            "payment_method": {"id": payment_method_id},
            "project": {"id": transaction.project_id},
            "paid_by": {"id": user_id},
        }
        self.dispatch(PAYMENT_TAKEN_EVENT, event_body)
        
        # Endpoint does not know about formatting/serializing
        # the response
        return schemas.dump(schemas.Payment, payment)

# messaging.service.py

from nameko.events import event_handler
# Replace with the Nameko "email_provider" dependency of your choice
from nameko_email_provider import EmailProvider
from nameko_sentry import SentryReporter


PAYMENT_SERVICE_NAME = "payment"
PAYMENT_TAKEN_EVENT = "payment_taken"


class MessagingService:

    name = "messaging"
    
    # Dependencies
    email_provider = EmailProvider()
    sentry = SentryReporter()
    
    # ...

    # ...
    
    @event_handler(PAYMENT_SERVICE_NAME, PAYMENT_TAKEN_EVENT)
    def send_order_paid_confirmation_email(self, payload):
        """Create and send order paid confirmation email.
        
        Not just a dumb and generic "send email" endpoint.
        It contains the logic to generate and send order paid 
        confirmation emails. 
        """
        order = payload["order"]
        project = payload["project"]
        payment_method = payload["payment_method"]
        paid_by = payload["paid_by"]
        
        # ...
        
        self._send_email(recipients, subject, content)
      
    def _send_email(self, recipients, subject, content, **kwargs):
        """Use the email provider dependency to send out emails.
        
        Helper method that acts as a wrapper around the email_provider
        dependency. Another approach could be a new "dependency wrapper".
        Reused by all the endpoints in the service that need to
        send emails.
        """
        # ...
        self.email_provider.send(
            recipients, subject, content, sender, bcc=bcc
        )