wiliot-certificate 4.4.2__py3-none-any.whl → 4.5.0__py3-none-any.whl

gw_certificate/ag/wlt_types_data.py

@@ -1,64 +0,0 @@
-from typing import Literal
-
-from gw_certificate.ag.wlt_types import WltPkt
-from gw_certificate.ag.ut_defines import *
-from gw_certificate.ag.wlt_types_ag import *
-
-DATA_DEFAULT_GROUP_ID = 0x020000
-
-class GenericPacket():
-    def __init__(self, payload=0, pkt_id=0):
-        self.payload = payload
-        self.pkt_id = pkt_id
-
-    def __eq__(self, other):
-        if isinstance(other, GenericV7):
-            return (
-                self.payload == other.payload and
-                self.pkt_id == other.pkt_id
-            )
-        return False
-
-    def dump(self):
-        string = bitstruct.pack("u160u32", self.payload, self.pkt_id)
-        return string.hex().upper()
-
-    def set(self, string):
-        d = bitstruct.unpack("u160u32", binascii.unhexlify(string))
-        self.payload = d[0]
-        self.pkt_id = d[1]
-
-
-class DataPacket(WltPkt):
-    def __init__(self, group_id=None, service_uuid:Literal["tag", "bridge"]='bridge', *args, **kwargs):
-        if service_uuid == 'bridge':
-            uuid_msb=HDR_DEFAULT_BRG_UUID_MSB
-            uuid_lsb=HDR_DEFAULT_BRG_UUID_LSB
-        else:
-            uuid_msb=HDR_DEFAULT_TAG_UUID_MSB
-            uuid_lsb=HDR_DEFAULT_TAG_UUID_LSB
-        if group_id is None:
-            group_id = DATA_DEFAULT_GROUP_ID
-        else:
-            group_id = group_id
-        super().__init__(hdr=Hdr(uuid_msb=uuid_msb, uuid_lsb=uuid_lsb, group_id=group_id), 
-                         data_hdr=DataHdr(uuid_msb=uuid_msb, uuid_lsb=uuid_lsb, 
-                                          group_id_minor=((group_id & 0xFFFF00) >> 8), group_id_major=(group_id & 0x0000FF)),
-                         generic=GenericPacket(), *args, **kwargs)
-        
-
-    def set(self, string):
-        if not string.startswith("1E16"):
-            string = "1E16" + string
-        self.hdr.set(string[0:14])
-        if self.hdr.group_id == DATA_DEFAULT_GROUP_ID:
-            self.generic = GenericPacket()
-            self.generic.set(string[14:62])
-        else:
-            super().set(string)
-            
-    def dump(self):
-        return super().dump()
-    
-    def __repr__(self) -> str:
-        return self.dump()

gw_certificate/api/extended_api.py

@@ -1,23 +0,0 @@
-
-from wiliot_api.edge.edge import EdgeClient
-
-
-class ExtendedEdgeClient(EdgeClient):
-    def __init__(self, api_key, owner_id, env='prod', region='us-east-2', cloud='',log_file=None, logger_=None):
-        # Support for GCP
-        region='us-central1' if cloud=='gcp' else region
-        super().__init__(api_key=api_key, owner_id=owner_id, env=env, region=region, cloud=cloud, log_file=log_file, logger_=logger_)
-                
-    def kick_gw_from_mqtt(self, gw_id):
-        path = f"gateway/{gw_id}/kick-mqtt-connection"
-        response = self._post(path, None)
-        return response
-    
-    def get_kong_logs(self, gw_id):
-        """
-        Only available under the certificate registration account
-        """
-        path = f"gateway/{gw_id}/auth-logs"
-
-        return self._get(path)
-        

gw_certificate/api_if/200/data.json

@@ -1,106 +0,0 @@
-{
-    "type": "object",
-    "properties": {
-        "gatewayId": {
-            "type": "string",
-            "maxLength": 36
-        },
-        "gatewayType": {
-            "type": "string"
-        },
-        "timestamp": {
-            "type": "number"
-        },
-        "packets": {
-            "allOf": [
-                        {
-                            "description": "Uncoupled Packet",
-                            "type": "array",
-                            "items": {
-                                "type": "object",
-                                "properties": {
-                                    "timestamp": {
-                                        "type": "number"
-                                    },
-                                    "sequenceId": {
-                                        "type": "number"
-                                    },
-                                    "rssi": {
-                                        "type": "number"
-                                    },
-                                    "payload": {
-                                        "type": "string"
-                                    }
-                                },
-                                "required": [
-                                    "timestamp",
-                                    "sequenceId",
-                                    "rssi",
-                                    "payload"
-                                ]
-                            }
-                        },
-                        {
-                            "description": "Coupled Packet",
-                            "type": "array",
-                            "items": {
-                                "type": "object",
-                                "properties": {
-                                    "bridgeId": {
-                                        "type": "string"
-                                    },
-                                    "timestamp": {
-                                        "type": "number"
-                                    },
-                                    "sequenceId": {
-                                        "type": "number"
-                                    },
-                                    "nfpkt": {
-                                        "type": "number"
-                                    },
-                                    "rssi": {
-                                        "type": "number"
-                                    },
-                                    "payload": {
-                                        "type": "string"
-                                    }
-                                },
-                                "dependentRequired":
-                                {
-                                    "nfpkt": ["rssi", "bridgeId"]
-                                },
-                                "required": ["timestamp", "sequenceId", "payload"]
-                            }
-                
-                        }
-            ]
-        }
-    },
-    "required": [
-        "gatewayId",
-        "gatewayType",
-        "timestamp",
-        "packets"
-    ],
-    "dependentSchemas": {
-        "location": {
-            "properties": {
-                "location": {
-                    "type": "object",
-                    "properties": {
-                        "lat": {
-                            "type": "number"
-                        },
-                        "lng": {
-                            "type": "number"
-                        }
-                    },
-                    "required": [
-                        "lat",
-                        "lng"
-                    ]
-                }
-            }
-        }
-    }
-}

gw_certificate/api_if/200/status.json

@@ -1,47 +0,0 @@
-{
-    "type": "object",
-    "properties": {
-        "gatewayId": {
-            "type": "string",
-            "maxLength": 36
-        },
-        "gatewayType": {
-            "type": "string"
-        },
-        "gatewayConf": {
-            "type": "object",
-            "properties": {
-                "apiVersion": {
-                    "type": "string",
-                    "enum": ["202"]
-                },
-                "interfaceChipSwVersion": {
-                    "type": "string"
-                },
-                "bleChipSwVersion": {
-                    "type": "string"
-                },
-                "additional": {
-                    "type": "object",
-                    "additionalProperties": true
-                }
-            },
-            "required": ["apiVersion", "interfaceChipSwVersion", "bleChipSwVersion"]
-        },
-        "tagMetadataCouplingSupported": {
-            "type": "boolean"
-        },
-        "downlinkSupported": {
-            "type": "boolean"
-        },
-        "bridgeOtaUpgradeSupported": {
-            "type": "boolean"
-        },
-        "fwUpgradeSupported": {
-            "type": "boolean"
-        }
-    },
-    "required": ["gatewayId", "gatewayType", "gatewayConf", "tagMetadataCouplingSupported", "downlinkSupported", "bridgeOtaUpgradeSupported", "fwUpgradeSupported"]
-}
-
-

gw_certificate/api_if/201/data.json

@@ -1,98 +0,0 @@
-{
-    "type": "object",
-    "properties": {
-        "gatewayId": {
-            "type": "string",
-            "maxLength": 36
-        },
-        "gatewayType": {
-            "type": "string"
-        },
-        "timestamp": {
-            "type": "number"
-        },
-        "packets": {
-            "type": "array",
-            "items": "object",
-            "oneOf": [
-                        {
-                            "description": "Uncoupled Packet",
-                            "type": "array",
-                            "items": {
-                                "type": "object",
-                                "properties": {
-                                    "timestamp": {
-                                        "type": "number"
-                                    },
-                                    "sequenceId": {
-                                        "type": "number"
-                                    },
-                                    "rssi": {
-                                        "type": "number"
-                                    },
-                                    "payload": {
-                                        "type": "string"
-                                    }
-                                },
-                                "required": ["timestamp", "sequenceId", "rssi", "payload"]
-                            }
-                        },
-                        {
-                            "description": "Coupled Packet",
-                            "type": "array",
-                            "items": {
-                                "type": "object",
-                                "properties": {
-                                    "bridgeId": {
-                                        "type": "string"
-                                    },
-                                    "timestamp": {
-                                        "type": "number"
-                                    },
-                                    "sequenceId": {
-                                        "type": "number"
-                                    },
-                                    "nfpkt": {
-                                        "type": "number"
-                                    },
-                                    "rssi": {
-                                        "type": "number"
-                                    },
-                                    "payload": {
-                                        "type": "string"
-                                    }
-                                },
-                                "required": ["nfpkt", "bridgeId", "timestamp", "sequenceId", "rssi", "payload"]
-                            }
-                        }
-            ]
-        }
-    },
-    "required": [
-        "gatewayId",
-        "gatewayType",
-        "timestamp",
-        "packets"
-    ],
-    "dependentSchemas": {
-        "location": {
-            "properties": {
-                "location": {
-                    "type": "object",
-                    "properties": {
-                        "lat": {
-                            "type": "number"
-                        },
-                        "lng": {
-                            "type": "number"
-                        }
-                    },
-                    "required": [
-                        "lat",
-                        "lng"
-                    ]
-                }
-            }
-        }
-    }
-}

gw_certificate/api_if/201/status.json

@@ -1,53 +0,0 @@
-{
-    "type": "object",
-    "properties": {
-        "gatewayId": {
-            "type": "string",
-            "maxLength": 36
-        },
-        "gatewayType": {
-            "type": "string"
-        },
-        "gatewayConf": {
-            "type": "object",
-            "properties": {
-                "apiVersion": {
-                    "type": "string",
-                    "enum": ["202"]
-                },
-                "gatewayVersion": {
-                    "type": "string"
-                },
-                "additional": {
-                    "type": "object",
-                    "additionalProperties": true
-                }
-            },
-            "oneOf":[
-                {"required": ["apiVersion", "gatewayVersion"]},
-                {"required": ["apiVersion", "interfaceChipSwVersion", "bleChipSwVersion"]}
-            ]
-        },
-        "tagMetadataCouplingSupported": {
-            "type": "boolean"
-        },
-        "downlinkSupported": {
-            "type": "boolean"
-        },
-        "bridgeOtaUpgradeSupported": {
-            "type": "boolean"
-        },
-        "fwUpgradeSupported": {
-            "type": "boolean"
-        },
-        "geoLocationSupport": {
-            "type": "boolean"
-        }
-    },
-    "oneOf": [
-        {"required": ["gatewayId", "gatewayType", "gatewayConf", "tagMetadataCouplingSupported", "downlinkSupported", "bridgeOtaUpgradeSupported", "fwUpgradeSupported", "geoLocationSupport"]},
-        {"required": ["gatewayID", "gatewayType", "gatewayConf", "tagMetadataCouplingSupported", "downlinkSupported", "bridgeOtaUpgradeSupported", "fwUpgradeSupported"]}
-    ]
-}
-
-

gw_certificate/api_if/205/logs.json

@@ -1,12 +0,0 @@
-{
-    "type": "object",
-    "properties": {
-        "gatewayLogs": {
-            "type": "array",
-            "items": {
-                "type": "string"
-            }
-        }
-    },
-    "required": ["gatewayLogs"]
-}

gw_certificate/api_if/api_validation.py

@@ -1,38 +0,0 @@
-import json
-from jsonschema import Draft202012Validator
-import pkg_resources
-from enum import Enum
-
-from gw_certificate.ag.ut_defines import GW_CONF, GW_API_VERSION
-from gw_certificate.common.debug import debug_print
-
-class MESSAGE_TYPES(Enum):
-    STATUS = "status"
-    DATA = "data"
-    LOGS = "logs"
-
-LATEST_API = "205"
-api_version = LATEST_API
-
-def validate_message(message_type: MESSAGE_TYPES, message: dict) -> tuple[bool, str]:
-    """
-    Validate MQTT message
-    :type message_type: MESSAGE_TYPES
-    :param message_type: MQTT message type
-    :type message: dict
-    :param message: MQTT Message
-    :return: tuple (bool, str)
-    """
-    global api_version
-
-    # NOTE When Connection test is not ran (using the -tests flag), default api_version is the latest
-    if message_type == MESSAGE_TYPES.STATUS:
-        api_version = message[GW_CONF][GW_API_VERSION]
-        debug_print(f'API version set as {api_version} according to the status message.')
-    json_path = pkg_resources.resource_filename(__name__, f"{api_version}/{message_type.value}.json")
-    with open(json_path) as f:
-        relevant_schema = json.load(f)
-    validator = Draft202012Validator(relevant_schema)
-    valid = validator.is_valid(message)
-    errors = [e for e in validator.iter_errors(message)]
-    return (valid, errors)

gw_certificate/api_if/gw_capabilities.py

@@ -1,54 +0,0 @@
-from dataclasses import dataclass
-from typing import Literal
-
-from gw_certificate.common.debug import debug_print
-from gw_certificate.interface.mqtt import Serialization
-from gw_certificate.ag.ut_defines import GW_CONF, GW_API_VERSION
-
-@dataclass
-class GWCapabilities:
-    tagMetadataCouplingSupported: bool = False
-    downlinkSupported: bool = False
-    bridgeOtaUpgradeSupported: bool = False
-    fwUpgradeSupported: bool = False
-    geoLocationSupport: bool = False
-    
-    @staticmethod
-    def get_capabilities():
-        return list(GWCapabilities.__dataclass_fields__.keys())
-    
-    def set_capability(self, capability, value:bool):
-        assert capability in GWCapabilities.get_capabilities(), f'{capability} is not a valid capability'
-        setattr(self, capability, value)
-
-class ConfigurationData():
-    """
-    Hold variables which values must be shared between different tests.
-    """
-    def __init__(self):
-        self.status_msg = None
-        self.api_version = None
-    
-    def status_msg_set(self, status_msg, ser: Serialization):
-        if not isinstance(status_msg, dict):
-            debug_print('Status message should be a dict!')
-            return
-
-        self.status_msg = status_msg
-        if ser == Serialization.PB:
-            self.api_version = status_msg.get(GW_API_VERSION)
-        else:
-            conf = status_msg.get(GW_CONF, {})
-            self.api_version = conf.get(GW_API_VERSION)
-            if isinstance(self.api_version, str):
-                self.api_version = int(self.api_version)
-
-    def status_msg_get(self):
-        return self.status_msg
-    
-    def is_acl_supported(self):
-        API_VERSION_SUPPORT_ACL = 205
-
-        if self.api_version != None and self.api_version >= API_VERSION_SUPPORT_ACL:
-            return True
-        return False

gw_certificate/cert_results.py

@@ -1,145 +0,0 @@
-import os
-import tabulate
-from reportlab.lib import colors
-from reportlab.lib.pagesizes import letter
-from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak, KeepTogether, Image
-from reportlab.lib.styles import ParagraphStyle
-from reportlab.lib.enums import TA_CENTER, TA_LEFT
-
-# Local imports
-from gw_certificate.ag.ut_defines import TEST_FAILED, TEST_INCONCLUSIVE, TEST_PASSED, TEST_INFO, TEST_WARNING, TEST_OPTIONAL
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-format_timedelta = lambda delta: f"{int(delta.total_seconds()//3600):02}:{int((delta.total_seconds()%3600)//60):02}:{int(delta.total_seconds()%60):02}"
-
-##################################
-# GENERIC
-##################################
-def generate_pdf_results_file(gw_cert):
-    # Extract GW certificate tests results
-    failures, inconclusive = 0, 0
-    for test in gw_cert.tests:
-        if test.rc == TEST_INCONCLUSIVE:
-            inconclusive += 1
-        elif test.rc == TEST_FAILED:
-            failures += 1
-
-    # Generate PDF file
-    doc = SimpleDocTemplate(gw_cert.result_pdf_path, pagesize=letter)
-    doc.title = f"Wiliot Gateway Certificate Results"
-    elements, hdr_page = [], []
-
-    # Add Wiliot Logo
-    img = Image(os.path.join(BASE_DIR, "../common", "wlt_logo.png"), width=100, height=40)  # Adjust size as needed
-    hdr_page.append(img)
-    hdr_page.append(Spacer(1, 20))
-
-    # Title and Summary
-    red_header = STYLES_PDF.get("RED_HEADER", ParagraphStyle("Default"))
-    green_header = STYLES_PDF.get("GREEN_HEADER", ParagraphStyle("Default"))
-    module_header = STYLES_PDF.get("MODULE_HEADER", ParagraphStyle("Default"))
-    test_header = STYLES_PDF.get("TEST_HEADER", ParagraphStyle("Default"))
-    text_style_bold = STYLES_PDF.get("BLACK_BOLD", ParagraphStyle("Default"))
-    text_style_centered = STYLES_PDF.get("BLACK", ParagraphStyle("Default"))
-    if gw_cert.error:
-        title = Paragraph(f"<b>Wiliot Gateway Certificate Error!</b>", red_header)
-        hdr_page.append(title)
-        hdr_page.append(Spacer(1, 20))
-        hdr_page.append(Paragraph(f"{gw_cert.error}", text_style_bold))
-    else:
-        title = Paragraph(f"<b>Wiliot Gateway Certificate Passed!</b>", green_header) if not failures else Paragraph(f"<b>Wiliot Gateway Certificate Failed!</b>", red_header)
-        hdr_page.append(title)
-        hdr_page.append(Spacer(1, 20))
-        hdr_page.append(Paragraph(f"<b>Summary</b>", module_header))
-        hdr_page.append(Spacer(1, 20))
-        hdr_page.append(Paragraph("<u>Run Info:</u>", text_style_bold))
-        hdr_page.append(Paragraph(f"Run date: {gw_cert.current_datetime.strftime('%d/%m/%Y, %H:%M:%S')}", text_style_bold))
-        hdr_page.append(Paragraph(f"Tests duration: {format_timedelta(gw_cert.runtime())}", text_style_bold))
-        hdr_page.append(Paragraph(f"Certificate version: {gw_cert.gw_cert_version}", text_style_bold))
-        hdr_page.append(Spacer(1, 10))
-        if gw_cert.use_uart:
-            hdr_page.append(Paragraph("<u>Certification Kit Info:</u>", text_style_bold))
-            hdr_page.append(Paragraph(f"BLE simulator mac: {gw_cert.uart.mac}", text_style_bold))
-            hdr_page.append(Paragraph(f"BLE simulator version: {gw_cert.uart.fw_version}", text_style_bold))
-            hdr_page.append(Spacer(1, 10))
-        hdr_page.append(Paragraph("<u>Tested Device Info:</u>", text_style_bold))
-        hdr_page.append(Paragraph(f"Tested gateway ID: {gw_cert.gw_id}", text_style_bold))
-        hdr_page.append(Spacer(1, 20))
-
-        # Count Table
-        count_data = [
-            ["PASSED", "INCONCLUSIVE", "FAILED", "TOTAL"],
-            [len(gw_cert.tests)-(failures+inconclusive), inconclusive, failures, len(gw_cert.tests)]
-        ]
-        count_table = Table(count_data)
-        count_table.setStyle(INNER_TABLE_STYLE)
-        hdr_page.append(count_table)
-        hdr_page.append(Spacer(1, 20))
-
-        # Test Results
-        summary_data = []
-        text_style_center = STYLES_PDF.get("BLACK", ParagraphStyle("Default"))
-        text_style_left = STYLES_PDF.get("BLACK_LEFT", ParagraphStyle("Default"))
-        for test in gw_cert.tests:
-            summary_data += [[Paragraph(f'<a href="#{test}">{test}</a>', text_style_centered), pass_or_fail_pdf(test), format_timedelta(test.duration)]]
-            elements.append(Paragraph(f"<a name='{test}'/><b>{test}</b>", module_header))
-            elements.append(Spacer(1, 20))
-            elements.append(pass_or_fail_pdf(test))
-            elements.append(Spacer(1, 10))
-            elements.append(Paragraph(f"Test duration: {format_timedelta(test.duration)}", text_style_bold))
-            elements.append(Spacer(1, 10))
-            inner_table, stages_breakdown = [["Phase", "Result", "Duration"]], []
-            for stage in test.stages:
-                stages_breakdown += [KeepTogether([Paragraph(stage.stage_name, test_header), Spacer(1, 10), pass_or_fail_pdf(stage), Spacer(1, 10)]
-                                                + [Paragraph(l, text_style_left) for l in stage.report.split('\n')]
-                                                + [Spacer(1, 10)])]
-                inner_table += [[Paragraph(stage.stage_name, text_style_center), pass_or_fail_pdf(stage), Paragraph(format_timedelta(stage.duration), text_style_center)]]
-            test_table = Table(inner_table)
-            test_table.setStyle(INNER_TABLE_STYLE)
-            elements.append(test_table)
-            elements.append(Spacer(1, 20))
-            elements += stages_breakdown
-            elements.append(PageBreak())
-        summary_table = Table([["Name", "Result", "Duration"]] + summary_data)
-        summary_table.setStyle(INNER_TABLE_STYLE)
-        elements = hdr_page + [summary_table, PageBreak()] + elements
-
-    doc.build(elements)
-
-
-##################################
-# PDF
-##################################
-STYLES_PDF = {
-    "GREEN_HEADER": ParagraphStyle("Green Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.green, alignment=TA_CENTER),
-    "RED_HEADER": ParagraphStyle("Red Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.red, alignment=TA_CENTER),
-    "MODULE_HEADER": ParagraphStyle("Module Header", fontName="Helvetica-Bold", fontSize=16, textColor=colors.navy, alignment=TA_CENTER),
-    "TEST_HEADER": ParagraphStyle("Test Header", fontName="Helvetica-Bold", fontSize=12, textColor=colors.black, alignment=TA_CENTER),
-    "BLACK": ParagraphStyle("Black", fontName="Helvetica", fontSize=9, textColor=colors.black, splitLongWords=False, alignment=TA_CENTER, wordWrap = 'CJK'),
-    "BLACK_LEFT": ParagraphStyle("Black Left", fontName="Helvetica", fontSize=9, textColor=colors.black, splitLongWords=False, alignment=TA_LEFT, wordWrap = 'CJK'),
-    "BLACK_BOLD": ParagraphStyle("Black Bold", fontName="Helvetica-Bold", fontSize=9, textColor=colors.black, splitLongWords=False, alignment=TA_LEFT, wordWrap = 'CJK'),
-    "BLUE": ParagraphStyle("Blue", fontName="Helvetica-Bold", fontSize=9, textColor=colors.navy, splitLongWords=False, alignment=TA_CENTER),
-    "CYAN": ParagraphStyle("Cyan", fontName="Helvetica-Bold", fontSize=9, textColor=colors.cyan, splitLongWords=False, alignment=TA_CENTER),
-    "GREEN": ParagraphStyle("Green", fontName="Helvetica-Bold", fontSize=9, textColor=colors.green, splitLongWords=False, alignment=TA_CENTER),
-    "WARNING": ParagraphStyle("Warning", fontName="Helvetica-Bold", fontSize=9, textColor=colors.gold, splitLongWords=False, alignment=TA_CENTER),
-    "RED": ParagraphStyle("Red", fontName="Helvetica-Bold", fontSize=9, textColor=colors.red, splitLongWords=False, alignment=TA_CENTER),
-    "GRAY": ParagraphStyle("Gray", fontName="Helvetica-Bold", fontSize=9, textColor=colors.gray, splitLongWords=False, alignment=TA_CENTER),
-}
-def color_pdf(c, t):
-    style = STYLES_PDF.get(c, ParagraphStyle("Default"))
-    return Paragraph(t, style)
-pdf_result_map = {TEST_FAILED: color_pdf("RED", "FAILED"), TEST_INCONCLUSIVE: color_pdf("WARNING", "INCONCLUSIVE"), 
-                  TEST_PASSED: color_pdf("GREEN", "PASSED"),  TEST_INFO: color_pdf("CYAN", "INFO"),
-                  TEST_WARNING: color_pdf("WARNING", "WARNING"), TEST_OPTIONAL: color_pdf("GRAY", "OPTIONAL")}
-pass_or_fail_pdf = lambda obj : pdf_result_map[obj.rc]
-
-INNER_TABLE_STYLE = TableStyle([
-                ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
-                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
-                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
-                ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
-                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-                ('FONTSIZE', (0, 0), (-1, 0), 9),
-                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
-                ('BACKGROUND', (0, 1), (-1, -1), colors.whitesmoke),
-                ('WORDWRAP', (0, 0), (-1, -1), False),
-            ])