Remove dead code from Table class

Remove unused methods that were superseded by AttributeType system:
- _process_object_value (replaced by ObjectType.encode)
- _build_object_url (only used by _process_object_value)
- get_object_storage (only used by _process_object_value)
- object_storage property (wrapper for get_object_storage)

Also removed unused imports: mimetypes, datetime, timezone,
StorageBackend, build_object_path, verify_or_create_store_metadata

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: dimitri-yatsenko

src/datajoint/table.py

@@ -4,10 +4,8 @@
 import itertools
 import json
 import logging
-import mimetypes
 import re
 import uuid
-from datetime import datetime, timezone
 from pathlib import Path
 
 import numpy as np
@@ -26,7 +24,6 @@
 from .heading import Heading
 from .settings import config
 from .staged_insert import staged_insert1 as _staged_insert1
-from .storage import StorageBackend, build_object_path, verify_or_create_store_metadata
 from .utils import get_master, is_camel_case, user_choice
 
 logger = logging.getLogger(__name__.split(".")[0])
@@ -255,179 +252,6 @@ def full_table_name(self):
             )
         return r"`{0:s}`.`{1:s}`".format(self.database, self.table_name)
 
-    @property
-    def object_storage(self) -> StorageBackend | None:
-        """Get the default object storage backend for this table."""
-        return self.get_object_storage()
-
-    def get_object_storage(self, store_name: str | None = None) -> StorageBackend | None:
-        """
-        Get the object storage backend for a specific store.
-
-        Args:
-            store_name: Name of the store (None for default store)
-
-        Returns:
-            StorageBackend instance or None if not configured
-        """
-        cache_key = f"_object_storage_{store_name or 'default'}"
-        if not hasattr(self, cache_key):
-            try:
-                spec = config.get_object_store_spec(store_name)
-                backend = StorageBackend(spec)
-                # Verify/create store metadata on first use
-                verify_or_create_store_metadata(backend, spec)
-                setattr(self, cache_key, backend)
-            except DataJointError:
-                setattr(self, cache_key, None)
-        return getattr(self, cache_key)
-
-    def _process_object_value(self, name: str, value, row: dict, store_name: str | None = None) -> str:
-        """
-        Process an object attribute value for insert.
-
-        Args:
-            name: Attribute name
-            value: Input value (file path, folder path, or (ext, stream) tuple)
-            row: The full row dict (needed for primary key values)
-            store_name: Name of the object store (None for default store)
-
-        Returns:
-            JSON string for database storage
-        """
-        backend = self.get_object_storage(store_name)
-        if backend is None:
-            store_desc = f"'{store_name}'" if store_name else "default"
-            raise DataJointError(
-                f"Object storage ({store_desc}) is not configured. Set object_storage settings in datajoint.json "
-                "or DJ_OBJECT_STORAGE_* environment variables."
-            )
-
-        # Extract primary key values from row
-        primary_key = {k: row[k] for k in self.primary_key if k in row}
-        if not primary_key:
-            raise DataJointError("Primary key values must be provided before object attributes for insert.")
-
-        # Determine input type and extract extension
-        is_dir = False
-        ext = None
-        size = 0
-        source_path = None
-        stream = None
-
-        if isinstance(value, tuple) and len(value) == 2:
-            # Tuple of (ext, stream)
-            ext, stream = value
-            if hasattr(stream, "read"):
-                # Read stream to buffer for upload
-                content = stream.read()
-                size = len(content)
-            else:
-                raise DataJointError(f"Invalid stream object for attribute {name}")
-        elif isinstance(value, (str, Path)):
-            source_path = Path(value)
-            if not source_path.exists():
-                raise DataJointError(f"File or folder not found: {source_path}")
-            is_dir = source_path.is_dir()
-            if not is_dir:
-                ext = source_path.suffix or None
-                size = source_path.stat().st_size
-        else:
-            raise DataJointError(
-                f"Invalid value type for object attribute {name}. Expected file path, folder path, or (ext, stream) tuple."
-            )
-
-        # Get storage spec for path building
-        spec = config.get_object_store_spec(store_name)
-        partition_pattern = spec.get("partition_pattern")
-        token_length = spec.get("token_length", 8)
-        location = spec.get("location", "")
-
-        # Build storage path
-        relative_path, token = build_object_path(
-            schema=self.database,
-            table=self.class_name,
-            field=name,
-            primary_key=primary_key,
-            ext=ext,
-            partition_pattern=partition_pattern,
-            token_length=token_length,
-        )
-
-        # Prepend location if specified
-        full_storage_path = f"{location}/{relative_path}" if location else relative_path
-
-        # Upload content
-        manifest = None
-        if source_path:
-            if is_dir:
-                manifest = backend.put_folder(source_path, full_storage_path)
-                size = manifest["total_size"]
-            else:
-                backend.put_file(source_path, full_storage_path)
-        elif stream:
-            backend.put_buffer(content, full_storage_path)
-
-        # Build full URL for the object
-        url = self._build_object_url(spec, full_storage_path)
-
-        # Build JSON metadata
-        timestamp = datetime.now(timezone.utc).isoformat()
-        metadata = {
-            "path": full_storage_path,
-            "size": size,
-            "hash": None,  # Hash is optional, not computed by default
-            "ext": ext,
-            "is_dir": is_dir,
-            "timestamp": timestamp,
-        }
-
-        # Add URL and store name
-        if url:
-            metadata["url"] = url
-        if store_name:
-            metadata["store"] = store_name
-
-        # Add mime_type for files
-        if not is_dir and ext:
-            mime_type, _ = mimetypes.guess_type(f"file{ext}")
-            if mime_type:
-                metadata["mime_type"] = mime_type
-
-        # Add item_count for folders
-        if is_dir and manifest:
-            metadata["item_count"] = manifest["item_count"]
-
-        return json.dumps(metadata)
-
-    def _build_object_url(self, spec: dict, path: str) -> str | None:
-        """
-        Build a full URL for an object based on the storage spec.
-
-        Args:
-            spec: Storage configuration dict
-            path: Path within the storage
-
-        Returns:
-            Full URL string or None for local storage
-        """
-        protocol = spec.get("protocol", "")
-        if protocol == "s3":
-            bucket = spec.get("bucket", "")
-            return f"s3://{bucket}/{path}"
-        elif protocol == "gcs":
-            bucket = spec.get("bucket", "")
-            return f"gs://{bucket}/{path}"
-        elif protocol == "azure":
-            container = spec.get("container", "")
-            return f"az://{container}/{path}"
-        elif protocol == "file":
-            # For local storage, return file:// URL
-            location = spec.get("location", "")
-            full_path = f"{location}/{path}" if location else path
-            return f"file://{full_path}"
-        return None
-
     def update1(self, row):
         """
         ``update1`` updates one existing entry in the table.