Update based on libtiledb latest

Author: kounelisagis

tiledb/__init__.py

@@ -25,7 +25,7 @@
     from .current_domain import CurrentDomain
     from .ndrectangle import NDRectangle
 
-if libtiledb_version()[0] == 2 and libtiledb_version()[1] >= 28:
+if libtiledb_version()[0] == 2 and libtiledb_version()[1] >= 29:
     from .profile import Profile
 
 del libtiledb_version  # no longer needed

tiledb/ctx.py

@@ -50,14 +50,24 @@ class Config(lt.Config):
 
     :param dict params: Set parameter values from dict like object
     :param str path: Set parameter values from persisted Config parameter file
+    :param str profile_name: Set the profile name to use for this Config object
+    :param str profile_dir: Set the profile directory to use for this Config object
     """
 
-    def __init__(self, params: dict = None, path: str = None):
+    def __init__(
+        self,
+        params: dict = None,
+        path: str = None,
+        profile_name: str = None,
+        profile_dir: str = None,
+    ):
         super().__init__()
         if path is not None:
             self.load(path)
         if params is not None:
             self.update(params)
+        if profile_name is not None or profile_dir is not None:
+            self._set_profile(profile_name, profile_dir)
 
     @staticmethod
     def load(uri: str):
@@ -293,6 +303,17 @@ def save(self, uri: str):
         """
         self.save_to_file(uri)
 
+    def set_profile(self, profile_name: str = None, profile_dir: str = None):
+        """
+        Sets the profile to use for the current Config object.
+        :param profile_name: The name of the profile to use. If not provided,
+        the default profile will be used.
+        :param profile_dir: The directory where the profile is located. If not
+        provided, the home directory will be used.
+        :raises tiledb.TileDBError: If the profile cannot be found or loaded.
+        """
+        self._set_profile(profile_name, profile_dir)
+
     def __reduce__(self):
         """
         Customize the pickling process by defining how to serialize

tiledb/libtiledb/context.cc

@@ -53,6 +53,13 @@ void init_config(py::module& m) {
             })
 
         .def("save_to_file", &Config::save_to_file)
+
+        .def(
+            "_set_profile",
+            &Config::set_profile,
+            py::arg("profile_name") = std::nullopt,
+            py::arg("profile_dir") = std::nullopt)
+
         .def("__eq__", &Config::operator==)
         .def("__ne__", &Config::operator!=)
         //.def("_ptr", &Config::ptr) // TBD should this be capsule?

tiledb/libtiledb/profile.cc

@@ -14,17 +14,19 @@ using namespace tiledbpy::common;
 namespace py = pybind11;
 
 void init_profile(py::module& m) {
+#if TILEDB_VERSION_MAJOR >= 2 && TILEDB_VERSION_MINOR >= 29
     py::class_<tiledb::Profile>(m, "Profile")
 
         .def(
             py::init<std::optional<std::string>, std::optional<std::string>>(),
-            py::keep_alive<1, 2>())
+            py::arg("name") = std::nullopt,
+            py::arg("dir") = std::nullopt)
 
         .def(py::init<Profile>())
 
-        .def_property_readonly("_name", &tiledb::Profile::get_name)
+        .def_property_readonly("_name", &tiledb::Profile::name)
 
-        .def_property_readonly("_homedir", &tiledb::Profile::get_homedir)
+        .def_property_readonly("_dir", &tiledb::Profile::dir)
 
         .def(
             "_set_param",
@@ -42,11 +44,12 @@ void init_profile(py::module& m) {
                 std::optional<std::string>,
                 std::optional<std::string>>(&tiledb::Profile::load),
             py::arg("name") = std::nullopt,
-            py::arg("homedir") = std::nullopt)
+            py::arg("dir") = std::nullopt)
 
         .def("_remove", &tiledb::Profile::remove)
 
         .def("_dump", &tiledb::Profile::dump);
+#endif
 }
 
 }  // namespace libtiledbcpp

tiledb/profile.py

@@ -6,14 +6,14 @@ class Profile(lt.Profile):
     Represents a TileDB profile.
     """
 
-    def __init__(self, name: str = None, homedir: str = None):
+    def __init__(self, name: str = None, dir: str = None):
         """Class representing a TileDB profile.
 
         :param name: The name of the profile.
-        :param homedir: The home directory of the profile.
+        :param dir: The directory of the profile.
         :raises tiledb.TileDBError:
         """
-        super().__init__(name, homedir)
+        super().__init__(name, dir)
 
     @property
     def name(self):
@@ -24,12 +24,12 @@ def name(self):
         return self._name
 
     @property
-    def homedir(self):
-        """The home directory of the profile.
+    def dir(self):
+        """The directory of the profile.
 
         :rtype: str
         """
-        return self._homedir
+        return self._dir
 
     def __repr__(self):
         """String representation of the profile.
@@ -63,18 +63,18 @@ def save(self):
         self._save()
 
     @classmethod
-    def load(cls, name: str = None, homedir: str = None) -> "Profile":
+    def load(cls, name: str = None, dir: str = None) -> "Profile":
         """Loads a profile from storage.
 
         :param name: The name of the profile.
-        :param homedir: The home directory of the profile.
+        :param dir: The directory of the profile.
         :return: The loaded profile.
         :rtype: tiledb.Profile
         :raises tiledb.TileDBError:
         """
         # This is a workaround for the from_pybind11 method due to the fact
         # that this class does not inherit from CtxMixin, as is commonly done.
-        lt_obj = lt.Profile._load(name, homedir)
+        lt_obj = lt.Profile._load(name, dir)
         py_obj = cls.__new__(cls)
         lt.Profile.__init__(py_obj, lt_obj)
         return py_obj

tiledb/tests/test_profile.py

@@ -1,3 +1,4 @@
+import json
 from pathlib import Path
 
 import pytest
@@ -7,82 +8,126 @@
 
 from .common import DiskTestCase
 
-if not (lt.version()[0] == 2 and lt.version()[1] >= 28):
+if not (lt.version()[0] == 2 and lt.version()[1] >= 29):
     pytest.skip(
-        "Profile is only available in TileDB 2.28 and later",
+        "Profile is only available in TileDB 2.29 and later",
         allow_module_level=True,
     )
 
+"""
+Due to the nature of Profiles, they are touching the filesystem,
+so we need to be careful and not affect the user's Profiles.
+Thus we use DiskTestCase to create temporary directories.
+"""
+
 
 class ProfileTestCase(DiskTestCase):
     def setup_method(self):
         super().setup_method()
-        self.profile1 = tiledb.Profile()  # default profile
-        self.profile2 = tiledb.Profile("test_profile")  # named profile
-        self.profile3 = tiledb.Profile(
-            homedir=self.path("profile3_dir")
-        )  # profile with custom home directory
-        self.profile4 = tiledb.Profile(
-            "test_profile", self.path("profile4_dir")
-        )  # named profile with custom home directory
+        self.profile1 = tiledb.Profile(
+            dir=self.path("profile1_dir")
+        )  # profile with custom directory
+        self.profile2 = tiledb.Profile(
+            "profile2_name", self.path("profile2_dir")
+        )  # named profile with custom directory
 
 
 class ProfileTest(ProfileTestCase):
     def test_profile_name(self):
         assert self.profile1.name == "default"
-        assert self.profile2.name == "test_profile"
-        assert self.profile3.name == "default"
-        assert self.profile4.name == "test_profile"
+        assert self.profile2.name == "profile2_name"
 
-    def test_profile_homedir(self):
-        assert Path(self.profile1.homedir) == Path.home()
-        assert Path(self.profile2.homedir) == Path.home()
-        assert Path(self.profile3.homedir) == Path(self.path("profile3_dir"))
-        assert Path(self.profile4.homedir) == Path(self.path("profile4_dir"))
+    def test_profile_dir(self):
+        assert Path(self.profile1.dir) == Path(self.path("profile1_dir"))
+        assert Path(self.profile2.dir) == Path(self.path("profile2_dir"))
 
     def test_profile_set_get_param(self):
-        self.profile1["rest.username"] = "my_username"
-        assert self.profile1["rest.username"] == "my_username"
+        username = "my_username"
+        server_address = "https://myaddress.com"
 
-        self.profile3["rest.server_address"] = "https://myaddress.com"
-        assert self.profile3["rest.server_address"] == "https://myaddress.com"
+        self.profile1["rest.username"] = username
+        assert self.profile1["rest.username"] == username
 
-    def test_profile_repr(self):
-        self.profile1["rest.password"] = "testing_the_password"
-        self.profile1["rest.payer_namespace"] = "testing_the_namespace"
-        self.profile1["rest.server_address"] = "https://testing_the_address.com"
-        self.profile1["rest.token"] = "testing_the_token"
-        self.profile1["rest.username"] = "testing_the_username"
+        self.profile1["rest.server_address"] = server_address
+        assert self.profile1["rest.server_address"] == server_address
 
-        import json
+    def test_profile_repr(self):
+        password = "testing_the_password"
+        payer_namespace = "testing_the_namespace"
+        server_address = "https://testing_the_address.com"
+        token = "testing_the_token"
+        username = "testing_the_username"
+
+        self.profile1["rest.password"] = password
+        self.profile1["rest.payer_namespace"] = payer_namespace
+        self.profile1["rest.server_address"] = server_address
+        self.profile1["rest.token"] = token
+        self.profile1["rest.username"] = username
 
         goal_dict = {
             "default": {
-                "rest.password": "testing_the_password",
-                "rest.payer_namespace": "testing_the_namespace",
-                "rest.server_address": "https://testing_the_address.com",
-                "rest.token": "testing_the_token",
-                "rest.username": "testing_the_username",
+                "rest.password": password,
+                "rest.payer_namespace": payer_namespace,
+                "rest.server_address": server_address,
+                "rest.token": token,
+                "rest.username": username,
             }
         }
 
         assert goal_dict == json.loads(repr(self.profile1))
 
     def test_profile_set_save_load_get(self):
-        self.profile4["rest.token"] = "testing_the_token_for_profile4"
-        self.profile4["rest.payer_namespace"] = "testing_the_namespace_for_profile4"
+        token = "testing_the_token_for_profile2"
+        payer_namespace = "testing_the_namespace_for_profile2"
+        default_server_address = "https://api.tiledb.com"
+
+        self.profile2["rest.token"] = token
+        self.profile2["rest.payer_namespace"] = payer_namespace
 
         # save the profile
-        self.profile4.save()
-
-        # load
-        new_profile = tiledb.Profile.load("test_profile", self.path("profile4_dir"))
-        assert new_profile.name == "test_profile"
-        assert new_profile.homedir == self.path("profile4_dir")
-        assert new_profile["rest.username"] == ""
-        assert new_profile["rest.password"] == ""
-        assert new_profile["rest.server_address"] == "https://api.tiledb.com"
-        assert new_profile["rest.token"] == "testing_the_token_for_profile4"
-        assert (
-            new_profile["rest.payer_namespace"] == "testing_the_namespace_for_profile4"
-        )
+        self.profile2.save()
+
+        # load the profile
+        loaded_profile = tiledb.Profile.load("profile2_name", self.path("profile2_dir"))
+        assert loaded_profile.name == "profile2_name"
+        assert loaded_profile.dir == self.path("profile2_dir")
+        assert loaded_profile["rest.username"] == ""
+        assert loaded_profile["rest.password"] == ""
+        assert loaded_profile["rest.server_address"] == default_server_address
+        assert loaded_profile["rest.token"] == token
+        assert loaded_profile["rest.payer_namespace"] == payer_namespace
+
+
+class ConfigWithProfileTest(ProfileTestCase):
+    def test_config_with_profile(self):
+        username = "username_coming_from_profile"
+        password = "password_coming_from_profile"
+        server_address = "https://profile_address.com"
+
+        # Create a profile and set some parameters
+        profile = tiledb.Profile(dir=self.path("profile_with_config_dir"))
+        profile["rest.username"] = username
+        profile["rest.password"] = password
+        profile["rest.server_address"] = server_address
+
+        # Save the profile
+        profile.save()
+
+        # -----
+        # The above is done only once, so we can use the same profile later
+        # -----
+
+        # Create a config and set the profile
+        config = tiledb.Config()
+        config.set_profile(profile_dir=self.path("profile_with_config_dir"))
+        # Test that the config parameters are set correctly
+        assert config["rest.username"] == username
+        assert config["rest.password"] == password
+        assert config["rest.server_address"] == server_address
+
+        # Alternatively, we can set the profile details directly in the Config constructor
+        config2 = tiledb.Config(profile_dir=self.path("profile_with_config_dir"))
+        # Test that the config parameters are set correctly
+        assert config2["rest.username"] == username
+        assert config2["rest.password"] == password
+        assert config2["rest.server_address"] == server_address