lamindb_setup 1.0.3__tar.gz → 1.1.1__tar.gz

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.0.3
+Version: 1.1.1
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
@@ -11,13 +11,15 @@ Requires-Dist: dj_database_url>=1.3.0,<3.0.0
 Requires-Dist: pydantic-settings
 Requires-Dist: appdirs<2.0.0
 Requires-Dist: requests
-Requires-Dist: universal_pathlib==0.2.5
+Requires-Dist: universal_pathlib==0.2.6
 Requires-Dist: botocore<2.0.0
 Requires-Dist: supabase>=2.8.1,<=2.11.0
+Requires-Dist: storage3!=0.11.2; python_version < '3.11'
 Requires-Dist: psutil
+Requires-Dist: packaging
 Requires-Dist: urllib3<2 ; extra == "aws"
 Requires-Dist: aiobotocore[boto3]>=2.5.4,<3.0.0 ; extra == "aws"
-Requires-Dist: s3fs>=2023.12.2,<=2024.10.0,!=2024.10.0 ; extra == "aws"
+Requires-Dist: s3fs>=2023.12.2,<=2025.2.0,!=2024.10.0 ; extra == "aws"
 Requires-Dist: line_profiler ; extra == "dev"
 Requires-Dist: pyjwt<3.0.0 ; extra == "dev"
 Requires-Dist: psycopg2-binary ; extra == "dev"
@@ -29,7 +31,7 @@ Requires-Dist: pytest-xdist ; extra == "dev"
 Requires-Dist: nbproject-test>=0.4.3 ; extra == "dev"
 Requires-Dist: pandas ; extra == "dev"
 Requires-Dist: django-schema-graph ; extra == "erdiagram"
-Requires-Dist: gcsfs>=2023.12.2,<=2024.10.0 ; extra == "gcp"
+Requires-Dist: gcsfs>=2023.12.2,<=2025.2.0 ; extra == "gcp"
 Project-URL: Home, https://github.com/laminlabs/lamindb-setup
 Provides-Extra: aws
 Provides-Extra: dev

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/docs/hub-cloud/01-init-local-instance.ipynb

@@ -1,7 +1,6 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {
     "tags": []
@@ -107,7 +106,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.16"
   },
   "vscode": {
    "interpreter": {

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/docs/hub-cloud/02-connect-local-instance.ipynb

@@ -32,7 +32,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import lamindb_setup as ln_setup"
+    "import lamindb_setup as ln_setup\n",
+    "from lamindb_setup._check_setup import ModuleWasntConfigured\n",
+    "import pytest"
    ]
   },
   {
@@ -51,6 +53,20 @@
     "If the user is the instance owner, load the instance by name:"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1106eff3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# bionty is not in the (schema) modules of mydata\n",
+    "# _check_instance_setup is called inside with from_module=None\n",
+    "# the branch where django is not setup yet\n",
+    "# as from_module=None it won't connect to an instance here\n",
+    "import bionty"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -58,7 +74,38 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "ln_setup.connect(\"mydata\")"
+    "ln_setup.connect(\n",
+    "    \"mydata\", _reload_lamindb=False\n",
+    ")  # also test passing _reload_lamindb explicitly"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "86a1cb7c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# wetlab is not in the (schema) modules of mydata\n",
+    "with pytest.raises(ModuleWasntConfigured):\n",
+    "    # _check_instance_setup is called inside with from_module=None\n",
+    "    # the branch where django is setup\n",
+    "    import wetlab"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "799740b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# wetlab is not in the (schema) modules of mydata\n",
+    "with pytest.raises(ModuleWasntConfigured):\n",
+    "    # _check_instance_setup is called inside with from_module=\"bionty\"\n",
+    "    # the branch where django is setup\n",
+    "    # in __getattr__ in __init__.py\n",
+    "    bionty.CellType"
    ]
   },
   {
@@ -122,7 +169,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.17"
+   "version": "3.10.16"
   },
   "vscode": {
    "interpreter": {

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/docs/hub-cloud/05-init-hosted-instance.ipynb

@@ -82,7 +82,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from lamindb_setup.core._aws_credentials import HOSTED_BUCKETS"
+    "from lamindb_setup.core._aws_options import HOSTED_BUCKETS"
    ]
   },
   {

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/docs/hub-prod/test-cloud-sync.ipynb

@@ -224,9 +224,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "dir_sync_local = settings.paths.cloud_to_local(\n",
+    "dir_sync_local = settings.paths.cloud_to_local_no_update(\n",
     "    dir_sync.as_posix(), cache_key=\"dir_cache/key\"\n",
-    ")"
+    ")\n",
+    "assert dir_sync_local == settings.cache_dir / \"dir_cache/key\"\n",
+    "\n",
+    "assert dir_sync.synchronize(dir_sync_local, just_check=True)\n",
+    "assert not dir_sync_local.exists()"
    ]
   },
   {
@@ -236,7 +240,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "assert dir_sync_local == settings.cache_dir / \"dir_cache/key\"\n",
+    "assert dir_sync.synchronize(dir_sync_local, just_check=False)\n",
     "assert dir_sync_local.is_dir()\n",
     "assert num_files(dir_sync_local) == 2"
    ]
@@ -744,7 +748,19 @@
    "outputs": [],
    "source": [
     "hf_path = UPath(\"hf://datasets/Koncopd/lamindb-test@main/anndata/pbmc68k_test.h5ad\")\n",
-    "hf_path_local = settings.paths.cloud_to_local(hf_path)"
+    "hf_path_local = settings.paths.cloud_to_local_no_update(hf_path)\n",
+    "assert isinstance(hf_path_local, LocalPathClasses)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0aad1f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert hf_path.synchronize(hf_path_local, just_check=True)\n",
+    "assert not hf_path_local.exists()"
    ]
   },
   {
@@ -754,7 +770,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "assert isinstance(hf_path_local, LocalPathClasses)\n",
+    "assert hf_path.synchronize(hf_path_local)\n",
     "assert hf_path_local.is_file()"
    ]
   },
@@ -811,7 +827,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.17"
+   "version": "3.10.16"
   },
   "vscode": {
    "interpreter": {

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/__init__.py

@@ -33,10 +33,12 @@ Modules & settings:
 
 """
 
-__version__ = "1.0.3"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.1.1"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os
 
+from packaging import version as packaging_version
+
 from . import core
 from ._check_setup import _check_instance_setup
 from ._close import close
@@ -50,6 +52,20 @@ from ._register_instance import register
 from ._setup_user import login, logout
 from .core._settings import settings
 
+# check that the version of s3fs is higher than the lower bound
+# needed because spatialdata installs old versions of s3fs
+try:
+    from s3fs import __version__ as s3fs_version
+
+    if packaging_version.parse(s3fs_version) < packaging_version.parse("2023.12.2"):
+        raise RuntimeError(
+            f"The version of s3fs you have ({s3fs_version}) is impompatible "
+            "with lamindb, please upgrade it: pip install s3fs>=2023.12.2"
+        )
+except ImportError:
+    # might be not installed
+    pass
+
 
 def _is_CI_environment() -> bool:
     ci_env_vars = [

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/_check_setup.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import functools
 import importlib as il
+import inspect
 import os
 from typing import TYPE_CHECKING
 
 from lamin_utils import logger
 
 from ._silence_loggers import silence_loggers
-from .core import django
+from .core import django as django_lamin
 from .core._settings import settings
 from .core._settings_store import current_instance_settings_file
 from .core.exceptions import DefaultMessageException
@@ -33,8 +34,12 @@ CURRENT_ISETTINGS: InstanceSettings | None = None
 IS_LOADING: bool = False
 
 
+class ModuleWasntConfigured(SystemExit):
+    pass
+
+
 # decorator to disable auto-connect when importing a module such as lamindb
-def _loading(func: Callable):
+def disable_auto_connect(func: Callable):
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
         global IS_LOADING
@@ -70,14 +75,66 @@ def _get_current_instance_settings() -> InstanceSettings | None:
         return None
 
 
+def _normalize_module_name(module_name: str) -> str:
+    return module_name.replace("lnschema_", "").replace("_", "-")
+
+
+# checks that the provided modules is in the modules of the provided instance
+# or in the apps setup by django
+def _check_module_in_instance_modules(
+    module: str, isettings: InstanceSettings | None = None
+) -> None:
+    not_in_instance_msg = (
+        f"'{module}' is missing from this instance. "
+        "Please go to your instance settings page and add it under 'schema modules'."
+    )
+
+    if isettings is not None:
+        modules_raw = isettings.modules
+        modules = set(modules_raw).union(
+            _normalize_module_name(module) for module in modules_raw
+        )
+        if _normalize_module_name(module) not in modules and module not in modules:
+            raise ModuleWasntConfigured(not_in_instance_msg)
+        else:
+            return
+
+    from django.apps import apps
+
+    for app in apps.get_app_configs():
+        # app.name is always unnormalized module (python package) name
+        if module == app.name or module == _normalize_module_name(app.name):
+            return
+    raise ModuleWasntConfigured(not_in_instance_msg)
+
+
+# infer the name of the module that calls this function
+def _infer_callers_module_name() -> str | None:
+    stack = inspect.stack()
+    if len(stack) < 3:
+        return None
+    module = inspect.getmodule(stack[2][0])
+    return module.__name__.partition(".")[0] if module is not None else None
+
+
 # we make this a private function because in all the places it's used,
 # users should not see it
 def _check_instance_setup(from_module: str | None = None) -> bool:
-    if django.IS_SETUP:
+    if django_lamin.IS_SETUP:
         # reload logic here because module might not yet have been imported
         # upon first setup
-        if from_module is not None and from_module != "lamindb":
-            il.reload(il.import_module(from_module))
+        if from_module is not None:
+            if from_module != "lamindb":
+                _check_module_in_instance_modules(from_module)
+                il.reload(il.import_module(from_module))
+        else:
+            infer_module = _infer_callers_module_name()
+            if infer_module is not None and infer_module not in {
+                "lamindb",
+                "lamindb_setup",
+                "lamin_cli",
+            }:
+                _check_module_in_instance_modules(infer_module)
         return True
     silence_loggers()
     if os.environ.get("LAMINDB_MULTI_INSTANCE") == "true":
@@ -91,17 +148,19 @@ def _check_instance_setup(from_module: str | None = None) -> bool:
         if (
             from_module is not None
             and settings.auto_connect
-            and not django.IS_SETUP
+            and not django_lamin.IS_SETUP
             and not IS_LOADING
         ):
-            if not from_module == "lamindb":
+            if from_module != "lamindb":
+                _check_module_in_instance_modules(from_module, isettings)
+
                 import lamindb
 
                 il.reload(il.import_module(from_module))
             else:
-                django.setup_django(isettings)
+                django_lamin.setup_django(isettings)
                 logger.important(f"connected lamindb: {isettings.slug}")
-        return django.IS_SETUP
+        return django_lamin.IS_SETUP
     else:
         if from_module is not None and settings.auto_connect:
             logger.warning(InstanceNotSetupError.default_message)

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/_connect_instance.py

@@ -271,6 +271,7 @@ def connect(instance: str | None = None, **kwargs) -> str | tuple | None:
             settings_dir / f"no_lnschema_core-{isettings.slug.replace('/', '--')}"
         )
         if not no_lnschema_core_file.exists():
+            # sqlite file for cloud sqlite instances is already updated here
             migrate_lnschema_core(
                 isettings, no_lnschema_core_file, write_file=_write_settings
             )
@@ -311,7 +312,8 @@ def connect(instance: str | None = None, **kwargs) -> str | tuple | None:
         load_from_isettings(isettings, user=_user, write_settings=_write_settings)
         if _reload_lamindb:
             importlib.reload(importlib.import_module("lamindb"))
-        logger.important(f"connected lamindb: {isettings.slug}")
+        else:
+            logger.important(f"connected lamindb: {isettings.slug}")
     except Exception as e:
         if isettings is not None:
             if _write_settings:
@@ -339,6 +341,12 @@ def migrate_lnschema_core(
     """Migrate lnschema_core tables to lamindb tables."""
     from urllib.parse import urlparse
 
+    # we need to do this because the sqlite file should be already synced
+    # has no effect if not cloud sqlite
+    # errors if the sqlite file is not in the cloud and doesn't exist locally
+    # isettings.db syncs but doesn't error in this case due to error_no_origin=False
+    isettings._update_local_sqlite_file()
+
     parsed_uri = urlparse(isettings.db)
     db_type = parsed_uri.scheme
 

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/_delete.py

@@ -7,7 +7,7 @@ from uuid import UUID
 from lamin_utils import logger
 
 from ._connect_instance import _connect_instance, get_owner_name_from_identifier
-from .core._aws_credentials import HOSTED_BUCKETS
+from .core._aws_options import HOSTED_BUCKETS
 from .core._hub_core import delete_instance as delete_instance_on_hub
 from .core._hub_core import get_storage_records_for_instance
 from .core._settings import settings

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/_init_instance.py

@@ -396,10 +396,5 @@ def infer_instance_name(
     if storage == "create-s3":
         raise ValueError("pass name to init if storage = 'create-s3'")
     storage_path = UPath(storage).resolve()
-    # not sure if name is ever ""
-    if storage_path.name != "":
-        name = storage_path.name
-    else:
-        # dedicated treatment of bucket names
-        name = storage_path.drive
+    name = storage_path.path.rstrip("/").split("/")[-1]
     return name.lower()

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/_migrate.py

@@ -5,7 +5,7 @@ from django.db.migrations.loader import MigrationLoader
 from lamin_utils import logger
 from packaging import version
 
-from ._check_setup import _check_instance_setup, _loading
+from ._check_setup import _check_instance_setup, disable_auto_connect
 from .core._settings import settings
 from .core.django import setup_django
 
@@ -62,7 +62,7 @@ class migrate:
     """
 
     @classmethod
-    @_loading
+    @disable_auto_connect
     def create(cls) -> None:
         """Create a migration."""
         if _check_instance_setup():
@@ -70,7 +70,7 @@ class migrate:
         setup_django(settings.instance, create_migrations=True)
 
     @classmethod
-    @_loading
+    @disable_auto_connect
     def deploy(cls) -> None:
         """Deploy a migration."""
         from ._schema_metadata import update_schema_in_hub
@@ -115,7 +115,7 @@ class migrate:
             )
 
     @classmethod
-    @_loading
+    @disable_auto_connect
     def check(cls) -> bool:
         """Check whether Registry definitions are in sync with migrations."""
         from django.core.management import call_command
@@ -132,7 +132,7 @@ class migrate:
         return True
 
     @classmethod
-    @_loading
+    @disable_auto_connect
     def squash(
         cls, package_name, migration_nr, start_migration_nr: str | None = None
     ) -> None:
@@ -148,7 +148,7 @@ class migrate:
             call_command("squashmigrations", package_name, migration_nr)
 
     @classmethod
-    @_loading
+    @disable_auto_connect
     def show(cls) -> None:
         """Show migrations."""
         from django.core.management import call_command

lamindb_setup-1.0.3/lamindb_setup/core/_aws_credentials.py → lamindb_setup-1.1.1/lamindb_setup/core/_aws_options.py

@@ -4,7 +4,7 @@ import os
 import time
 
 from lamin_utils import logger
-from upath.implementations.cloud import S3Path
+from upath import UPath
 
 HOSTED_REGIONS = [
     "eu-central-1",
@@ -25,22 +25,29 @@ def _keep_trailing_slash(path_str: str):
     return path_str if path_str[-1] == "/" else path_str + "/"
 
 
-AWS_CREDENTIALS_EXPIRATION = 11 * 60 * 60  # refresh credentials after 11 hours
+AWS_CREDENTIALS_EXPIRATION: int = 11 * 60 * 60  # refresh credentials after 11 hours
 
 
 # set anon=True for these buckets if credentials fail for a public bucket
 # to be expanded
-PUBLIC_BUCKETS = ("cellxgene-data-public",)
+PUBLIC_BUCKETS: tuple[str] = ("cellxgene-data-public",)
 
 
-class AWSCredentialsManager:
+# s3-comaptible endpoints managed by lamin
+# None means the standard aws s3 endpoint
+LAMIN_ENDPOINTS: tuple[str | None] = (None,)
+
+
+class AWSOptionsManager:
     def __init__(self):
         self._credentials_cache = {}
 
         from s3fs import S3FileSystem
 
         # this is cached so will be resued with the connection initialized
-        fs = S3FileSystem(cache_regions=True)
+        fs = S3FileSystem(
+            cache_regions=True, use_listings_cache=True, version_aware=False
+        )
         try:
             fs.connect()
             self.anon: bool = fs.session._credentials is None
@@ -83,7 +90,7 @@ class AWSCredentialsManager:
     def _get_cached_credentials(self, root: str) -> dict:
         return self._credentials_cache[root]["credentials"]
 
-    def _path_inject_options(self, path: S3Path, credentials: dict) -> S3Path:
+    def _path_inject_options(self, path: UPath, credentials: dict) -> UPath:
         if credentials == {}:
             # credentials were specified manually for the path
             if "anon" in path.storage_options:
@@ -99,13 +106,27 @@ class AWSCredentialsManager:
             connection_options = credentials
 
         if "cache_regions" in path.storage_options:
-            cache_regions = path.storage_options["cache_regions"]
+            connection_options["cache_regions"] = path.storage_options["cache_regions"]
         else:
-            cache_regions = True
-
-        return S3Path(path, cache_regions=cache_regions, **connection_options)
-
-    def enrich_path(self, path: S3Path, access_token: str | None = None) -> S3Path:
+            connection_options["cache_regions"] = (
+                path.storage_options.get("endpoint_url", None) is None
+            )
+        # we use cache to avoid some uneeded downloads or credential problems
+        # see in upload_from
+        connection_options["use_listings_cache"] = path.storage_options.get(
+            "use_listings_cache", True
+        )
+        # normally we want to ignore objects vsrsions in a versioned bucket
+        connection_options["version_aware"] = path.storage_options.get(
+            "version_aware", False
+        )
+
+        return UPath(path, **connection_options)
+
+    def enrich_path(self, path: UPath, access_token: str | None = None) -> UPath:
+        # ignore paths with non-lamin-managed endpoints
+        if path.storage_options.get("endpoint_url", None) not in LAMIN_ENDPOINTS:
+            return path
         # trailing slash is needed to avoid returning incorrect results
         # with .startswith
         # for example s3://lamindata-eu should not receive cache for s3://lamindata
@@ -160,13 +181,13 @@ class AWSCredentialsManager:
         return self._path_inject_options(path, credentials)
 
 
-_aws_credentials_manager: AWSCredentialsManager | None = None
+_aws_options_manager: AWSOptionsManager | None = None
 
 
-def get_aws_credentials_manager() -> AWSCredentialsManager:
-    global _aws_credentials_manager
+def get_aws_options_manager() -> AWSOptionsManager:
+    global _aws_options_manager
 
-    if _aws_credentials_manager is None:
-        _aws_credentials_manager = AWSCredentialsManager()
+    if _aws_options_manager is None:
+        _aws_options_manager = AWSOptionsManager()
 
-    return _aws_credentials_manager
+    return _aws_options_manager

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/core/_hub_client.py

@@ -66,7 +66,11 @@ def connect_hub(
 ) -> Client:
     env = Environment(fallback=fallback_env)
     if client_options is None:
-        client_options = ClientOptions(auto_refresh_token=False)
+        # function_client_timeout=5 by default
+        # increase to avoid rare timeouts for edge functions
+        client_options = ClientOptions(
+            auto_refresh_token=False, function_client_timeout=10
+        )
     return create_client(env.supabase_api_url, env.supabase_anon_key, client_options)
 
 

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/core/_hub_core.py

@@ -311,6 +311,7 @@ def _init_instance(
             "db_database": db_dsn.db.database,
         }
         fields.update(db_fields)
+    slug = isettings.slug
     # I'd like the following to be an upsert, but this seems to violate RLS
     # Similarly, if we don't specify `returning="minimal"`, we'll violate RLS
     # we could make this idempotent by catching an error, but this seems dangerous
@@ -318,14 +319,13 @@ def _init_instance(
     try:
         client.table("instance").insert(fields, returning="minimal").execute()
     except APIError:
-        logger.warning(
-            f"instance already existed at: https://lamin.ai/{isettings.owner}/{isettings.name}"
-        )
+        logger.warning(f"instance already existed at: https://lamin.ai/{slug}")
         return None
     client.table("storage").update(
         {"instance_id": isettings._id.hex, "is_default": True}
     ).eq("id", isettings.storage._uuid.hex).execute()  # type: ignore
-    logger.important(f"go to: https://lamin.ai/{isettings.owner}/{isettings.name}")
+    if isettings.dialect != "sqlite" and isettings.is_remote:
+        logger.important(f"go to: https://lamin.ai/{slug}")
 
 
 def _connect_instance_hub(

{lamindb_setup-1.0.3 → lamindb_setup-1.1.1}/lamindb_setup/core/_private_django_api.py

@@ -34,7 +34,6 @@ def private_django_api(reverse=False):
     # the order here matters
     # changing it might break the tests
     attributes = [
-        "DoesNotExist",
         "MultipleObjectsReturned",
         "add_to_class",
         "adelete",
@@ -72,10 +71,6 @@ def private_django_api(reverse=False):
             new_name = attr if reverse else f"_{attr}"
             content = content.replace(old_name, new_name)
 
-        if not reverse:
-            content = content.replace("Field_DoesNotExist", "FieldDoesNotExist")
-            content = content.replace("Object_DoesNotExist", "ObjectDoesNotExist")
-
         if content != original_content:
             file_path.write_text(content, encoding=encoding)