Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
Mirrored from https://github.com/Camo67/composio.git
Synced Nov 22, 12:00 UTC
fix(py): truncate long filenames from public URL uploads
jkomyno committed
Jan 28, 2026 at 21:46 UTC
6e4cc38f06820bdcaaf66283779670a5863bdd9f
2 files changed
+233
python/composio/core/models/_files.py
+38
@@ -28,6 +28,12 @@ if t.TYPE_CHECKING:
28
29
_DEFAULT_CHUNK_SIZE = 1024 * 1024
30
_FILE_UPLOAD = "/api/v3/files/upload/request"
31
+_MAX_FILENAME_LENGTH = 100
32
+"""
33
+Maximum filename length to prevent issues with long URLs from public buckets.
34
+Long filenames (containing hashes, UUIDs, or encoded metadata) are replaced
35
+with timestamped filenames to match TypeScript SDK behavior.
36
+"""
37
38
LOCAL_CACHE_DIRECTORY_NAME = ".composio"
39
"""
@@ -133,6 +139,35 @@ def _generate_timestamped_filename(extension: str) -> str:
139
return f"file_{timestamp}_{unique_id}{extension}"
140
141
142
+def _truncate_filename(filename: str, max_length: int = _MAX_FILENAME_LENGTH) -> str:
143
+ """Truncate filename if it exceeds max length by generating a timestamped name.
144
+
145
+ Long filenames are common with public bucket URLs containing hashes or UUIDs.
146
+ These can cause issues, so we replace them with timestamped filenames while
147
+ preserving the extension.
148
+
149
+ Args:
150
+ filename: The original filename
151
+ max_length: Maximum allowed length for the filename
152
+
153
+ Returns:
154
+ The original filename if within limits, or a timestamped filename
155
+ with the extension preserved if the original is too long
156
+ """
157
+ if len(filename) <= max_length:
158
+ return filename
159
+
160
+ # Extract extension
161
+ if "." in filename:
162
+ _, ext = filename.rsplit(".", 1)
163
+ ext = f".{ext}"
164
+ else:
165
+ ext = ""
166
+
167
+ # Generate a timestamped filename (matches TypeScript SDK behavior)
168
+ return _generate_timestamped_filename(ext)
169
+
170
+
171
def _fetch_file_from_url(url: str) -> t.Tuple[str, bytes, str]:
172
"""Fetch file content from a URL.
173
@@ -165,6 +200,9 @@ def _fetch_file_from_url(url: str) -> t.Tuple[str, bytes, str]:
200
extension = _get_extension_from_mimetype(mimetype)
201
filename = _generate_timestamped_filename(extension)
202
203
+ # Truncate long filenames (common with public bucket URLs containing hashes)
204
+ filename = _truncate_filename(filename)
205
+
206
return filename, content, mimetype
207
208
python/tests/test_files.py
+195
@@ -15,8 +15,10 @@ from composio.core.models._files import (
15
_is_url,
16
_get_extension_from_mimetype,
17
_generate_timestamped_filename,
18
+ _truncate_filename,
19
_fetch_file_from_url,
20
_upload_bytes_to_s3,
21
+ _MAX_FILENAME_LENGTH,
22
)
23
from composio.core.models.base import allow_tracking
24
from composio.exceptions import ErrorUploadingFile
@@ -1402,3 +1404,196 @@ class TestFileHelperWithUrls:
1404
assert len(result["attachments"]) == 2
1405
assert result["attachments"][0]["s3key"] == "key1"
1406
assert result["attachments"][1]["s3key"] == "key2"
1407
+
1408
+
1409
+class TestTruncateFilename:
1410
+ """Test cases for _truncate_filename function.
1411
+
1412
+ Long filenames are common with public bucket URLs containing hashes or UUIDs.
1413
+ These can cause issues, so they are replaced with timestamped filenames.
1414
+ """
1415
+
1416
+ def test_truncate_filename_short_unchanged(self):
1417
+ """Short filenames should not be modified."""
1418
+ assert _truncate_filename("document.pdf") == "document.pdf"
1419
+ assert _truncate_filename("image.jpg") == "image.jpg"
1420
+ assert _truncate_filename("file.txt") == "file.txt"
1421
+
1422
+ def test_truncate_filename_at_limit_unchanged(self):
1423
+ """Filenames exactly at the limit should not be modified."""
1424
+ # Create a filename exactly at the limit (100 chars by default)
1425
+ name = "a" * 95 + ".pdf" # 95 + 4 = 99 chars
1426
+ assert _truncate_filename(name) == name
1427
+
1428
+ name_at_limit = "a" * 96 + ".pdf" # 96 + 4 = 100 chars
1429
+ assert _truncate_filename(name_at_limit) == name_at_limit
1430
+
1431
+ def test_truncate_filename_long_generates_timestamped(self):
1432
+ """Long filenames should be replaced with timestamped filename."""
1433
+ long_name = "a" * 150 + ".pdf"
1434
+ result = _truncate_filename(long_name)
1435
+
1436
+ assert len(result) < _MAX_FILENAME_LENGTH
1437
+ assert result.startswith("file_")
1438
+ assert result.endswith(".pdf")
1439
+
1440
+ def test_truncate_filename_preserves_extension(self):
1441
+ """Extension should be preserved when generating timestamped filename."""
1442
+ test_cases = [
1443
+ ("very_long_" * 20 + ".docx", ".docx"),
1444
+ ("hash_" * 30 + ".jpg", ".jpg"),
1445
+ ("uuid_" * 25 + ".png", ".png"),
1446
+ ("data_" * 40 + ".json", ".json"),
1447
+ ]
1448
+
1449
+ for long_name, expected_ext in test_cases:
1450
+ result = _truncate_filename(long_name)
1451
+ assert result.endswith(expected_ext), (
1452
+ f"Expected {result} to end with {expected_ext}"
1453
+ )
1454
+
1455
+ def test_truncate_filename_long_hash_url(self):
1456
+ """Hash-based filenames from URLs should be truncated."""
1457
+ # Typical long hash filename from public bucket URLs (needs to be >100 chars)
1458
+ hash_filename = "8f14e45fceea167a5a36dedd4bea2543_5d41402abc4b2a76b9719d911017c592_extra_hash_data_to_exceed_limit_download.jpg"
1459
+ assert len(hash_filename) > _MAX_FILENAME_LENGTH # Verify test setup
1460
+
1461
+ result = _truncate_filename(hash_filename)
1462
+
1463
+ assert len(result) <= _MAX_FILENAME_LENGTH
1464
+ assert result.startswith("file_")
1465
+ assert result.endswith(".jpg")
1466
+
1467
+ def test_truncate_filename_multiple_hashes(self):
1468
+ """Multiple concatenated hashes should be truncated."""
1469
+ # 32 char hash * 5 = 160 chars + extension
1470
+ multi_hash = "8f14e45fceea167a5a36dedd4bea2543" * 5 + ".pdf"
1471
+ result = _truncate_filename(multi_hash)
1472
+
1473
+ assert len(result) <= _MAX_FILENAME_LENGTH
1474
+ assert result.endswith(".pdf")
1475
+
1476
+ def test_truncate_filename_no_extension(self):
1477
+ """Long filenames without extension should still be truncated."""
1478
+ long_name = "a" * 150
1479
+ result = _truncate_filename(long_name)
1480
+
1481
+ assert len(result) <= _MAX_FILENAME_LENGTH
1482
+ assert result.startswith("file_")
1483
+ # Should not end with a dot
1484
+ assert not result.endswith(".")
1485
+
1486
+ def test_truncate_filename_custom_max_length(self):
1487
+ """Custom max_length parameter should be respected."""
1488
+ name = "a" * 60 + ".txt" # 64 chars total
1489
+
1490
+ # With default limit (100), should be unchanged
1491
+ assert _truncate_filename(name) == name
1492
+
1493
+ # With custom limit (50), should be truncated
1494
+ result = _truncate_filename(name, max_length=50)
1495
+ assert len(result) <= 50
1496
+ assert result.startswith("file_")
1497
+ assert result.endswith(".txt")
1498
+
1499
+ def test_truncate_filename_edge_case_one_over_limit(self):
1500
+ """Filename one character over limit should be truncated."""
1501
+ # Create filename exactly one char over the limit
1502
+ name = "a" * 97 + ".pdf" # 97 + 4 = 101 chars (one over default 100)
1503
+ result = _truncate_filename(name)
1504
+
1505
+ assert len(result) < _MAX_FILENAME_LENGTH
1506
+ assert result.startswith("file_")
1507
+ assert result.endswith(".pdf")
1508
+
1509
+ def test_truncate_filename_long_extension(self):
1510
+ """Long extensions should be preserved when truncating."""
1511
+ long_name = "file_" * 30 + ".dockerfile"
1512
+ result = _truncate_filename(long_name)
1513
+
1514
+ assert result.endswith(".dockerfile")
1515
+ assert result.startswith("file_")
1516
+
1517
+ def test_truncate_filename_multiple_dots_preserves_last_extension(self):
1518
+ """Filename with multiple dots should preserve only the last extension."""
1519
+ long_name = "archive" * 20 + ".backup.tar.gz"
1520
+ result = _truncate_filename(long_name)
1521
+
1522
+ # rsplit(".", 1) takes the part after the last dot
1523
+ assert result.endswith(".gz")
1524
+
1525
+
1526
+class TestFetchFileFromUrlWithTruncation:
1527
+ """Test cases for _fetch_file_from_url with filename truncation."""
1528
+
1529
+ @patch("composio.core.models._files.requests.get")
1530
+ def test_fetch_truncates_long_filename(self, mock_get):
1531
+ """Long filenames from URLs should be truncated."""
1532
+ mock_response = MagicMock()
1533
+ mock_response.ok = True
1534
+ mock_response.content = b"test content"
1535
+ mock_response.headers = {"content-type": "application/pdf"}
1536
+ mock_get.return_value = mock_response
1537
+
1538
+ # Create a very long filename (hash-based, common in public buckets)
1539
+ long_filename = "8f14e45fceea167a5a36dedd4bea2543" * 5 + ".pdf"
1540
+
1541
+ filename, content, mimetype = _fetch_file_from_url(
1542
+ f"https://bucket.example.com/files/{long_filename}"
1543
+ )
1544
+
1545
+ assert len(filename) <= _MAX_FILENAME_LENGTH
1546
+ assert filename.startswith("file_")
1547
+ assert filename.endswith(".pdf")
1548
+ assert content == b"test content"
1549
+
1550
+ @patch("composio.core.models._files.requests.get")
1551
+ def test_fetch_preserves_short_filename(self, mock_get):
1552
+ """Short filenames should be preserved unchanged."""
1553
+ mock_response = MagicMock()
1554
+ mock_response.ok = True
1555
+ mock_response.content = b"image data"
1556
+ mock_response.headers = {"content-type": "image/jpeg"}
1557
+ mock_get.return_value = mock_response
1558
+
1559
+ filename, content, mimetype = _fetch_file_from_url(
1560
+ "https://example.com/photo.jpg"
1561
+ )
1562
+
1563
+ assert filename == "photo.jpg"
1564
+
1565
+ @patch("composio.core.models._files.requests.get")
1566
+ def test_fetch_truncates_after_adding_extension(self, mock_get):
1567
+ """Truncation should happen after extension is appended."""
1568
+ mock_response = MagicMock()
1569
+ mock_response.ok = True
1570
+ mock_response.content = b"pdf content"
1571
+ mock_response.headers = {"content-type": "application/pdf"}
1572
+ mock_get.return_value = mock_response
1573
+
1574
+ # URL without extension - extension will be added from mimetype
1575
+ long_name_no_ext = "8f14e45fceea167a5a36dedd4bea2543" * 4
1576
+ filename, content, mimetype = _fetch_file_from_url(
1577
+ f"https://bucket.example.com/{long_name_no_ext}"
1578
+ )
1579
+
1580
+ # Should be truncated and have .pdf extension
1581
+ assert len(filename) <= _MAX_FILENAME_LENGTH
1582
+ assert filename.endswith(".pdf")
1583
+
1584
+ @patch("composio.core.models._files.requests.get")
1585
+ def test_fetch_generated_filename_not_truncated(self, mock_get):
1586
+ """Generated timestamped filenames (when URL has no filename) should be short enough."""
1587
+ mock_response = MagicMock()
1588
+ mock_response.ok = True
1589
+ mock_response.content = b"data"
1590
+ mock_response.headers = {"content-type": "image/png"}
1591
+ mock_get.return_value = mock_response
1592
+
1593
+ # URL with no filename - will generate a timestamped one
1594
+ filename, content, mimetype = _fetch_file_from_url("https://example.com/")
1595
+
1596
+ # Generated filename should be naturally short
1597
+ assert filename.startswith("file_")
1598
+ assert filename.endswith(".png")
1599
+ assert len(filename) < 50 # Timestamped names are short