def __init__(self, *args, **kwargs):
    """Create the server instance and add custom members.

    """
    super(BaseHTTPDServer, self).__init__(*args, **kwargs)
    self._pages = dict()
    self._default = 'index.html'
    self._policy = HTTPDPolicy()

def configure(self, **kwargs) -> None:
    """Configure the server.

        1. Configure policy....
        2. Add bakeries for dynamic HTML pages : The created pages are instances
        of the BaseResponseRecipe class.

        Optional keys in config dict:
            - "app": application name
            - "blacklist": list of blacklisted user agents
            - "blacklist_path": list of blacklisted URL paths
            - "banlist": file and duration of the temporary ban of addresses
            - "signed_url": signed URL path

        :param kwargs: (dict) Configuration dictionary.

        """
    self._policy.configure({'blacklist': kwargs.get('blacklist', None), 'blacklist_path': kwargs.get('blacklist_path', None), 'banlist': kwargs.get('banlist', None), 'signed_url': kwargs.get('signed_url', None)})
    self._create_pages(**kwargs)

def policy_check(self, path: str, query_string: str, headers, client_address: str) -> tuple:
    """Check the request against policies and return decision and response.

        Returned values are:
            - allowed: (bool) True if request is accepted
            - content: (bytes|None) Response body if rejected, otherwise None
            - status: (HTTPDStatus|None) Status if rejected, otherwise None
            - mime_type: (str|None) Mime of the body, None if the body is empty

        :param path: (str) Normalized URL path (without query).
        :param query_string: (str) Raw query string (without '?').
        :param headers: (Any) Request headers or environ. Must support ".get(...)".
        :param client_address: (str) The address of the client of the request.
        :return: (tuple) (allowed, content, status, mime_type)

        """
    return self._policy.check(path, query_string, headers, client_address)

def default(self):
    """Return the default page name, used when a URL ends with '/'."""
    return self._default

def page_bakery(self, page_name: str, headers: dict, events: dict, has_to_return_data: bool=False) -> tuple:
    """Return the page content and response status.

        This method bakes a page and optionally finalizes outgoing HTML.

        :param page_name: (str) Requested page name.
        :param headers: (dict) HTTP request headers.
        :param events: (dict) Event values (POST).
        :param has_to_return_data: (bool) True if returning data, False if returning HTML.
        :return: (tuple) (content, status)

        """
    content, status = HTTPDHandlerUtils.bakery(self._pages, page_name, headers, events, has_to_return_data)
    if has_to_return_data is False:
        content = self._policy.finalize_html(content)
    return (content, status)

def _create_pages(self, **kwargs):
    """To be overridden. Add bakeries for dynamic HTML pages.

        The created pages are instances of the BaseResponseRecipe class.
        Below is an example on how to override this method:

        :example:
        if app == "main":
            self._pages["index.html"] = BaseResponseRecipe("index.html", HTMLTree("Index"))
            self._pages["foo.html"] = WebResponseRecipe("foo.html", HTMLTree("Foo"))
        elif app == "test":
            self._pages["test.html"] = BaseResponseRecipe("test.html", HTMLTree("test"))

        """
    raise NotImplementedError