rucio-clients 37.7.0__py3-none-any.whl → 38.0.0__py3-none-any.whl

rucio/cli/opendata.py

@@ -0,0 +1,132 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from typing import TYPE_CHECKING, Optional
+
+import click
+
+from rucio.cli.utils import JSONType
+from rucio.common.constants import OPENDATA_DID_STATE_LITERAL_LIST
+from rucio.common.utils import extract_scope
+
+if TYPE_CHECKING:
+    from click import Context
+
+    from rucio.common.constants import OPENDATA_DID_STATE_LITERAL
+
+
+def is_valid_json(s: str) -> bool:
+    try:
+        json.loads(s)
+        return True
+    except json.JSONDecodeError:
+        return False
+
+
+@click.group()
+def opendata() -> None:
+    """Manage Opendata resources"""
+
+
+@opendata.group(name="did")
+def opendata_did() -> None:
+    """Manage Opendata DIDs"""
+
+
+@opendata_did.command("list")
+@click.option("--state", type=click.Choice(OPENDATA_DID_STATE_LITERAL_LIST, case_sensitive=False), required=False,
+              help="Filter on Opendata state")
+@click.option("--public", required=False, is_flag=True, default=False,
+              help="Perform request against the public endpoint")
+@click.pass_context
+def list_opendata_dids(ctx: "Context", state: Optional["OPENDATA_DID_STATE_LITERAL"], public: bool) -> None:
+    """
+    List Opendata DIDs, optionally filtered by state and public/private access
+    """
+
+    client = ctx.obj.client
+    result = client.list_opendata_dids(state=state, public=public)
+    print(json.dumps(result, indent=4, sort_keys=True, ensure_ascii=False))
+
+
+@opendata_did.command("add")
+@click.argument("did")
+@click.pass_context
+def add_opendata_did(ctx: "Context", did: str) -> None:
+    """
+    Adds an existing DID to the Opendata catalog
+    """
+
+    client = ctx.obj.client
+    scope, name = extract_scope(did)
+    client.add_opendata_did(scope=scope, name=name)
+
+
+@opendata_did.command("remove")
+@click.argument("did")
+@click.pass_context
+def remove_opendata_did(ctx: "Context", did: str) -> None:
+    """
+    Removes an existing Opendata DID from the Opendata catalog
+    """
+
+    client = ctx.obj.client
+    scope, name = extract_scope(did)
+    client.remove_opendata_did(scope=scope, name=name)
+
+
+@opendata_did.command("show")
+@click.argument("did")
+@click.option("--meta", required=False, is_flag=True, default=False, help="Print only the opendata metadata")
+@click.option("--files", required=False, is_flag=True, default=False,
+              help="Print the files associated with the opendata DID")
+@click.option("--public", required=False, is_flag=True, default=False,
+              help="Perform request against the public endpoint")
+@click.pass_context
+def get_opendata_did(ctx: "Context", did: str, include_files: bool, include_metadata: bool, public: bool) -> None:
+    """
+    Get information about an Opendata DID, optionally including files and metadata.
+    """
+
+    client = ctx.obj.client
+    scope, name = extract_scope(did)
+    result = client.get_opendata_did(scope=scope, name=name, public=public,
+                                     include_files=include_files, include_metadata=include_metadata,
+                                     include_doi=True)
+    # TODO: pretty print using tables, etc
+    print(json.dumps(result, indent=4, sort_keys=True, ensure_ascii=False))
+
+
+@opendata_did.command("update")
+@click.argument("did")
+@click.option("--meta", type=JSONType(), required=False, help="Opendata JSON")
+@click.option("--state", type=click.Choice(OPENDATA_DID_STATE_LITERAL_LIST, case_sensitive=False), required=False,
+              help="State of the Opendata DID")
+@click.option("--doi", required=False,
+              help="Digital Object Identifier (DOI) for the Opendata DID (e.g., 10.1234/foo.bar)")
+@click.pass_context
+def update_opendata_did(ctx: "Context", did: str, meta: Optional[str],
+                        state: Optional["OPENDATA_DID_STATE_LITERAL"],
+                        doi: Optional[str]) -> None:
+    """
+    Update an existing Opendata DID in the Opendata catalog.
+    """
+
+    client = ctx.obj.client
+    if not any([meta, state, doi]):
+        raise ValueError("At least one of --meta, --state, or --doi must be provided.")
+
+    scope, name = extract_scope(did)
+    client.update_opendata_did(scope=scope, name=name, meta=meta, state=state, doi=doi)

rucio/cli/replica.py

@@ -11,12 +11,17 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from typing import TYPE_CHECKING, Optional
+
 import click
 
-from rucio.cli.bin_legacy.rucio import list_dataset_replicas, list_file_replicas, list_suspicious_replicas
+from rucio.cli.bin_legacy.rucio import list_dataset_replicas, list_datasets_rse, list_file_replicas, list_suspicious_replicas
 from rucio.cli.bin_legacy.rucio_admin import declare_bad_file_replicas, declare_temporary_unavailable_replicas, quarantine_replicas, set_tombstone
 from rucio.cli.utils import Arguments
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 @click.group()
 def replica():
@@ -60,13 +65,18 @@ def list_(ctx, dids, protocols, all_states, pfns, domain, link, missing, metalin
 
 @replica_list.command("dataset")
 @click.argument("dids", nargs=-1)
+@click.option("--rse", default=None, help="RSE name to use a filter")
 @click.option("--deep", default=False, is_flag=True, help="Make a deep check, checking the contents of datasets in datasets")
 @click.option("--csv", help="Write output to comma separated values", is_flag=True, default=False)
 @click.pass_context
-def list_dataset(ctx, dids, deep, csv):
-    """List dataset replicas"""
-    args = Arguments({"no_pager": ctx.obj.no_pager, "dids": dids, "deep": deep, "csv": csv})
-    list_dataset_replicas(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)
+def list_dataset(ctx, dids: Optional["Sequence[str]"], rse: Optional[str], deep: bool, csv: bool):
+    """List dataset replicas, or view all datasets at a RSE"""
+    if rse is None:
+        args = Arguments({"no_pager": ctx.obj.no_pager, "dids": dids, "deep": deep, "csv": csv})
+        list_dataset_replicas(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)
+    else:
+        args = Arguments({"no_pager": ctx.obj.no_pager, "rse": rse})
+        list_datasets_rse(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)
 
 
 @replica.command("remove")

rucio/cli/rule.py

@@ -15,6 +15,7 @@ import click
 
 from rucio.cli.bin_legacy.rucio import add_rule, delete_rule, info_rule, list_rules, list_rules_history, move_rule, update_rule
 from rucio.cli.utils import Arguments
+from rucio.common.exception import InputValidationError
 
 
 @click.group()
@@ -149,7 +150,7 @@ def update(
 
 
 @rule.command("list")
-@click.argument("did")
+@click.option("--did", help="Filter by DID")
 @click.option("--traverse", is_flag=True, default=False, help="Traverse the did tree and search for rules affecting this did")
 @click.option("--csv", is_flag=True, default=False, help="Comma Separated Value output")
 @click.option("--file", help="Filter by file")
@@ -158,5 +159,9 @@ def update(
 @click.pass_context
 def list_(ctx, did, traverse, csv, file, account, subscription):
     """List all rules impacting a given DID"""
-    args = Arguments({"no_pager": ctx.obj.no_pager, "did": did, "rule_id": None, "traverse": traverse, "csv": csv, "file": file, "subscription": (account if account is not None else ctx.obj.client.account, subscription)})
+    # Done here to raise error==2
+    if not (did or file or account or subscription):
+        raise InputValidationError("At least one option has to be given. Use -h to list the options.")
+
+    args = Arguments({"no_pager": ctx.obj.no_pager, "did": did, "traverse": traverse, "csv": csv, "file": file, "rule_account": account, "subscription": subscription})
     list_rules(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)

rucio/cli/scope.py

@@ -34,7 +34,8 @@ def add_(ctx, account, scope_name):
 
 @scope.command("list")
 @click.option("-a", "--account", help="Filter by associated account", required=False)
+@click.option("--csv", is_flag=True, help="Output in CSV format", default=False)
 @click.pass_context
-def list_(ctx, account):
+def list_(ctx: click.Context, account: str, csv: bool):
     """List existing scopes"""
-    list_scopes(Arguments({"no_pager": ctx.obj.no_pager, "account": account}), ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)
+    list_scopes(Arguments({"no_pager": ctx.obj.no_pager, "account": account, "csv": csv}), ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)

rucio/cli/utils.py

@@ -11,7 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 import errno
+import json
 import logging
 import os
 import signal
@@ -20,6 +22,9 @@ import sys
 import traceback
 from configparser import NoOptionError, NoSectionError
 from functools import wraps
+from typing import Optional, Union
+
+import click
 
 from rucio.client.client import Client
 from rucio.common.config import config_get
@@ -30,7 +35,7 @@ from rucio.common.exception import (
     DataIdentifierNotFound,
     Duplicate,
     DuplicateContent,
-    InvalidObject,
+    InputValidationError,
     InvalidRSEExpression,
     MissingDependency,
     RSENotFound,
@@ -52,12 +57,13 @@ def exception_handler(function):
     def new_funct(*args, **kwargs):
         try:
             return function(*args, **kwargs)
+        except InputValidationError as error:
+            logger.error(error)
+            logger.debug("This means that one you provided an invalid combination of parameters, or incorrect types. Please check the command help (-h/--help).")
+            return FAILURE
         except NotImplementedError as error:
             logger.error(f"Cannot run that operation/command combination {error}")
             return FAILURE
-        except InvalidObject as error:
-            logger.error(error)
-            return error.error_code
         except DataIdentifierNotFound as error:
             logger.error(error)
             logger.debug("This means that the Data IDentifier you provided is not known by Rucio.")
@@ -224,3 +230,21 @@ class Arguments(dict):
     __getattr__ = dict.get
     __setattr__ = dict.__setitem__
     __delattr__ = dict.__delitem__
+
+
+class JSONType(click.ParamType):
+    name = "json"
+
+    def convert(
+            self,
+            value: Union[str, None],
+            param: "Optional[click.Parameter]",
+            ctx: "Optional[click.Context]",
+    ) -> Optional[dict]:
+        if value is None:
+            return None
+
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError as e:
+            self.fail(f"Invalid JSON: {e}", param, ctx)

rucio/client/baseclient.py

@@ -41,7 +41,7 @@ from rucio.common.config import config_get, config_get_bool, config_get_int, con
 from rucio.common.constants import DEFAULT_VO
 from rucio.common.exception import CannotAuthenticate, ClientProtocolNotFound, ClientProtocolNotSupported, ConfigNotFound, MissingClientParameter, MissingModuleException, NoAuthInformation, ServerConnectionException
 from rucio.common.extra import import_extras
-from rucio.common.utils import build_url, get_tmp_dir, my_key_generator, parse_response, setup_logger, ssh_sign
+from rucio.common.utils import build_url, get_tmp_dir, my_key_generator, parse_response, setup_logger, ssh_sign, wlcg_token_discovery
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -944,6 +944,14 @@ class BaseClient:
 
         :return: True if a token could be read. False if no file exists.
         """
+
+        if self.auth_type == "oidc":
+            token = wlcg_token_discovery()
+            if token:
+                self.auth_token = token
+                self.headers['X-Rucio-Auth-Token'] = self.auth_token
+                return True
+
         if not os.path.exists(self.token_file):
             return False
 

rucio/client/client.py

@@ -27,6 +27,7 @@ from rucio.client.importclient import ImportClient
 from rucio.client.lifetimeclient import LifetimeClient
 from rucio.client.lockclient import LockClient
 from rucio.client.metaconventionsclient import MetaConventionClient
+from rucio.client.opendataclient import OpenDataClient
 from rucio.client.pingclient import PingClient
 from rucio.client.replicaclient import ReplicaClient
 from rucio.client.requestclient import RequestClient
@@ -46,6 +47,7 @@ class Client(AccountClient,
              RSEClient,
              ScopeClient,
              DIDClient,
+             OpenDataClient,
              RuleClient,
              SubscriptionClient,
              LockClient,

rucio/client/diracclient.py

@@ -25,8 +25,13 @@ if TYPE_CHECKING:
 
 
 class DiracClient(BaseClient):
+    """
+    Client for the DIRAC integration layer.
 
-    """DataIdentifier client class for working with data identifiers"""
+    This client wraps the REST calls used by the ``RucioFileCatalog`` plugin in DIRAC.
+    Only `add_files` is currently provided and it behaves like any other ``BaseClient``
+    method by handling authentication tokens and host selection automatically.
+    """
 
     DIRAC_BASEURL = 'dirac'
 
@@ -37,25 +42,81 @@ class DiracClient(BaseClient):
             parents_metadata: Optional["Mapping[str, Mapping[str, Any]]"] = None
     ) -> Literal[True]:
         """
-        Bulk add files :
-            * Create the file and replica.
+        Register files and create missing parent structures.
 
-            * If doesn't exist create the dataset containing the file as well as a rule on the dataset on ANY sites.
+        For each entry in ``lfns`` the method:
 
-            * Create all the ascendants of the dataset if they do not exist
+        * Creates the file and its replica on the specified RSE.
+        * If the containing dataset does not exist, it is created with a replication
+          rule using the RSE expression ``ANY=true``. This places the dataset on any
+          RSE advertising the ``ANY`` attribute.
+        * Creates all ancestor containers when needed.
+        * Attaches metadata from ``parents_metadata`` to those parents.
 
         Parameters
         ----------
-        lfns :
-            List of lfn (dictionary {'lfn': <lfn>, 'rse': <rse>, 'bytes': <bytes>, 'adler32': <adler32>, 'guid': <guid>, 'pfn': <pfn>}
-        ignore_availability :
-            A boolean to ignore blocked sites.
-        parents_metadata :
-            Metadata for selected hierarchy DIDs. (dictionary {'lpn': {key : value}}). Default=None
+        lfns
+            Iterable of dictionaries describing the files. Each dictionary must contain:
+
+            * **``lfn``**  full logical file name with scope
+            * **``rse``**  destination RSE name
+            * **``bytes``**  file size in bytes
+            * **``adler32``**  Adler‑32 checksum
+
+            Optional keys include ``guid`` ``pfn`` and ``meta``.
+
+        ignore_availability
+            When ``True``, the availability status of RSEs is ignored and blocked RSEs are
+            still accepted. Defaults to ``False`` which rejects blocked RSEs.
+        parents_metadata
+            Mapping of parent logical path names to metadata {'lpn': {key : value}}.
+            Entries are only applied when new datasets or containers are created.
+            Defaults to None.
+
+        Returns
+        -------
+        Literal[True]
+            When the server confirms the creation.
+
+        Raises
+        ------
+        RucioException
+            Raised when the HTTP request is not successful.
+
+        Examples
+        --------
+        ??? Example
+
+            Register a file using the DIRAC naming style. Dirac's scope extraction is
+            required to be set for this to work:
+
+            ```python
+            >>> from rucio.client.diracclient import DiracClient
+            >>> from rucio.common.utils import generate_uuid
+
+            >>> dc = DiracClient()
+            >>> lfn = f"/belle/mock/cont_{generate_uuid()}/dataset_{generate_uuid()}/file_{generate_uuid()}"
+            >>> files = [{
+            ...     "lfn": lfn,
+            ...     "rse": "XRD1",
+            ...     "bytes": 1,
+            ...     "adler32": "0cc737eb",
+            ...     'guid': generate_uuid()
+            ... }]
+
+            >>> dc.add_files(files)
+            True
+            ```
         """
         path = '/'.join([self.DIRAC_BASEURL, 'addfiles'])
         url = build_url(choice(self.list_hosts), path=path)
-        r = self._send_request(url, type_='POST', data=dumps({'lfns': lfns, 'ignore_availability': ignore_availability, 'parents_metadata': parents_metadata}))
+
+        r = self._send_request(
+            url,
+            type_='POST',
+            data=dumps({'lfns': lfns, 'ignore_availability': ignore_availability, 'parents_metadata': parents_metadata})
+        )
+
         if r.status_code == codes.created:
             return True
         else:

rucio/client/opendataclient.py

@@ -0,0 +1,249 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from typing import TYPE_CHECKING, Any, Optional
+from urllib.parse import quote_plus
+
+from requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.config import config_get
+from rucio.common.utils import build_url, render_json
+
+if TYPE_CHECKING:
+    from rucio.common.constants import OPENDATA_DID_STATE_LITERAL
+
+
+class OpenDataClient(BaseClient):
+    opendata_public_base_url = "opendata/public"
+    opendata_private_base_url = "opendata"
+
+    opendata_public_dids_base_url = f"{opendata_public_base_url}/dids"
+    opendata_private_dids_base_url = f"{opendata_private_base_url}/dids"
+
+    opendata_host_from_config = config_get('client', 'opendata_host', raise_exception=False, default=None)
+
+    def get_opendata_host(self, *, public: bool) -> str:
+        """
+        Get the Opendata host URL for the public or private endpoint.
+        The private opendata host is the regular rucio server, while the public opendata host can be configured separately (defaults to the same as the private one).
+
+        Parameters:
+            public: If True, return the public Opendata host URL. If False, return the private Opendata host URL.
+
+        Returns:
+            The Opendata host URL.
+        """
+
+        if public and self.opendata_host_from_config is not None:
+            return self.opendata_host_from_config
+
+        return choice(self.list_hosts)
+
+    def list_opendata_dids(
+            self,
+            *,
+            state: Optional["OPENDATA_DID_STATE_LITERAL"] = None,
+            public: bool = False,
+    ) -> dict[str, Any]:
+        """
+        Return a list of Opendata DIDs, optionally filtered by state and access type.
+
+        Parameters:
+            state: The state to filter DIDs by. If None, all states are included.
+            public: If True, queries the public Opendata endpoint. Defaults to False.
+
+        Returns:
+            A dictionary containing the list of Opendata DIDs.
+
+        Raises:
+            ValueError: If both `state` and `public=True` are provided.
+            Exception: If the request fails or the server returns an error.
+        """
+
+        base_url = self.opendata_public_dids_base_url if public else self.opendata_private_dids_base_url
+        path = '/'.join([base_url])
+
+        params = {}
+
+        if state is not None:
+            params['state'] = state
+
+        if state is not None and public:
+            raise ValueError('state and public cannot be provided at the same time.')
+
+        url = build_url(self.get_opendata_host(public=public), path=path)
+        r = self._send_request(url, type_='GET', params=params)
+        if r.status_code == codes.ok:
+            return json.loads(r.content.decode('utf-8'))
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)
+
+    def add_opendata_did(
+            self,
+            *,
+            scope: str,
+            name: str,
+    ) -> bool:
+        """
+        Adds an existing Rucio DID (Data Identifier) to the Opendata catalog.
+
+        Parameters:
+            scope: The scope under which the DID is registered.
+            name: The name of the DID.
+
+        Returns:
+            True if the DID was successfully added to the Opendata catalog, otherwise raises an exception.
+
+        Raises:
+            Exception: If the request fails or the server returns an error.
+        """
+
+        path = '/'.join([self.opendata_private_dids_base_url, quote_plus(scope), quote_plus(name)])
+        url = build_url(self.get_opendata_host(public=False), path=path)
+
+        r = self._send_request(url, type_='POST')
+
+        if r.status_code == codes.created:
+            return True
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)
+
+    def remove_opendata_did(
+            self,
+            *,
+            scope: str,
+            name: str,
+    ) -> bool:
+        """
+        Remove an existing Opendata DID from the Opendata catalog.
+
+        Parameters:
+            scope: The scope under which the DID is registered.
+            name: The name of the DID.
+
+        Returns:
+            True if the DID was successfully removed, otherwise raises an exception.
+
+        Raises:
+            Exception: If the request fails or the server returns an error.
+        """
+
+        path = '/'.join([self.opendata_private_dids_base_url, quote_plus(scope), quote_plus(name)])
+        url = build_url(self.get_opendata_host(public=False), path=path)
+
+        r = self._send_request(url, type_='DEL')
+
+        if r.status_code == codes.no_content:
+            return True
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)
+
+    def update_opendata_did(
+            self,
+            *,
+            scope: str,
+            name: str,
+            state: Optional["OPENDATA_DID_STATE_LITERAL"] = None,
+            meta: Optional[dict] = None,
+            doi: Optional[str] = None,
+    ) -> bool:
+        """
+        Update an existing Opendata DID in the Opendata catalog.
+
+        Parameters:
+            scope: The scope under which the DID is registered.
+            name: The name of the DID.
+            state: The new state to set for the DID.
+            meta: Metadata to update for the DID. Must be a valid JSON object.
+            doi: DOI to associate with the DID. Must be a valid DOI string (e.g., "10.1234/foo.bar").
+
+        Returns:
+            True if the update was successful.
+
+        Raises:
+            ValueError: If none of 'meta', 'state', or 'doi' are provided.
+            Exception: If the request fails or the server returns an error.
+        """
+
+        path = '/'.join([self.opendata_private_dids_base_url, quote_plus(scope), quote_plus(name)])
+        url = build_url(self.get_opendata_host(public=False), path=path)
+
+        if not any([meta, state, doi]):
+            raise ValueError("Either 'meta', 'state', or 'doi' must be provided.")
+
+        data: dict[str, Any] = {}
+
+        if meta is not None:
+            data['meta'] = meta
+
+        if state is not None:
+            data['state'] = state
+
+        if doi is not None:
+            data['doi'] = doi
+
+        r = self._send_request(url, type_='PUT', data=render_json(**data))
+
+        if r.status_code == codes.ok:
+            return True
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)
+
+    def get_opendata_did(
+            self,
+            *,
+            scope: str,
+            name: str,
+            include_files: bool = False,
+            include_metadata: bool = False,
+            include_doi: bool = True,
+            public: bool = False,
+    ) -> dict[str, Any]:
+        """
+        Retrieve information about an OpenData DID (Data Identifier).
+
+        Parameters:
+            scope: The scope under which the DID is registered.
+            name: The name of the DID.
+            include_files: If True, include a list of associated files. Defaults to False.
+            include_metadata: If True, include extended metadata. Defaults to False.
+            include_doi: If True, include DOI (Digital Object Identifier) information. Defaults to True.
+            public: If True, only return data if the DID is publicly accessible. Defaults to False.
+
+        Returns:
+            A dictionary containing metadata about the specified DID.
+            May include file list, extended metadata, and DOI details depending on the parameters.
+        """
+
+        base_url = self.opendata_public_dids_base_url if public else self.opendata_private_dids_base_url
+        path = '/'.join([base_url, quote_plus(scope), quote_plus(name)])
+        url = build_url(self.get_opendata_host(public=public), path=path)
+
+        r = self._send_request(url, type_='GET', params={
+            'files': 1 if include_files else 0,
+            'meta': 1 if include_metadata else 0,
+            'doi': 1 if include_doi else 0,
+        })
+
+        if r.status_code == codes.ok:
+            return json.loads(r.content.decode('utf-8'))
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)