pixeltable 0.2.11__tar.gz → 0.2.12__tar.gz

{pixeltable-0.2.11 → pixeltable-0.2.12}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.2.11
+Version: 0.2.12
 Summary: Pixeltable: The Multimodal AI Data Plane
-Author: Marcel Kornacker
-Author-email: marcelk@gmail.com
+Author: Pixeltable, Inc.
+Author-email: contact@pixeltable.com
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/__init__.py

@@ -3,8 +3,8 @@ from .dataframe import DataFrame
 from .exceptions import Error
 from .exprs import RELATIVE_PATH_ROOT
 from .func import Function, udf, Aggregator, uda, expr_udf
-from .globals import init, create_table, create_view, get_table, move, drop_table, list_tables, create_dir, rm_dir, \
-    list_dirs, list_functions, get_path, configure_logging
+from .globals import init, create_table, create_view, get_table, move, drop_table, list_tables, create_dir, drop_dir, \
+    list_dirs, list_functions, configure_logging
 from .type_system import (
     ColumnType,
     StringType,

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/__version__.py

@@ -1,3 +1,3 @@
 # These version placeholders will be replaced during build.
-__version__ = "0.2.11"
-__version_tuple__ = (0, 2, 11)
+__version__ = "0.2.12"
+__version_tuple__ = (0, 2, 12)

pixeltable-0.2.12/pixeltable/catalog/schema_object.py

@@ -0,0 +1,60 @@
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Optional
+from uuid import UUID
+
+if TYPE_CHECKING:
+    from pixeltable import catalog
+
+
+class SchemaObject:
+    """
+    Base class of all addressable objects within a Db.
+    Each object has an id, a name and a parent directory.
+    """
+    def __init__(self, obj_id: UUID, name: str, dir_id: Optional[UUID]):
+        # make these private so they don't collide with column names (id and name are fairly common)
+        self._id = obj_id
+        self._name = name
+        self._dir_id = dir_id
+
+    def _get_id(self) -> UUID:
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Returns the name of this schema object."""
+        return self._name
+
+    @property
+    def parent(self) -> Optional['catalog.Dir']:
+        """Returns the parent directory of this schema object."""
+        from pixeltable import catalog
+        if self._dir_id is None:
+            return None
+        dir = catalog.Catalog.get().paths.get_schema_obj(self._dir_id)
+        assert isinstance(dir, catalog.Dir)
+        return dir
+
+    @property
+    def path(self) -> str:
+        """Returns the path to this schema object."""
+        parent = self.parent
+        if parent is None or parent.parent is None:
+            # Either this is the root directory, with empty path, or its parent is the
+            # root directory. Either way, we return just the name.
+            return self.name
+        else:
+            return f'{parent.path}.{self.name}'
+
+    @classmethod
+    @abstractmethod
+    def display_name(cls) -> str:
+        """
+        Return name displayed in error messages.
+        """
+        pass
+
+    def _move(self, new_name: str, new_dir_id: UUID) -> None:
+        """Subclasses need to override this to make the change persistent"""
+        self._name = new_name
+        self._dir_id = new_dir_id

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/catalog/table.py

@@ -82,14 +82,22 @@ class Table(SchemaObject):
             return self._queries[index]
         return self._tbl_version_path.__getitem__(index)
 
-    def get_views(self, *, recursive: bool = False) -> list['Table']:
+    def list_views(self, *, recursive: bool = True) -> list[str]:
         """
-        All views and snapshots of this `Table`.
+        Returns a list of all views and snapshots of this `Table`.
+
+        Args:
+            recursive: If `False`, returns only the immediate successor views of this `Table`. If `True`, returns
+                all sub-views (including views of views, etc.)
         """
+        return [t.path for t in self._get_views(recursive=recursive)]
+
+    def _get_views(self, *, recursive: bool = True) -> list['Table']:
+        dependents = catalog.Catalog.get().tbl_dependents[self._get_id()]
         if recursive:
-            return [self] + [t for view in self.get_views(recursive=False) for t in view.get_views(recursive=True)]
+            return dependents + [t for view in dependents for t in view._get_views(recursive=True)]
         else:
-            return catalog.Catalog.get().tbl_dependents[self._get_id()]
+            return dependents
 
     def _df(self) -> 'pixeltable.dataframe.DataFrame':
         """Return a DataFrame for this table.
@@ -500,7 +508,37 @@ class Table(SchemaObject):
             >>> tbl.drop_column('factorial')
         """
         self._check_is_dropped()
-        self._tbl_version.drop_column(name)
+
+        if name not in self._tbl_version.cols_by_name:
+            raise excs.Error(f'Unknown column: {name}')
+        col = self._tbl_version.cols_by_name[name]
+
+        dependent_user_cols = [c for c in col.dependent_cols if c.name is not None]
+        if len(dependent_user_cols) > 0:
+            raise excs.Error(
+                f'Cannot drop column `{name}` because the following columns depend on it:\n'
+                f'{", ".join(c.name for c in dependent_user_cols)}'
+            )
+
+        # See if this column has a dependent store. We need to look through all stores in all
+        # (transitive) views of this table.
+        dependent_stores = [
+            (view, store)
+            for view in [self] + self._get_views(recursive=True)
+            for store in view._tbl_version.external_stores.values()
+            if col in store.get_local_columns()
+        ]
+        if len(dependent_stores) > 0:
+            dependent_store_names = [
+                store.name if view._get_id() == self._get_id() else f'{store.name} (in view `{view.name}`)'
+                for view, store in dependent_stores
+            ]
+            raise excs.Error(
+                f'Cannot drop column `{name}` because the following external stores depend on it:\n'
+                f'{", ".join(dependent_store_names)}'
+            )
+
+        self._tbl_version.drop_column(col)
 
     def rename_column(self, old_name: str, new_name: str) -> None:
         """Rename a column.
@@ -522,15 +560,15 @@ class Table(SchemaObject):
 
     def add_embedding_index(
             self, col_name: str, *, idx_name: Optional[str] = None,
-            text_embed: Optional[pixeltable.Function] = None, img_embed: Optional[pixeltable.Function] = None,
+            string_embed: Optional[pixeltable.Function] = None, image_embed: Optional[pixeltable.Function] = None,
             metric: str = 'cosine'
     ) -> None:
         """Add an index to the table.
         Args:
             col_name: name of column to index
             idx_name: name of index, which needs to be unique for the table; if not provided, a name will be generated
-            text_embed: function to embed text; required if the column is a text column
-            img_embed: function to embed images; required if the column is an image column
+            string_embed: function to embed text; required if the column is a text column
+            image_embed: function to embed images; required if the column is an image column
             metric: distance metric to use for the index; one of 'cosine', 'ip', 'l2'; default is 'cosine'
 
         Raises:
@@ -539,13 +577,13 @@ class Table(SchemaObject):
         Examples:
             Add an index to the ``img`` column:
 
-            >>> tbl.add_embedding_index('img', img_embed=...)
+            >>> tbl.add_embedding_index('img', image_embed=...)
 
             Add another index to the ``img`` column, using the inner product as the distance metric,
-            and with a specific name; ``text_embed`` is also specified in order to search with text:
+            and with a specific name; ``string_embed`` is also specified in order to search with text:
 
             >>> tbl.add_embedding_index(
-                'img', idx_name='clip_idx', img_embed=..., text_embed=...text_embed..., metric='ip')
+                'img', idx_name='clip_idx', image_embed=..., string_embed=..., metric='ip')
         """
         if self._tbl_version_path.is_snapshot():
             raise excs.Error('Cannot add an index to a snapshot')
@@ -557,7 +595,7 @@ class Table(SchemaObject):
             raise excs.Error(f'Duplicate index name: {idx_name}')
         from pixeltable.index import EmbeddingIndex
         # create the EmbeddingIndex instance to verify args
-        idx = EmbeddingIndex(col, metric=metric, text_embed=text_embed, img_embed=img_embed)
+        idx = EmbeddingIndex(col, metric=metric, string_embed=string_embed, image_embed=image_embed)
         status = self._tbl_version.add_index(col, idx_name=idx_name, idx=idx)
         # TODO: how to deal with exceptions here? drop the index and raise?
 
@@ -604,26 +642,26 @@ class Table(SchemaObject):
             raise excs.Error('Cannot drop an index from a snapshot')
         self._check_is_dropped()
         if (column_name is None) == (idx_name is None):
-            raise excs.Error('Exactly one of column_name or idx_name must be provided')
+            raise excs.Error("Exactly one of 'column_name' or 'idx_name' must be provided")
 
         if idx_name is not None:
             if idx_name not in self._tbl_version.idxs_by_name:
-                raise excs.Error(f'Index {idx_name} does not exist')
+                raise excs.Error(f'Index {idx_name!r} does not exist')
             idx_id = self._tbl_version.idxs_by_name[idx_name].id
         else:
             col = self._tbl_version_path.get_column(column_name, include_bases=True)
             if col is None:
-                raise excs.Error(f'Column {column_name} unknown')
+                raise excs.Error(f'Column {column_name!r} unknown')
             if col.tbl.id != self._tbl_version.id:
                 raise excs.Error(
-                    f'Column {column_name}: cannot drop index from column that belongs to base ({col.tbl.name})')
+                    f'Column {column_name!r}: cannot drop index from column that belongs to base ({col.tbl.name}!r)')
             idx_info = [info for info in self._tbl_version.idxs_by_name.values() if info.col.id == col.id]
             if _idx_class is not None:
                 idx_info = [info for info in idx_info if isinstance(info.idx, _idx_class)]
             if len(idx_info) == 0:
-                raise excs.Error(f'Column {column_name} does not have an index')
+                raise excs.Error(f'Column {column_name!r} does not have an index')
             if len(idx_info) > 1:
-                raise excs.Error(f'Column {column_name} has multiple indices; specify idx_name instead')
+                raise excs.Error(f"Column {column_name!r} has multiple indices; specify 'idx_name' instead")
             idx_id = idx_info[0].id
         self._tbl_version.drop_index(idx_id)
 
@@ -823,13 +861,13 @@ class Table(SchemaObject):
         Links the specified `ExternalStore` to this table.
         """
         if self._tbl_version.is_snapshot:
-            raise excs.Error(f'Table `{self.get_name()}` is a snapshot, so it cannot be linked to an external store.')
+            raise excs.Error(f'Table `{self.name}` is a snapshot, so it cannot be linked to an external store.')
         self._check_is_dropped()
         if store.name in self.external_stores:
-            raise excs.Error(f'Table `{self.get_name()}` already has an external store with that name: {store.name}')
-        _logger.info(f'Linking external store `{store.name}` to table `{self.get_name()}`')
+            raise excs.Error(f'Table `{self.name}` already has an external store with that name: {store.name}')
+        _logger.info(f'Linking external store `{store.name}` to table `{self.name}`')
         self._tbl_version.link_external_store(store)
-        print(f'Linked external store `{store.name}` to table `{self.get_name()}`.')
+        print(f'Linked external store `{store.name}` to table `{self.name}`.')
 
     def unlink_external_stores(
             self,
@@ -861,11 +899,11 @@ class Table(SchemaObject):
         if not ignore_errors:
             for store in stores:
                 if store not in all_stores:
-                    raise excs.Error(f'Table `{self.get_name()}` has no external store with that name: {store}')
+                    raise excs.Error(f'Table `{self.name}` has no external store with that name: {store}')
 
         for store in stores:
             self._tbl_version.unlink_external_store(store, delete_external_data=delete_external_data)
-            print(f'Unlinked external store from table `{self.get_name()}`: {store}')
+            print(f'Unlinked external store from table `{self.name}`: {store}')
 
     def sync(
             self,
@@ -893,7 +931,7 @@ class Table(SchemaObject):
 
         for store in stores:
             if store not in all_stores:
-                raise excs.Error(f'Table `{self.get_name()}` has no external store with that name: {store}')
+                raise excs.Error(f'Table `{self.name}` has no external store with that name: {store}')
 
         from pixeltable.io import SyncStatus
 

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/catalog/table_version.py

@@ -540,39 +540,12 @@ class TableVersion:
             num_rows=row_count, num_computed_values=row_count, num_excs=num_excs,
             cols_with_excs=[f'{col.tbl.name}.{col.name}'for col in cols_with_excs if col.name is not None])
 
-    def drop_column(self, name: str) -> None:
+    def drop_column(self, col: Column) -> None:
         """Drop a column from the table.
         """
         from pixeltable.catalog import Catalog
 
         assert not self.is_snapshot
-        if name not in self.cols_by_name:
-            raise excs.Error(f'Unknown column: {name}')
-        col = self.cols_by_name[name]
-        dependent_user_cols = [c for c in col.dependent_cols if c.name is not None]
-        if len(dependent_user_cols) > 0:
-            raise excs.Error(
-                f'Cannot drop column `{name}` because the following columns depend on it:\n'
-                f'{", ".join(c.name for c in dependent_user_cols)}'
-            )
-        # See if this column has a dependent store. We need to look through all stores in all
-        # (transitive) views of this table.
-        transitive_views = Catalog.get().tbls[self.id].get_views(recursive=True)
-        dependent_stores = [
-            (view, store)
-            for view in transitive_views
-            for store in view._tbl_version.external_stores.values()
-            if col in store.get_local_columns()
-        ]
-        if len(dependent_stores) > 0:
-            dependent_store_names = [
-                store.name if view._get_id() == self.id else f'{store.name} (in view `{view.get_name()}`)'
-                for view, store in dependent_stores
-            ]
-            raise excs.Error(
-                f'Cannot drop column `{name}` because the following external stores depend on it:\n'
-                f'{", ".join(dependent_store_names)}'
-            )
 
         # we're creating a new schema version
         self.version += 1
@@ -596,7 +569,7 @@ class TableVersion:
                 del self.idxs_by_name[idx_name]
             self._drop_columns(dropped_cols)
             self._update_md(time.time(), conn, preceding_schema_version=preceding_schema_version)
-        _logger.info(f'Dropped column {name} from table {self.name}, new version: {self.version}')
+        _logger.info(f'Dropped column {col.name} from table {self.name}, new version: {self.version}')
 
     def _drop_columns(self, cols: Iterable[Column]) -> None:
         """Mark columns as dropped"""

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/dataframe.py

@@ -558,7 +558,7 @@ class DataFrame:
                 # we need to make sure that the grouping table is a base of self.tbl
                 base = self.tbl.find_tbl_version(item._tbl_version_path.tbl_id())
                 if base is None or base.id == self.tbl.tbl_id():
-                    raise excs.Error(f'group_by(): {item.get_name()} is not a base table of {self.tbl.tbl_name()}')
+                    raise excs.Error(f'group_by(): {item.name} is not a base table of {self.tbl.tbl_name()}')
                 grouping_tbl = item._tbl_version_path.tbl_version
                 break
             if not isinstance(item, exprs.Expr):

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/exprs/column_ref.py

@@ -63,14 +63,9 @@ class ColumnRef(Expr):
 
         return super().__getattr__(name)
 
-    def similarity(self, other: Any) -> Expr:
-        # if isinstance(other, Expr):
-        #     raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not an expression')
-        item = Expr.from_object(other)
-        if item is None or not(item.col_type.is_string_type() or item.col_type.is_image_type()):
-            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not a {type(other)}')
+    def similarity(self, item: Any, *, idx: Optional[str] = None) -> Expr:
         from .similarity_expr import SimilarityExpr
-        return SimilarityExpr(self, item)
+        return SimilarityExpr(self, item, idx_name=idx)
 
     def default_column_name(self) -> Optional[str]:
         return str(self)

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/exprs/similarity_expr.py

@@ -1,4 +1,4 @@
-from typing import Optional, List
+from typing import Optional, List, Any
 
 import sqlalchemy as sql
 import PIL.Image
@@ -14,33 +14,44 @@ from .row_builder import RowBuilder
 
 class SimilarityExpr(Expr):
 
-    def __init__(self, col_ref: ColumnRef, item: Expr):
+    def __init__(self, col_ref: ColumnRef, item: Any, idx_name: Optional[str] = None):
         super().__init__(ts.FloatType())
-        self.components = [col_ref, item]
+        item_expr = Expr.from_object(item)
+        if item_expr is None or not(item_expr.col_type.is_string_type() or item_expr.col_type.is_image_type()):
+            raise excs.Error(f'similarity(): requires a string or a PIL.Image.Image object, not a {type(item)}')
+        assert item_expr.col_type.is_string_type() or item_expr.col_type.is_image_type()
+
+        self.components = [col_ref, item_expr]
         self.id = self._create_id()
-        assert item.col_type.is_string_type() or item.col_type.is_image_type()
 
         # determine index to use
         idx_info = col_ref.col.get_idx_info()
         import pixeltable.index as index
-        embedding_idx_info = [info for info in idx_info.values() if isinstance(info.idx, index.EmbeddingIndex)]
+        embedding_idx_info = {
+            info.name: info for info in idx_info.values() if isinstance(info.idx, index.EmbeddingIndex)
+        }
         if len(embedding_idx_info) == 0:
-            raise excs.Error(f'No index found for column {col_ref.col}')
+            raise excs.Error(f'No index found for column {col_ref.col!r}')
+        if idx_name is not None and idx_name not in embedding_idx_info:
+            raise excs.Error(f'Index {idx_name!r} not found for column {col_ref.col.name!r}')
         if len(embedding_idx_info) > 1:
-            raise excs.Error(
-                f'Column {col_ref.col.name} has multiple indices; use the index name to disambiguate, '
-                f'e.g., `{col_ref.col.name}.<index-name>.similarity(...)`')
-        self.idx_info = embedding_idx_info[0]
+            if idx_name is None:
+                raise excs.Error(
+                    f'Column {col_ref.col.name!r} has multiple indices; use the index name to disambiguate: '
+                    f'`{col_ref.col.name}.similarity(..., idx=<name>)`')
+            self.idx_info = embedding_idx_info[idx_name]
+        else:
+            self.idx_info = next(iter(embedding_idx_info.values()))
         idx = self.idx_info.idx
 
-        if item.col_type.is_string_type() and idx.txt_embed is None:
+        if item_expr.col_type.is_string_type() and idx.string_embed is None:
             raise excs.Error(
-                f'Embedding index {self.idx_info.name} on column {self.idx_info.col.name} was created without the '
-                f'text_embed parameter and does not support text queries')
-        if item.col_type.is_image_type() and idx.img_embed is None:
+                f'Embedding index {self.idx_info.name!r} on column {self.idx_info.col.name!r} was created without the '
+                f"'string_embed' parameter and does not support string queries")
+        if item_expr.col_type.is_image_type() and idx.image_embed is None:
             raise excs.Error(
-                f'Embedding index {self.idx_info.name} on column {self.idx_info.col.name} was created without the '
-                f'img_embed parameter and does not support image queries')
+                f'Embedding index {self.idx_info.name!r} on column {self.idx_info.col.name!r} was created without the '
+                f"'image_embed' parameter and does not support image queries")
 
     def __str__(self) -> str:
         return f'{self.components[0]}.similarity({self.components[1]})'

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/functions/openai.py

@@ -141,7 +141,7 @@ def chat_completions(
 
 
 @pxt.udf
-def vision(prompt: str, image: PIL.Image.Image, *, model: str = 'gpt-4-vision-preview') -> str:
+def vision(prompt: str, image: PIL.Image.Image, *, model: str) -> str:
     # TODO(aaron-siegel): Decompose CPU/GPU ops into separate functions
     bytes_arr = io.BytesIO()
     image.save(bytes_arr, format='png')

{pixeltable-0.2.11 → pixeltable-0.2.12}/pixeltable/globals.py

@@ -234,7 +234,7 @@ def drop_table(path: str, force: bool = False, ignore_errors: bool = False) -> N
 
     Args:
         path: Path to the table.
-        force: Whether to drop the table even if it has unsaved changes.
+        force: If `True`, will also drop all views or sub-views of this table.
         ignore_errors: Whether to ignore errors if the table does not exist.
 
     Raises:
@@ -243,21 +243,27 @@ def drop_table(path: str, force: bool = False, ignore_errors: bool = False) -> N
     Examples:
         >>> cl.drop_table('my_table')
     """
+    cat = Catalog.get()
     path_obj = catalog.Path(path)
     try:
-        Catalog.get().paths.check_is_valid(path_obj, expected=catalog.Table)
+        cat.paths.check_is_valid(path_obj, expected=catalog.Table)
     except Exception as e:
-        if ignore_errors:
+        if ignore_errors or force:
             _logger.info(f'Skipped table `{path}` (does not exist).')
             return
         else:
             raise e
-    tbl = Catalog.get().paths[path_obj]
-    if len(Catalog.get().tbl_dependents[tbl._id]) > 0:
-        dependent_paths = [get_path(dep) for dep in Catalog.get().tbl_dependents[tbl._id]]
-        raise excs.Error(f'Table {path} has dependents: {", ".join(dependent_paths)}')
+    tbl = cat.paths[path_obj]
+    assert isinstance(tbl, catalog.Table)
+    if len(cat.tbl_dependents[tbl._id]) > 0:
+        dependent_paths = [dep.path for dep in cat.tbl_dependents[tbl._id]]
+        if force:
+            for dependent_path in dependent_paths:
+                drop_table(dependent_path, force=True)
+        else:
+            raise excs.Error(f'Table {path} has dependents: {", ".join(dependent_paths)}')
     tbl._drop()
-    del Catalog.get().paths[path_obj]
+    del cat.paths[path_obj]
     _logger.info(f'Dropped table `{path}`.')
 
 
@@ -291,7 +297,7 @@ def list_tables(dir_path: str = '', recursive: bool = True) -> list[str]:
     return [str(p) for p in Catalog.get().paths.get_children(path, child_type=catalog.Table, recursive=recursive)]
 
 
-def create_dir(path_str: str, ignore_errors: bool = False) -> None:
+def create_dir(path_str: str, ignore_errors: bool = False) -> catalog.Dir:
     """Create a directory.
 
     Args:
@@ -319,10 +325,12 @@ def create_dir(path_str: str, ignore_errors: bool = False) -> None:
             session.add(dir_record)
             session.flush()
             assert dir_record.id is not None
-            Catalog.get().paths[path] = catalog.Dir(dir_record.id, parent._id, path.name)
+            dir = catalog.Dir(dir_record.id, parent._id, path.name)
+            Catalog.get().paths[path] = dir
             session.commit()
             _logger.info(f'Created directory `{path_str}`.')
             print(f'Created directory `{path_str}`.')
+            return dir
     except excs.Error as e:
         if ignore_errors:
             return
@@ -330,7 +338,7 @@ def create_dir(path_str: str, ignore_errors: bool = False) -> None:
             raise e
 
 
-def rm_dir(path_str: str) -> None:
+def drop_dir(path_str: str, force: bool = False, ignore_errors: bool = False) -> None:
     """Remove a directory.
 
     Args:
@@ -340,31 +348,49 @@ def rm_dir(path_str: str) -> None:
         Error: If the path does not exist or does not designate a directory or if the directory is not empty.
 
     Examples:
-        >>> cl.rm_dir('my_dir')
+        >>> cl.drop_dir('my_dir')
 
         Remove a subdirectory:
 
-        >>> cl.rm_dir('my_dir.sub_dir')
+        >>> cl.drop_dir('my_dir.sub_dir')
     """
+    cat = Catalog.get()
     path = catalog.Path(path_str)
-    Catalog.get().paths.check_is_valid(path, expected=catalog.Dir)
 
-    # make sure it's empty
-    if len(Catalog.get().paths.get_children(path, child_type=None, recursive=True)) > 0:
-        raise excs.Error(f'Directory {path_str} is not empty')
-    # TODO: figure out how to make force=True work in the presence of snapshots
-    #        # delete tables
-    #        for tbl_path in self.paths.get_children(path, child_type=MutableTable, recursive=True):
-    #            self.drop_table(str(tbl_path), force=True)
-    #        # rm subdirs
-    #        for dir_path in self.paths.get_children(path, child_type=Dir, recursive=False):
-    #            self.rm_dir(str(dir_path), force=True)
+    try:
+        cat.paths.check_is_valid(path, expected=catalog.Dir)
+    except Exception as e:
+        if ignore_errors or force:
+            _logger.info(f'Skipped directory `{path}` (does not exist).')
+            return
+        else:
+            raise e
+
+    children = cat.paths.get_children(path, child_type=None, recursive=True)
+
+    if len(children) > 0 and not force:
+        raise excs.Error(f'Directory `{path_str}` is not empty.')
+
+    for child in children:
+        assert isinstance(child, catalog.Path)
+        # We need to check that the child is still in `cat.paths`, since it is possible it was
+        # already deleted as a dependent of a preceding child in the iteration.
+        try:
+            obj = cat.paths[child]
+        except excs.Error:
+            continue
+        if isinstance(obj, catalog.Dir):
+            drop_dir(str(child), force=True)
+        else:
+            assert isinstance(obj, catalog.Table)
+            assert not obj._is_dropped  # else it should have been removed from `cat.paths` already
+            drop_table(str(child), force=True)
 
     with Env.get().engine.begin() as conn:
         dir = Catalog.get().paths[path]
         conn.execute(sql.delete(schema.Dir.__table__).where(schema.Dir.id == dir._id))
     del Catalog.get().paths[path]
-    _logger.info(f'Removed directory {path_str}')
+    _logger.info(f'Removed directory `{path_str}`.')
 
 
 def list_dirs(path_str: str = '', recursive: bool = True) -> list[str]:
@@ -416,28 +442,6 @@ def list_functions() -> pd.DataFrame:
     return pd_df.hide(axis='index')
 
 
-def get_path(schema_obj: catalog.SchemaObject) -> str:
-    """Returns the path to a SchemaObject.
-
-    Args:
-        schema_obj: SchemaObject to get the path for.
-
-    Returns:
-        Path to the SchemaObject.
-    """
-    path_elements: list[str] = []
-    dir_id = schema_obj._dir_id
-    while dir_id is not None:
-        dir = Catalog.get().paths.get_schema_obj(dir_id)
-        if dir._dir_id is None:
-            # this is the root dir with name '', which we don't want to include in the path
-            break
-        path_elements.insert(0, dir._name)
-        dir_id = dir._dir_id
-    path_elements.append(schema_obj._name)
-    return '.'.join(path_elements)
-
-
 def configure_logging(
     *,
     to_stdout: Optional[bool] = None,