datachain 0.31.4__tar.gz → 0.32.1__tar.gz

{datachain-0.31.4 → datachain-0.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datachain
-Version: 0.31.4
+Version: 0.32.1
 Summary: Wrangle unstructured AI data at scale
 Author-email: Dmitry Petrov <support@dvc.org>
 License-Expression: Apache-2.0
@@ -210,45 +210,33 @@ datasets that evolve over time and may occasionally have processing errors.
 .. code:: py
 
     import datachain as dc
-    from datachain import C, File
 
-    def process_file(file: File):
-        """Process a file, which may occasionally fail."""
+    def process_file(file: dc.File) -> tuple[str, str, str]:
+        """Analyze a file, may occasionally fail."""
         try:
             # Your processing logic here
             content = file.read_text()
-            result = analyze_content(content)
-            return {
-                "content": content,
-                "result": result,
-                "error": None  # No error
-            }
+            result = content.upper()
+            return content, result, ""  # No error
         except Exception as e:
             # Return an error that will trigger reprocessing next time
-            return {
-                "content": None,
-                "result": None,
-                "error": str(e)  # Error field will trigger retry
-            }
+            return "", "", str(e)  # Error field will trigger retry
 
     # Process files efficiently with delta and retry
+    # Run it many times, keep adding files, to see delta and retry in action
     chain = (
         dc.read_storage(
             "data/",
             update=True,
             delta=True,              # Process only new/changed files
             delta_on="file.path",    # Identify files by path
-            retry_on="error"         # Field that indicates errors
+            delta_retry="error",     # Process files with error again
         )
-        .map(processed_result=process_file)
-        .mutate(
-            content=C("processed_result.content"),
-            result=C("processed_result.result"),
-            error=C("processed_result.error")
-        )
-        .save(name="processed_data")
+        .map(process_file, output=("content", "result", "error"))
+        .save("processed-data")
     )
 
+
 Example: LLM based text-file evaluation
 ---------------------------------------
 

{datachain-0.31.4 → datachain-0.32.1}/README.rst

@@ -89,45 +89,33 @@ datasets that evolve over time and may occasionally have processing errors.
 .. code:: py
 
     import datachain as dc
-    from datachain import C, File
 
-    def process_file(file: File):
-        """Process a file, which may occasionally fail."""
+    def process_file(file: dc.File) -> tuple[str, str, str]:
+        """Analyze a file, may occasionally fail."""
         try:
             # Your processing logic here
             content = file.read_text()
-            result = analyze_content(content)
-            return {
-                "content": content,
-                "result": result,
-                "error": None  # No error
-            }
+            result = content.upper()
+            return content, result, ""  # No error
         except Exception as e:
             # Return an error that will trigger reprocessing next time
-            return {
-                "content": None,
-                "result": None,
-                "error": str(e)  # Error field will trigger retry
-            }
+            return "", "", str(e)  # Error field will trigger retry
 
     # Process files efficiently with delta and retry
+    # Run it many times, keep adding files, to see delta and retry in action
     chain = (
         dc.read_storage(
             "data/",
             update=True,
             delta=True,              # Process only new/changed files
             delta_on="file.path",    # Identify files by path
-            retry_on="error"         # Field that indicates errors
+            delta_retry="error",     # Process files with error again
         )
-        .map(processed_result=process_file)
-        .mutate(
-            content=C("processed_result.content"),
-            result=C("processed_result.result"),
-            error=C("processed_result.error")
-        )
-        .save(name="processed_data")
+        .map(process_file, output=("content", "result", "error"))
+        .save("processed-data")
     )
 
+
 Example: LLM based text-file evaluation
 ---------------------------------------
 

{datachain-0.31.4 → datachain-0.32.1}/docs/api_hooks.py

@@ -4,6 +4,13 @@ def on_pre_build(**kwargs):
 
     import requests
 
+    # Skip if files already exist
+    if os.path.exists("docs/openapi.json") and os.path.exists(
+        "docs/studio/api/index.md"
+    ):
+        print("API docs already exist, skipping generation")
+        return
+
     # Download OpenAPI spec
     response = requests.get(
         "https://studio.datachain.ai/api/openapi.json",

{datachain-0.31.4 → datachain-0.32.1}/docs/guide/namespaces.md

@@ -159,3 +159,26 @@ dc.read_values(scores=[0.8, 1.5, 2.1]).save("metrics")
 
 ds = dc.read_dataset("local.local.metrics")
 ds.show()
+```
+
+## Removing Namespaces and Projects
+
+Use `delete_namespace` to remove an empty namespace or an empty project within a namespace. Delete will fail if the target is not empty.
+
+### Signature
+
+```python
+def delete_namespace(name: str, session: Optional[Session]) -> None:
+```
+
+- **`<namespace>`** — deletes the namespace (must contain no projects or datasets).
+- **`<namespace>.<project>`** — deletes the project (must contain no datasets).
+
+### Examples
+
+```python
+import datachain as dc
+
+dc.delete_namespace("dev.my-project")  # delete project
+dc.delete_namespace("dev")             # delete namespace
+```

{datachain-0.31.4 → datachain-0.32.1}/docs/references/datachain.md

@@ -19,6 +19,8 @@ for examples of how to create a chain.
 
 ::: datachain.lib.dc.datasets.move_dataset
 
+::: datachain.lib.namespaces.delete_namespace
+
 ::: datachain.lib.dc.hf.read_hf
 
 ::: datachain.lib.dc.json.read_json

datachain-0.32.1/docs/studio/webhooks.md

@@ -0,0 +1,265 @@
+# Webhooks in Studio
+
+## About webhooks
+
+Webhooks provide a way for the notifications to be delivered to an external web server whenever certain events occur in [Studio](https://studio.datachain.ai). With webhooks, you can set a setting once that you want to hear about certain events or activities .
+
+When you create a webhook, you specify a URL, and necessary information you want us to send to along with the events that you want to listen on Datachain. When the event occurs, Datachain Studio will send an HTTP request with the data about the event to the URL that you specified. If your server is setup to listen for webhook deliveries at that URL, it can take action when it receives one.
+
+For example, you can subscribe your webhook to events that occur when a job is created, is complete, is failed, is running, and so on. You can then monitor whenever a job is failed through this webhook.
+
+### Alternative
+As opposed to webhooks, you can also use [CLI command](../commands/index.md) to get the job information or some of our available [API endpoints](api/index.md) but webhook requires less effort than polling an API since it allows near real time updates.
+
+## Available event type
+As of now, your server can receive two different types of events.
+
+### JOB
+
+Whenever any job is created or any status is changed to the job, you will receive the JOB webhook event. The payload you get with the job webhook is as:
+
+Header: `http-x-datachain-event`: `JOB`
+
+Payload:
+```json
+{
+        "action": "job_status",
+        "job": {
+            "id": "da59df47-d121-4eb6-aa76-dc452755544e",
+            "status": "COMPLETE",
+            "error_message": "",
+            "created_at": "2021-07-27T16:02:08.070557",
+            "updated_at": "2021-07-27T16:22:08.070557",
+            "finished_at": "2021-07-27T16:22:08.070557",
+            "url": "https://studio.datachain.ai/team/TeamName/datasets/jobs/da59df47-d121-4eb6-aa76-dc452755544e"
+        },
+        "timestamp": "2021-07-27T16:22:08.070557",
+    }
+```
+
+### PING
+Whenever you add your webhook to your team, Studio sends a PING event to check the delivery to the server. You can check the recent deliveries to check if the webhook is successfully connected.
+
+Header: `http-x-datachain-event`: `PING`.
+
+Payload:
+```json
+{
+    "action": "PING"
+}
+```
+
+
+## Creating webhooks
+
+You should have admin access to a team to create the webhooks in the team. To create a webhook, go to settings for the team and under the section Webhooks, click on Add new Webhook.
+![Webhook Settings](../assets/webhook_list.png)
+
+Enter the necessary information to create the webhooks.
+
+- **URL:**  Enter the valid URL where you’d like to receive the webhook payload in
+- **Secret:** A string to use as a secret key. You should choose a random string of text with high entropy. You can use the webhook secret to [validate incoming requests](#validating-webhook-deliveries) to those only originating from Datachain Studio.
+- **Events:** Under events, select the events you would like to trigger the webhook.
+    - **JOB:**
+        - CREATED: When a job is created but not yet scheduled to run
+        - SCHEDULED: Job has been scheduled to run
+        - QUEUED: Job is in the queue waiting to be processed
+        - INIT: Job is initializing (starting up)
+        - RUNNING: When a job starts running
+        - COMPLETE: Job has completed successfully
+        - FAILED: Job failed with error
+        - CANCELED: Job has been canceled successfully
+        - CANCELING: Job has been scheduled to cancel
+        - TASK: A scheduled task is created.
+
+- SSL Verification: By default, we verify SSL certificates when delivering payloads. SSL verification helps ensure that hook payloads are delivered to your URL endpoint securely, keeping your data away from prying eyes. Disabling this option is **not recommended**.
+- HTTP Method: By default, we make a post request, but you can specify other http method if necessary.
+- Content Type: Optionally, select the data format you want to receive the webhook payload in
+    - **application/json** will deliver the JSON payload directly as the body of the `POST` request.
+    - **application/x-www-form-urlencoded** will send the JSON payload as a form parameter called `payload`.
+
+![Add webhook](../assets/webhook_dialog.png)
+
+
+## Handling webhook deliveries
+
+When you create a webhook, you specify a URL and subscribe to event types. When any event that your webhook is subscribed to occurs, Datachain Studio will send an HTTP request with the data about the event to the event that you specified. If your server is setup at that URL, it can take action when it receives one.
+
+### Setup
+
+In order to test your webhook locally, you can use a webhook proxy URL to forward the webhooks from Studio to your computer or codespace. We are using [smee.io](http://smee.io) to provide a webhook proxy url and forward webhooks.
+
+1. Go to [smee.io](http://smee.io)
+2. Start a new channel
+3. Copy the full URL under the webhook proxy URL. We will use this URL in the following setup steps.
+4. Install smee-client if it is not already installed using `npm install --global smee-client`
+5. To receive forwarded webhooks from smee.io, run the following command in your terminal. Replace the `WEBHOOK_PROXY_URL` with your webhook proxy URL from earlier.
+
+```bash
+smee --path /webhook --port 3000 --url WEBHOOK_PROXY_URL
+```
+
+6. Keep this running while you test out your webhook. When you want to stop forwarding the webhooks, enter Ctrl + C
+7. Create webhook using the step as mentioned above or edit the one if you already have with the url from earlier.
+8. Write code to handle webhook deliveries
+    1. Initialize your server to listen for requests to your webhook URL
+    2. Read HTTP headers and body from request
+    3. Take desired action in response to the request.
+
+You can use any programming languages that you can to run on your server.
+
+### Example Code
+
+#### Python
+
+This example uses the Python and Flask libraries to handle the routes and HTTP requests.
+
+To use this you must install flask library in your project. For example:
+
+```bash
+pip install Flask
+```
+
+Create a python file with following contents. Modify the code to handle only the event types that your webhook is subscribed to as well as the ping event that Studio sends when you create a webhook. This example handles job, dataset and ping events.
+
+```python
+# You installed the `flask` library earlier.
+from flask import Flask, request
+
+# This defines the port where your server should listen.
+# 3000 matches the port that you specified for webhook forwarding.
+#
+# Once you deploy your code to a server,
+# Change this to match the port where your server is listening.
+port = 3000
+secret = "secretString"
+
+# This initializes a new Flask application.
+app = Flask(__name__)
+
+# This defines a POST route at the `/webhook` path.
+# It matches the path you specified for the smee.io forwarding.
+#
+# Once you deploy your code to a server and update your webhook URL,
+# Change this to match the path portion of the URL for your webhook.
+@app.route('/webhook', methods=['POST'])
+def webhook():
+    # Respond to indicate that delivery was successfully received.
+    # Your server should respond with a 2XX response
+    # within 10 seconds of receiving a webhook delivery.
+    # If your server takes longer than that to respond,
+    # then Studio terminates the connection.
+
+    # Check `http-x-datachain-event` header for the event type.
+    datachain_event = request.headers.get('http-x-datachain-event')
+
+    # You should add logic to handle each event type
+    # that your webhook is subscribed to.
+    # For example, this code handles the `JOB` and `PING` events.
+    if datachain_event == 'JOB':
+        data = request.get_json()
+        action = data.get('action')
+        if action == 'job_status':
+            print(
+                f"Job status for job {data['job']['id']} was" \
+                " changed to {data['job']['status']}"
+            )
+        else:
+            print(f"Unhandled action for the job event: {action}")
+    elif datachain_event == 'PING':
+        print('Ping event received')
+    else:
+        print(f"Unhandled event: {datachain_event}")
+
+    return '', 202  # 202 Accepted status code
+
+# This starts the server.
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=port, debug=True)
+    print(f"Server is running on port {port}")
+
+```
+
+To test the code, run the file using `python FILENAME`. Make sure that you are forwarding the webhooks in a separate terminal.
+
+When you run a job in Studio, you will see some similar response as below:
+
+```prolog
+Ping event received
+Job status for job a852ee4a-091a-456f-ba1a-c809f7e804f3 was changed to CREATED
+Job status for job a852ee4a-091a-456f-ba1a-c809f7e804f3 was changed to SCHEDULED
+Job status for job a852ee4a-091a-456f-ba1a-c809f7e804f3 was changed to QUEUED
+Job status for job a852ee4a-091a-456f-ba1a-c809f7e804f3 was changed to INIT
+Job status for job a852ee4a-091a-456f-ba1a-c809f7e804f3 was changed to RUNNING
+Job status for job a852ee4a-091a-456f-ba1a-c809f7e804f3 was changed to COMPLETE
+```
+
+## Validating webhook deliveries
+
+Once your server is configured to receive payloads, it will listen for any delivery that’s sent to the endpoint you configured. To ensure that your server only processes webhook deliveries that were sent by Datachain Studio and to ensure that the delivery was not tampered with, you should validate webhook signature before processing the delivery further.
+
+Studio will use the secret you added when creating your webhook to create a hash signature that’s sent to you with each payload. The hash signature will appear in each delivery as the value of `X-datachain-signature-256` header.
+
+In your code that handles webhook deliveries, you should calculate a hash using your secret token and compare the hash Studio sent with the expected hash that you calculate and ensure they match.
+
+Notes:
+
+- Studio uses HMAC hex digest to compute the hash
+- The hash signature always starts with `sha256=`
+- The hash signature is generated using webhook’s secret token and payload contents.
+- Never use a plain `==` operator. Instead consider using a method like [`secure_compare`](https://www.rubydoc.info/gems/rack/Rack%2FUtils:secure_compare) or [`crypto.timingSafeEqual`](https://nodejs.org/api/crypto.html#cryptotimingsafeequala-b), which performs a "constant time" string comparison to help mitigate certain timing attacks against regular equality operators, or regular loops in JIT-optimized languages.
+
+Updating the example above:
+
+```python
+import hashlib
+import hmac
+from flask import abort
+
+def verify_signature(payload_body, secret_token, signature_header):
+    """Verify the payload was sent from Studio by validating SHA256.
+
+    Raise and return 403 if not authorized.
+
+    Args:
+        payload_body: request body to verify (request.body())
+        secret_token: Studio webhook token (WEBHOOK_SECRET)
+        signature_header: header (x-datachain-signature-256)
+    """
+    if not signature_header:
+        abort(403, "X-datachain-signature-256 is missing!")
+    hash_object = hmac.new(
+        secret_token.encode('utf-8'),
+        msg=payload_body,
+        digestmod=hashlib.sha256
+    )
+    expected_signature = "sha256=" + hash_object.hexdigest()
+    if not hmac.compare_digest(
+        expected_signature, signature_header
+    ):
+        abort(403, "Request signatures didn't match!")
+```
+
+Add the following call in the api receiver.
+
+```python
+# Get the signature header
+signature = request.headers.get('X-Datachain-Signature-256')
+
+# Re-enable signature verification with improved JSON handling
+if signature:
+    verify_signature(request.get_data(), secret, signature)
+else:
+    print("Warning: No signature header found")
+```
+
+## Best practices for using Webhooks
+
+1. You should only subscribe to the webhook events that you need. This will reduce the amount of work your server needs to do.
+2. The webhook secret should be a random string of text with high entropy. You should securely store your webhook secret in a way that your server can access.
+3. You should ensure that your server uses an HTTPS connection. By default, Studio will verify SSL certificates when delivering webhooks. Studio recommends that you leave SSL verification enabled.
+4. Your server should respond with a 2XX response within 10 seconds of receiving a webhook delivery. If your server takes longer than that to respond, then Studio terminates the connection and considers the delivery a failure.
+5. Check the event header and action type before processing the event.
+6. Make sure the endpoints are idempotent meaning if multiple requests for same event is received, the server should handle this.
+7. Datachain Studio may deliver webhooks in a different order than the order in which the events took place. If you need to know when the event occurred relative to another event, you should use the timestamps that are included in the delivery payload.
+8. Consecutive 10 failures to webhook will disable the webhook deliveries.

{datachain-0.31.4 → datachain-0.32.1}/mkdocs.yml

@@ -119,6 +119,7 @@ nav:
           - Local DB Migrations: guide/db_migrations.md
       - 🔗 Studio:
           - API: studio/api/index.md
+          - Webhooks: studio/webhooks.md
       - 🤝 Contributing: contributing.md
 
   - DataChain Website ↗: https://datachain.ai" target="_blank"

{datachain-0.31.4 → datachain-0.32.1}/src/datachain/__init__.py

@@ -37,6 +37,7 @@ from datachain.lib.file import (
     VideoFrame,
 )
 from datachain.lib.model_store import ModelStore
+from datachain.lib.namespaces import delete_namespace
 from datachain.lib.projects import create as create_project
 from datachain.lib.udf import Aggregator, Generator, Mapper
 from datachain.lib.utils import AbstractUDF, DataChainError
@@ -74,6 +75,7 @@ __all__ = [
     "create_project",
     "datasets",
     "delete_dataset",
+    "delete_namespace",
     "is_chain_type",
     "is_studio",
     "listings",

{datachain-0.31.4 → datachain-0.32.1}/src/datachain/data_storage/metastore.py

@@ -22,6 +22,7 @@ from sqlalchemy import (
     UniqueConstraint,
     select,
 )
+from sqlalchemy.sql import func as f
 
 from datachain.data_storage import JobQueryType, JobStatus
 from datachain.data_storage.serializer import Serializable
@@ -37,7 +38,9 @@ from datachain.dataset import (
 from datachain.error import (
     DatasetNotFoundError,
     DatasetVersionNotFoundError,
+    NamespaceDeleteNotAllowedError,
     NamespaceNotFoundError,
+    ProjectDeleteNotAllowedError,
     ProjectNotFoundError,
     TableMissingError,
 )
@@ -141,6 +144,10 @@ class AbstractMetastore(ABC, Serializable):
     def get_namespace(self, name: str, conn=None) -> Namespace:
         """Gets a single namespace by name"""
 
+    @abstractmethod
+    def remove_namespace(self, namespace_id: int, conn=None) -> None:
+        """Removes a single namespace by id"""
+
     @abstractmethod
     def list_namespaces(self, conn=None) -> list[Namespace]:
         """Gets a list of all namespaces"""
@@ -190,10 +197,30 @@ class AbstractMetastore(ABC, Serializable):
         It also creates project if not found and create flag is set to True.
         """
 
+    def is_default_project(self, project_name: str, namespace_name: str) -> bool:
+        return (
+            project_name == self.default_project_name
+            and namespace_name == self.default_namespace_name
+        )
+
+    def is_listing_project(self, project_name: str, namespace_name: str) -> bool:
+        return (
+            project_name == self.listing_project_name
+            and namespace_name == self.system_namespace_name
+        )
+
     @abstractmethod
     def get_project_by_id(self, project_id: int, conn=None) -> Project:
         """Gets a single project by id"""
 
+    @abstractmethod
+    def count_projects(self, namespace_id: Optional[int] = None) -> int:
+        """Counts projects in some namespace or in general."""
+
+    @abstractmethod
+    def remove_project(self, project_id: int, conn=None) -> None:
+        """Removes a single project by id"""
+
     @abstractmethod
     def list_projects(self, namespace_id: Optional[int], conn=None) -> list[Project]:
         """Gets list of projects in some namespace or in general (in all namespaces)"""
@@ -270,6 +297,10 @@ class AbstractMetastore(ABC, Serializable):
     ) -> Iterator[DatasetListRecord]:
         """Lists all datasets in some project or in all projects."""
 
+    @abstractmethod
+    def count_datasets(self, project_id: Optional[int] = None) -> int:
+        """Counts datasets in some project or in all projects."""
+
     @abstractmethod
     def list_datasets_by_prefix(
         self, prefix: str, project_id: Optional[int] = None
@@ -735,6 +766,18 @@ class AbstractDBMetastore(AbstractMetastore):
 
         return self.get_namespace(name)
 
+    def remove_namespace(self, namespace_id: int, conn=None) -> None:
+        num_projects = self.count_projects(namespace_id)
+        if num_projects > 0:
+            raise NamespaceDeleteNotAllowedError(
+                f"Namespace cannot be removed. It contains {num_projects} project(s). "
+                "Please remove the project(s) first."
+            )
+
+        n = self._namespaces
+        with self.db.transaction():
+            self.db.execute(self._namespaces_delete().where(n.c.id == namespace_id))
+
     def get_namespace(self, name: str, conn=None) -> Namespace:
         """Gets a single namespace by name"""
         n = self._namespaces
@@ -796,18 +839,6 @@ class AbstractDBMetastore(AbstractMetastore):
 
         return self.get_project(name, namespace.name)
 
-    def _is_listing_project(self, project_name: str, namespace_name: str) -> bool:
-        return (
-            project_name == self.listing_project_name
-            and namespace_name == self.system_namespace_name
-        )
-
-    def _is_default_project(self, project_name: str, namespace_name: str) -> bool:
-        return (
-            project_name == self.default_project_name
-            and namespace_name == self.default_namespace_name
-        )
-
     def get_project(
         self, name: str, namespace_name: str, create: bool = False, conn=None
     ) -> Project:
@@ -816,7 +847,7 @@ class AbstractDBMetastore(AbstractMetastore):
         p = self._projects
         validate = True
 
-        if self._is_listing_project(name, namespace_name) or self._is_default_project(
+        if self.is_listing_project(name, namespace_name) or self.is_default_project(
             name, namespace_name
         ):
             # we are always creating default and listing projects if they don't exist
@@ -858,7 +889,31 @@ class AbstractDBMetastore(AbstractMetastore):
             raise ProjectNotFoundError(f"Project with id {project_id} not found.")
         return self.project_class.parse(*rows[0])
 
-    def list_projects(self, namespace_id: Optional[int], conn=None) -> list[Project]:
+    def count_projects(self, namespace_id: Optional[int] = None) -> int:
+        p = self._projects
+        query = self._projects_select()
+        if namespace_id:
+            query = query.where(p.c.namespace_id == namespace_id)
+
+        query = select(f.count(1)).select_from(query.subquery())
+
+        return next(self.db.execute(query))[0]
+
+    def remove_project(self, project_id: int, conn=None) -> None:
+        num_datasets = self.count_datasets(project_id)
+        if num_datasets > 0:
+            raise ProjectDeleteNotAllowedError(
+                f"Project cannot be removed. It contains {num_datasets} dataset(s). "
+                "Please remove the dataset(s) first."
+            )
+
+        p = self._projects
+        with self.db.transaction():
+            self.db.execute(self._projects_delete().where(p.c.id == project_id))
+
+    def list_projects(
+        self, namespace_id: Optional[int] = None, conn=None
+    ) -> list[Project]:
         """
         Gets a list of projects inside some namespace, or in all namespaces
         """
@@ -1189,7 +1244,6 @@ class AbstractDBMetastore(AbstractMetastore):
     def list_datasets(
         self, project_id: Optional[int] = None
     ) -> Iterator["DatasetListRecord"]:
-        """Lists all datasets."""
         d = self._datasets
         query = self._base_list_datasets_query().order_by(
             self._datasets.c.name, self._datasets_versions.c.version
@@ -1198,6 +1252,16 @@ class AbstractDBMetastore(AbstractMetastore):
             query = query.where(d.c.project_id == project_id)
         yield from self._parse_dataset_list(self.db.execute(query))
 
+    def count_datasets(self, project_id: Optional[int] = None) -> int:
+        d = self._datasets
+        query = self._datasets_select()
+        if project_id:
+            query = query.where(d.c.project_id == project_id)
+
+        query = select(f.count(1)).select_from(query.subquery())
+
+        return next(self.db.execute(query))[0]
+
     def list_datasets_by_prefix(
         self, prefix: str, project_id: Optional[int] = None, conn=None
     ) -> Iterator["DatasetListRecord"]:

{datachain-0.31.4 → datachain-0.32.1}/src/datachain/error.py

@@ -34,6 +34,14 @@ class ProjectCreateNotAllowedError(NotAllowedError):
     pass
 
 
+class ProjectDeleteNotAllowedError(NotAllowedError):
+    pass
+
+
+class NamespaceDeleteNotAllowedError(NotAllowedError):
+    pass
+
+
 class ProjectNotFoundError(NotFoundError):
     pass