karrio-server-documents 2025.5rc14__py3-none-any.whl → 2025.5rc15__py3-none-any.whl

karrio/server/documents/generator.py

@@ -37,6 +37,15 @@ UNITS = {
 }
 
 
+class TemplateRenderingError(Exception):
+    """Custom exception for template rendering errors"""
+    def __init__(self, message, line_number=None, template_error=None):
+        self.message = message
+        self.line_number = line_number
+        self.template_error = template_error
+        super().__init__(self.message)
+
+
 class Documents:
     @staticmethod
     def generate(
@@ -47,6 +56,8 @@ class Documents:
     ) -> io.BytesIO:
         options = kwargs.get("options") or {}
         metadata = kwargs.get("metadata") or {}
+
+        # Build contexts based on related_object and provided data
         shipment_contexts = data.get("shipments_context") or lib.identity(
             get_shipments_context(data["shipments"])
             if "shipments" in data and related_object == "shipment"
@@ -57,63 +68,120 @@ class Documents:
             if "orders" in data and related_object == "order"
             else []
         )
+
+        # For generic contexts, include the full data structure
         generic_contexts = data.get("generic_context") or lib.identity(
-            [{"data": data}] if related_object is None else []
+            [data] if related_object is None else []
         )
+
+        # If no specific contexts are provided but we have a related_object, create a context with the data
+        if not shipment_contexts and not order_contexts and not generic_contexts:
+            if related_object == "shipment" and data:
+                # For shipment templates, ensure we have the expected structure
+                generic_contexts = [data]
+            elif related_object == "order" and data:
+                # For order templates, ensure we have the expected structure
+                generic_contexts = [data]
+            else:
+                # Default fallback
+                generic_contexts = [data]
+
         filename = lib.identity(
             dict(filename=kwargs.get("doc_name")) if kwargs.get("doc_name") else {}
         )
 
-        prefetch = lambda ctx: {
-            k: v
-            for o in lib.run_concurently(
-                lambda _: {
-                    _[0]: str(
-                        lib.failsafe(
-                            lambda: _[1].render(
-                                **ctx,
-                                metadata=metadata,
-                                units=UNITS,
-                                utils=utils,
-                                lib=lib,
-                            )
-                        )
-                        or ""
+        def safe_render_prefetch(ctx):
+            """Safely render prefetch templates with error handling"""
+            result = {}
+            for key, value in options.get("prefetch", {}).items():
+                try:
+                    template_obj = jinja2.Template(value)
+                    rendered = template_obj.render(
+                        **ctx,
+                        metadata=metadata,
+                        units=UNITS,
+                        utils=utils,
+                        lib=lib,
                     )
-                },
-                [
-                    (key, jinja2.Template(value))
-                    for key, value in options.get("prefetch", {}).items()
-                ],
+                    result[key] = str(rendered or "")
+                except jinja2.TemplateError as e:
+                    # Log the error but continue with empty string
+                    result[key] = ""
+            return result
+
+        try:
+            jinja_template = jinja2.Template(template)
+        except jinja2.TemplateSyntaxError as e:
+            raise TemplateRenderingError(
+                f"Template syntax error: {e.message}",
+                line_number=e.lineno,
+                template_error=e
             )
-            for k, v in o.items()
-        }
 
-        jinja_template = jinja2.Template(template)
         all_contexts = shipment_contexts + order_contexts + generic_contexts
-        rendered_pages = lib.run_asynchronously(
-            lambda ctx: jinja_template.render(
-                **ctx,
-                metadata=metadata,
-                units=UNITS,
-                utils=utils,
-                lib=lib,
-                prefetch=prefetch(ctx),
-            ),
-            all_contexts,
-        )
-        content = PAGE_SEPARATOR.join(rendered_pages)
 
-        buffer = io.BytesIO()
-        html = weasyprint.HTML(string=content, encoding="utf-8")
-        html.write_pdf(
-            buffer,
-            stylesheets=STYLESHEETS,
-            font_config=FONT_CONFIG,
-            optimize_size=("fonts", "images"),
-        )
+        # If no contexts are available, create a default one
+        if not all_contexts:
+            all_contexts = [data or {}]
 
-        return buffer
+        rendered_pages = []
+        for ctx in all_contexts:
+            try:
+                # Add prefetch data safely
+                ctx_with_prefetch = {
+                    **ctx,
+                    "prefetch": safe_render_prefetch(ctx)
+                }
+
+                rendered_page = jinja_template.render(
+                    **ctx_with_prefetch,
+                    metadata=metadata,
+                    units=UNITS,
+                    utils=utils,
+                    lib=lib,
+                )
+                rendered_pages.append(rendered_page)
+            except jinja2.UndefinedError as e:
+                raise TemplateRenderingError(
+                    f"Template variable error: {str(e)}. Available variables: {list(ctx.keys())}",
+                    template_error=e
+                )
+            except jinja2.TemplateRuntimeError as e:
+                raise TemplateRenderingError(
+                    f"Template runtime error: {str(e)}",
+                    line_number=getattr(e, 'lineno', None),
+                    template_error=e
+                )
+            except jinja2.TemplateError as e:
+                raise TemplateRenderingError(
+                    f"Template error: {str(e)}",
+                    line_number=getattr(e, 'lineno', None),
+                    template_error=e
+                )
+            except Exception as e:
+                raise TemplateRenderingError(
+                    f"Unexpected error during template rendering: {str(e)}",
+                    template_error=e
+                )
+
+        content = PAGE_SEPARATOR.join(rendered_pages)
+
+        # Handle PDF generation errors
+        try:
+            buffer = io.BytesIO()
+            html = weasyprint.HTML(string=content, encoding="utf-8")
+            html.write_pdf(
+                buffer,
+                stylesheets=STYLESHEETS,
+                font_config=FONT_CONFIG,
+                optimize_size=("fonts", "images"),
+            )
+            return buffer
+        except Exception as e:
+            raise TemplateRenderingError(
+                f"PDF generation error: {str(e)}",
+                template_error=e
+            )
 
     @staticmethod
     def generate_template(

karrio/server/documents/tests.py

@@ -0,0 +1,182 @@
+import json
+from django.test import TestCase
+from rest_framework.test import APIClient
+from rest_framework import status
+from unittest.mock import patch
+
+from karrio.server.documents.generator import Documents, TemplateRenderingError
+
+
+class DocumentGenerationErrorHandlingTest(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        # Mock authentication for testing
+        with patch('karrio.server.core.views.api.APIView.permission_classes', []):
+            pass
+
+    def test_template_with_undefined_variable_returns_error(self):
+        """Test that template with undefined variables returns proper error message"""
+        template = "<div>{{ shipment.shipper.address_line1 }}</div>"
+        data = {
+            "template": template,
+            "doc_format": "html",
+            "doc_name": "Test Document",
+            "data": {
+                "object": {"id": "test123"},
+                # Note: no shipment data provided, so shipment.shipper.address_line1 will be undefined
+            }
+        }
+
+        # Mock the permission check
+        with patch('karrio.server.core.views.api.APIView.check_permissions'):
+            response = self.client.post(
+                '/v1/documents/generate',
+                data=json.dumps(data),
+                content_type='application/json'
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn('errors', response.json())
+        self.assertIn('Template variable error', response.json()['errors'][0]['message'])
+        self.assertIn('shipment', response.json()['errors'][0]['message'])
+
+    def test_template_syntax_error_returns_error(self):
+        """Test that template with syntax errors returns proper error message"""
+        template = "<div>{{ unclosed_tag</div>"  # Missing closing }}
+        data = {
+            "template": template,
+            "doc_format": "html",
+            "doc_name": "Test Document",
+            "data": {"test": "data"}
+        }
+
+        with patch('karrio.server.core.views.api.APIView.check_permissions'):
+            response = self.client.post(
+                '/v1/documents/generate',
+                data=json.dumps(data),
+                content_type='application/json'
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn('errors', response.json())
+        self.assertIn('Template syntax error', response.json()['errors'][0]['message'])
+
+    def test_missing_template_returns_error(self):
+        """Test that missing template returns proper error message"""
+        data = {
+            "doc_format": "html",
+            "doc_name": "Test Document",
+            "data": {"test": "data"}
+            # Note: no template or template_id provided
+        }
+
+        with patch('karrio.server.core.views.api.APIView.check_permissions'):
+            response = self.client.post(
+                '/v1/documents/generate',
+                data=json.dumps(data),
+                content_type='application/json'
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertIn('errors', response.json())
+        self.assertEqual(
+            response.json()['errors'][0]['message'],
+            'template or template_id is required'
+        )
+
+    def test_valid_template_with_data_succeeds(self):
+        """Test that valid template with proper data succeeds"""
+        template = "<div>Hello {{ name }}!</div>"
+        data = {
+            "template": template,
+            "doc_format": "html",
+            "doc_name": "Test Document",
+            "data": {
+                "name": "World",
+                "shipment": {
+                    "shipper": {"address_line1": "123 Test St"}
+                }
+            }
+        }
+
+        # Mock PDF generation to avoid WeasyPrint dependency in tests
+        with patch('karrio.server.core.views.api.APIView.check_permissions'), \
+             patch('karrio.server.documents.generator.weasyprint.HTML') as mock_html:
+
+            # Mock the PDF generation
+            mock_buffer = b"fake pdf content"
+            mock_html.return_value.write_pdf.return_value = None
+
+            # Patch the buffer creation
+            with patch('karrio.server.documents.generator.io.BytesIO') as mock_bytesio:
+                mock_bytesio.return_value.getvalue.return_value = mock_buffer
+
+                response = self.client.post(
+                    '/v1/documents/generate',
+                    data=json.dumps(data),
+                    content_type='application/json'
+                )
+
+        # Should succeed (201) or fail gracefully with a proper error message
+        self.assertIn(response.status_code, [status.HTTP_201_CREATED, status.HTTP_400_BAD_REQUEST])
+
+        if response.status_code == status.HTTP_400_BAD_REQUEST:
+            # If it fails, it should be with a proper error message, not a 500
+            self.assertIn('errors', response.json())
+            error_message = response.json()['errors'][0]['message']
+            # Should not be a generic "internal server error"
+            self.assertNotIn('Internal server error', error_message)
+
+    def test_template_rendering_error_direct(self):
+        """Test TemplateRenderingError class directly"""
+        try:
+            # Test with a template that has undefined variables
+            Documents.generate(
+                template="<div>{{ undefined_var.nested.property }}</div>",
+                data={"some_data": "test"}
+            )
+            self.fail("Should have raised TemplateRenderingError")
+        except TemplateRenderingError as e:
+            self.assertIn("Template variable error", e.message)
+            self.assertIn("undefined_var", e.message)
+            self.assertIn("Available variables", e.message)
+        except Exception as e:
+            self.fail(f"Should have raised TemplateRenderingError, got {type(e).__name__}: {e}")
+
+
+class DocumentGenerationContextTest(TestCase):
+    """Test that data contexts are properly handled"""
+
+    def test_shipment_context_properly_passed(self):
+        """Test that shipment data is properly passed to template context"""
+        template = "<div>{{ shipment.shipper.address_line1 }}</div>"
+        data = {
+            "shipment": {
+                "shipper": {"address_line1": "123 Test Street"}
+            }
+        }
+
+        try:
+            # This should work without errors
+            result = Documents.generate(template, data=data)
+            # If we get here, the context was properly passed
+            self.assertIsNotNone(result)
+        except TemplateRenderingError as e:
+            # If it fails, it should be due to PDF generation, not template rendering
+            if "PDF generation error" not in e.message:
+                self.fail(f"Template rendering failed: {e.message}")
+
+    def test_generic_context_fallback(self):
+        """Test that generic context fallback works for arbitrary data"""
+        template = "<div>{{ custom_field }}</div>"
+        data = {
+            "custom_field": "test value"
+        }
+
+        try:
+            result = Documents.generate(template, data=data)
+            self.assertIsNotNone(result)
+        except TemplateRenderingError as e:
+            # Should work for simple templates
+            if "PDF generation error" not in e.message:
+                self.fail(f"Template rendering failed: {e.message}")

karrio/server/documents/views/templates.py

@@ -167,34 +167,74 @@ class DocumentGenerator(api.APIView):
         This API is designed to be used to generate GS1 labels,
         invoices and any document that requires external data.
         """
-        data = serializers.DocumentData.map(data=request.data).data
+        try:
+            data = serializers.DocumentData.map(data=request.data).data
 
-        if data.get("template") is None and data.get("template_id") is None:
-            raise serializers.ValidationError("template or template_id is required")
+            if data.get("template") is None and data.get("template_id") is None:
+                return Response(
+                    {"errors": [{"message": "template or template_id is required"}]},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
 
-        document_template = lib.identity(
-            None
-            if data.get("template_id") is None
-            else models.DocumentTemplate.objects.get(pk=data.get("template_id"))
-        )
+            document_template = lib.identity(
+                None
+                if data.get("template_id") is None
+                else models.DocumentTemplate.objects.get(pk=data.get("template_id"))
+            )
 
-        doc_file = generator.Documents.generate(
-            getattr(document_template, "template", data.get("template")),
-            related_object=getattr(document_template, "related_object", None),
-            metadata=getattr(document_template, "metadata", {}),
-            data=data.get("data"),
-            options=data.get("options"),
-            doc_name=data.get("doc_name"),
-            doc_fomat=data.get("doc_format"),
-        )
-        document = serializers.GeneratedDocument.map(
-            data={
-                **data,
-                "doc_file": base64.b64encode(doc_file.getvalue()).decode("utf-8"),
-            }
-        )
+            try:
+                doc_file = generator.Documents.generate(
+                    getattr(document_template, "template", data.get("template")),
+                    related_object=getattr(document_template, "related_object", None),
+                    metadata=getattr(document_template, "metadata", {}),
+                    data=data.get("data", {}),
+                    options=data.get("options", {}),
+                    doc_name=data.get("doc_name"),
+                    doc_format=data.get("doc_format"),
+                )
+
+                document = serializers.GeneratedDocument.map(
+                    data={
+                        **data,
+                        "doc_file": base64.b64encode(doc_file.getvalue()).decode("utf-8"),
+                    }
+                )
 
-        return Response(document.data, status=status.HTTP_201_CREATED)
+                return Response(document.data, status=status.HTTP_201_CREATED)
+
+            except generator.TemplateRenderingError as e:
+                error_message = e.message
+                if e.line_number:
+                    error_message += f" (line {e.line_number})"
+
+                return Response(
+                    {"errors": [{"message": error_message}]},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            except models.DocumentTemplate.DoesNotExist:
+                return Response(
+                    {"errors": [{"message": f"Document template with id '{data.get('template_id')}' not found"}]},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+            except Exception as e:
+                logger.exception(f"Unexpected error during document generation: {e}")
+                return Response(
+                    {"errors": [{"message": f"Document generation failed: {str(e)}"}]},
+                    status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                )
+
+        except serializers.ValidationError as e:
+            logger.error(f"Validation error: {e}")
+            return Response(
+                {"errors": [{"message": "Invalid input data"}]},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        except Exception as e:
+            logger.exception(f"Unexpected error in document generator: {e}")
+            return Response(
+                {"errors": [{"message": "Internal server error"}]},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
 
 
 urlpatterns = [

{karrio_server_documents-2025.5rc14.dist-info → karrio_server_documents-2025.5rc15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karrio_server_documents
-Version: 2025.5rc14
+Version: 2025.5rc15
 Summary: Multi-carrier shipping API apps module
 Author-email: karrio <hello@karrio.io>
 License-Expression: Apache-2.0

{karrio_server_documents-2025.5rc14.dist-info → karrio_server_documents-2025.5rc15.dist-info}/RECORD

@@ -2,9 +2,10 @@ karrio/server/documents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 karrio/server/documents/admin.py,sha256=TAkENFDUEnRvOXvKL_6Nz-kmi5sosHvM04W6zCLeIBA,3464
 karrio/server/documents/apps.py,sha256=cH7FOtpePV56R4mW1KIlTdySGavZYZZ9hEwo3xmwgLo,359
 karrio/server/documents/filters.py,sha256=cLJNRFAnmzRNErUwnx9xSj413q2da5hrjRN2U3KPbrU,460
-karrio/server/documents/generator.py,sha256=OV_lbBPX-pDJhjFKscDbBcF2fb4IE-hgbaq35oXBMLE,7416
+karrio/server/documents/generator.py,sha256=Dh__0UAU0bKgMr28O3FXHKB_yN1a_Bdm-aO_Lz_96xk,10326
 karrio/server/documents/models.py,sha256=btjONslnF7BYmDR6_EAmI2K8F96xC2w2WV2F8FNE9m4,1724
 karrio/server/documents/signals.py,sha256=HY4GvQuLEgCgQ2ONNVVKLuZtoOVZvbkVYOpwnHHFyEk,937
+karrio/server/documents/tests.py,sha256=_DhWOXdu2jl1xPbyveqlZiJReSHHt0kMQ8fsvmbRuI8,7437
 karrio/server/documents/urls.py,sha256=JPGYWhRS_Ts3g4QRPJ6r93JDf_V7ucII_5xSOP93NHg,273
 karrio/server/documents/utils.py,sha256=ElTfhi4lkU3ZjzYf_eW6FdXhAHmXuKR0u7YpDymJodQ,119469
 karrio/server/documents/migrations/0001_initial.py,sha256=_4SvF3POad9c77tYuyjgjidatJRvYPlGIakE3ja-bhg,2406
@@ -24,13 +25,13 @@ karrio/server/documents/tests/test_generator.py,sha256=JgTziVt9Sn_VuVU2axvUUOTp0
 karrio/server/documents/tests/test_templates.py,sha256=fenggMLz5svtSSQc3k1GnFMnnHTmJqN0hpX2uHuaNrY,11268
 karrio/server/documents/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 karrio/server/documents/views/printers.py,sha256=OsgMLIZ2y64Sr_9Z020n0mWL28TlUjq8iN4wULJuxsM,7343
-karrio/server/documents/views/templates.py,sha256=vDxU2wtjXMus6vHO17cZTFW_PTWms9r2Gsj0LuPN_kY,7063
+karrio/server/documents/views/templates.py,sha256=uR2fwdaHSrQTlEe4mYl8EsVIaVhHi-aoxIOko0DpEMU,8881
 karrio/server/graph/schemas/__init__.py,sha256=iOEMwnlORWezdO8-2vxBIPSR37D7JGjluZ8f55vzxls,81
 karrio/server/graph/schemas/documents/__init__.py,sha256=GV9yk56ddIYnB9PP_AtXnucs3SIszUJpe2Jv9sHdzlo,1620
 karrio/server/graph/schemas/documents/inputs.py,sha256=Ri2P_VJjUsFZYy8dIuHnUzHlbWxgSWJhpy9J8TS8Y1Q,1288
 karrio/server/graph/schemas/documents/mutations.py,sha256=5m-3w7ZVRsl4SiagpN4XN1nN1TW_3eLrqRCjhaFRtG0,1849
 karrio/server/graph/schemas/documents/types.py,sha256=_UgtdgnGDUeMXW9HGHNVdcP7YeN6hnsnTHYZZgaiH5M,1537
-karrio_server_documents-2025.5rc14.dist-info/METADATA,sha256=Doz5VUJ2T7Rkham_lrv9EOCFHRUvqgnxwBOBNRUpsNM,565
-karrio_server_documents-2025.5rc14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-karrio_server_documents-2025.5rc14.dist-info/top_level.txt,sha256=D1D7x8R3cTfjF_15mfiO7wCQ5QMtuM4x8GaPr7z5i78,12
-karrio_server_documents-2025.5rc14.dist-info/RECORD,,
+karrio_server_documents-2025.5rc15.dist-info/METADATA,sha256=W3-Uhahv0mPkokGzqDC4fVmwp_JBYxqeb6FN4zkpMzA,565
+karrio_server_documents-2025.5rc15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+karrio_server_documents-2025.5rc15.dist-info/top_level.txt,sha256=D1D7x8R3cTfjF_15mfiO7wCQ5QMtuM4x8GaPr7z5i78,12
+karrio_server_documents-2025.5rc15.dist-info/RECORD,,