tina4-python 0.2.124__tar.gz → 0.2.125__tar.gz

{tina4_python-0.2.124 → tina4_python-0.2.125}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 0.2.124
+Version: 0.2.125
 Summary: Tina4Python - This is not another framework for Python
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 Requires-Python: <4.0,>=3.12

{tina4_python-0.2.124 → tina4_python-0.2.125}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "0.2.124"
+version = "0.2.125"
 description = "Tina4Python - This is not another framework for Python"
 authors = [
     {name = "Andre van Zuydam",email = "andrevanzuydam@gmail.com"}

{tina4_python-0.2.124 → tina4_python-0.2.125}/tina4_python/CRUD.py

@@ -141,6 +141,9 @@ class CRUD:
         table_nice_name = Template.get_nice_label(table_name)
         twig_file = self.ensure_crud_template(table_name + ".twig")
 
+        if options is None:
+            options = {}
+
         if "primary_key" not in options:
             options["primary_key"] = "id"
 
@@ -165,9 +168,12 @@ class CRUD:
 
 
             # Use defined columns or fallback
-            search_columns = self.columns
-            if isinstance(search_columns, dict):
-                search_columns = [c["name"] for c in search_columns if "name" in c]
+            if not "search_columns" in options:
+                search_columns = self.columns
+                if isinstance(search_columns, dict):
+                    search_columns = [c["name"] for c in search_columns if "name" in c]
+            else:
+                search_columns = options["search_columns"]
 
             # Execute fetch with search
             result = self.dba.fetch(

{tina4_python-0.2.124 → tina4_python-0.2.125}/tina4_python/Template.py

@@ -4,6 +4,8 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
+import ast
+import html
 import os
 import re
 import json
@@ -33,6 +35,7 @@ class Template:
         Template.twig.add_extension('jinja2.ext.do')
         Template.twig.globals['RANDOM'] = RANDOM
         Template.twig.globals['json'] = json
+        Template.twig.filters['detect_image'] = Template.detect_image
         Template.twig.filters['json_encode'] = json.dumps
         Template.twig.filters['json_decode'] = json.loads
         Template.twig.filters['nice_label'] = Template.get_nice_label
@@ -79,7 +82,7 @@ class Template:
         """
         Recursively convert non-JSON-serializable objects:
           • datetime/date → ISO 8601 string
-          • bytes        → base64 string
+          • bytes base64 string
           • dict/list/tuple/set → recursively processed
         Safe for deeply nested data (arrays of arrays, dicts in lists, etc.)
         """
@@ -145,81 +148,51 @@ class Template:
 
     @staticmethod
     def detect_image(value: Any) -> Dict[str, str]:
-        """
-        Detects if a string is an image (base64, data URL, or raw bytes)
-        Returns: {"content": "<base64 without prefix>", "content_type": "image/jpeg|png|gif|webp"}
-        """
-        if value is None:
-            return {"content": "", "content_type": ""}
-
-        # Convert to string if it's bytes or something else
-        if isinstance(value, (bytes, bytearray)):
-            value = value.decode('latin1', errors='ignore')
-        elif not isinstance(value, str):
-            value = str(value)
+        if not value or len(value) <= 50:
+            return {"content": value, "content_type": ""}
 
-        original = value.strip()
-
-        # Case 1: JSON object like {"content": "...", "content_type": "..."}
-        if original.startswith("{"):
-            try:
-                data = json.loads(original)
-                if isinstance(data, dict) and "content" in data:
-                    content = data["content"]
-                    content_type = data.get("content_type", "")
-                    if content_type.startswith("image/"):
-                        return {
-                            "content": str(content).split(",", 1)[-1] if "," in content else str(content),
-                            "content_type": content_type
-                        }
-            except:
-                pass  # not valid JSON, continue
-
-        # Case 2: Data URL like data:image/png;base64,...
-        if original.startswith("data:image/"):
+        if value[0] == '{' and value[-1] == '}':
             try:
-                header, b64_data = original.split(",", 1)
-                mime = header.split(";")[0].split(":", 1)[1]  # extract image/png
-                return {
-                    "content": b64_data,
-                    "content_type": mime
-                }
-            except:
-                pass
-
-        # Case 3: Pure base64 string with magic bytes detection
-        b64 = original
-
-        # Remove common prefixes if present
-        if b64.startswith("data:"):
-            b64 = b64.split(",", 1)[-1]
-
-        # Clean whitespace/newlines
-        b64 = b64.strip()
-
-        # Try to detect by magic bytes (first few chars of base64)
-        try:
-            # Decode just the first 20 bytes to inspect magic
-            sample = base64.b64decode(b64[:40] + "===", validate=True)
-        except:
-            return {"content": "", "content_type": ""}
-
-        if sample.startswith(b'\xFF\xD8\xFF'):
-            mime = "image/jpeg"
-        elif sample.startswith(b'\x89PNG\r\n\x1A\n'):
-            mime = "image/png"
-        elif sample.startswith(b'GIF87a') or sample.startswith(b'GIF89a'):
-            mime = "image/gif"
-        elif sample.startswith(b'RIFF') and len(sample) >= 12 and sample[8:12] == b'WEBP':
-            mime = "image/webp"
-        elif sample.startswith(b'BM'):  # BMP
-            mime = "image/bmp"
-        elif sample.startswith(b'\x00\x00\x01\x00'):  # ICO
-            mime = "image/x-icon"
+                value = html.unescape(value)
+                data = json.loads(value)
+                content = data.get('content', '')
+
+                if not content:
+                    return  {"content": value, "content_type": ""}
+
+                content_type = data.get('content_type', '')
+                if content_type.startswith('image/'):
+                    mime_type = content_type.split('/')[1]
+                    return  {"content": content, "content_type": mime_type}
+
+                # Fallback to magic bytes if no content_type
+                if content[:4] == '/9j/':
+                    mime_type = 'jpeg'
+                elif content[:11] == 'iVBORw0KGgo':
+                    mime_type = 'png'
+                elif content[:6] == 'R0lGOD':
+                    mime_type = 'gif'
+                elif content[:5] == 'UklGR':
+                    mime_type = 'webp'
+                else:
+                    return  {"content": content, "content_type": ""}
+
+                return {"content": content, "content_type": mime_type}
+            except json.JSONDecodeError as e:
+                return {"content": str(e), "content_type": ""}
+
+
+        mime_type = "jpeg"
+        # Check magic bytes on value
+        if value[:4] == '/9j/':
+            mime_type = 'jpeg'
+        elif value[:11] == 'iVBORw0KGgo':
+            mime_type = 'png'
+        elif value[:6] == 'R0lGOD':
+            mime_type = 'gif'
+        elif value[:5] == 'UklGR':
+            mime_type = 'webp'
         else:
-            return {"content": "", "content_type": ""}
+            return {"content": value, "content_type": mime_type}
 
-        return {
-            "content": b64,
-            "content_type": mime
-        }
+        return {"content": value, "content_type": mime_type}

{tina4_python-0.2.124 → tina4_python-0.2.125}/tina4_python/templates/components/crud.twig

@@ -48,26 +48,12 @@
 
                                         {# --- Detect image by magic bytes (no ternary, no starts with) --- #}
                                         {% set is_image = False %}
-                                        {% set mime_type = 'jpeg' %}
+                                        {% set check_value = value | detect_image   %}
 
-                                        {% if value[0] == "{" %}
+                                        {% if check_value.content_type  %}
                                             {% set is_image = True %}
-                                            {% set value = value | json_decode %}
-                                            {% set value = value.content %}
-                                        {% else %}
-                                            {% if value[:4] == '/9j/' %}
-                                                {% set is_image = True %}
-                                                {% set mime_type = 'jpeg' %}
-                                                {% elif value[:11] == 'iVBORw0KGgo' %}
-                                                {% set is_image = True %}
-                                                {% set mime_type = 'png' %}
-                                                {% elif value[:6] == 'R0lGOD' %}
-                                                {% set is_image = True %}
-                                                {% set mime_type = 'gif' %}
-                                                {% elif value[:5] == 'UklGR' %}
-                                                {% set is_image = True %}
-                                                {% set mime_type = 'webp' %}
-                                            {% endif %}
+                                            {% set value = check_value.content %}
+                                            {% set mime_type = check_value.mime_type %}
                                         {% endif %}
 
                                         {# --- Only show image if it's base64-like and long enough --- #}
@@ -132,34 +118,18 @@
                             {% set name = column.name %}
                             {% set value = record[name]|e %}
 
-                            {# --- Detect image by magic bytes (no ternary, no starts with) --- #}
                             {% set is_image = False %}
-                            {% set mime_type = 'jpeg' %}
 
+                            {% set check_value = value | detect_image   %}
 
-                            {% if value | length > 50  and value != "" and value[0] == "{" %}
+                            {% if check_value.content_type  %}
                                 {% set is_image = True %}
-                                {% set value =  record[name] | json_decode %}
-                                {% set value = value.content %}
-                            {% else %}
-                                {% if value|length > 50 and value[:4] == '/9j/' %}
-                                    {% set is_image = True %}
-                                    {% set mime_type = 'jpeg' %}
-                                    {% elif value[:11] == 'iVBORw0KGgo' %}
-                                    {% set is_image = True %}
-                                    {% set mime_type = 'png' %}
-                                    {% elif value[:6] == 'R0lGOD' %}
-                                    {% set is_image = True %}
-                                    {% set mime_type = 'gif' %}
-                                    {% elif value[:5] == 'UklGR' %}
-                                    {% set is_image = True %}
-                                    {% set mime_type = 'webp' %}
-                                {% endif %}
+                                {% set value = check_value.content %}
+                                {% set mime_type = check_value.mime_type %}
                             {% endif %}
-
                             <td>
                                 {# --- Only show image if it's base64-like and long enough --- #}
-                                {% if is_image and value|length > 50 and value is string %}
+                                {% if is_image  %}
                                     {% set src = value %}
                                     {% if value[:10] != 'data:image/' %}
                                         {% set src = 'data:image/' ~ mime_type ~ ';base64,' ~ value %}