@devries-cameron20 / composio Mirror · read-only / commits / 6e4cc38f0
Fork 0

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