dataiku-api-client 15.1.0__tar.gz → 15.2.0__tar.gz

{dataiku_api_client-15.1.0 → dataiku_api_client-15.2.0}/HISTORY.txt

@@ -2,6 +2,11 @@ Changelog
 ==========
 
 
+15.2.0 (2026-10-16)
+-------------------
+
+* Initial release for DSS 15.2.0
+
 15.1.0 (2026-10-09)
 -------------------
 

{dataiku_api_client-15.1.0/dataiku_api_client.egg-info → dataiku_api_client-15.2.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: dataiku-api-client
-Version: 15.1.0
+Version: 15.2.0
 Summary: Python API client for Dataiku APIs
 Home-page: https://www.dataiku.com
-Download-URL: https://github.com/dataiku/dataiku-api-client-python/tarball/15.1.0
+Download-URL: https://github.com/dataiku/dataiku-api-client-python/tarball/15.2.0
 Author: Dataiku
 Author-email: support@dataiku.com
 License: Apache Software License
@@ -36,6 +36,11 @@ Changelog
 ==========
 
 
+15.2.0 (2026-10-16)
+-------------------
+
+* Initial release for DSS 15.2.0
+
 15.1.0 (2026-10-09)
 -------------------
 

{dataiku_api_client-15.1.0 → dataiku_api_client-15.2.0/dataiku_api_client.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: dataiku-api-client
-Version: 15.1.0
+Version: 15.2.0
 Summary: Python API client for Dataiku APIs
 Home-page: https://www.dataiku.com
-Download-URL: https://github.com/dataiku/dataiku-api-client-python/tarball/15.1.0
+Download-URL: https://github.com/dataiku/dataiku-api-client-python/tarball/15.2.0
 Author: Dataiku
 Author-email: support@dataiku.com
 License: Apache Software License
@@ -36,6 +36,11 @@ Changelog
 ==========
 
 
+15.2.0 (2026-10-16)
+-------------------
+
+* Initial release for DSS 15.2.0
+
 15.1.0 (2026-10-09)
 -------------------
 

{dataiku_api_client-15.1.0 → dataiku_api_client-15.2.0}/dataiku_api_client.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ dataiku_api_client.egg-info/dependency_links.txt
 dataiku_api_client.egg-info/requires.txt
 dataiku_api_client.egg-info/top_level.txt
 dataikuapi/__init__.py
+dataikuapi/agentmanagement_client.py
 dataikuapi/apinode_admin_client.py
 dataikuapi/apinode_client.py
 dataikuapi/auth.py
@@ -20,6 +21,21 @@ dataikuapi/govern_client.py
 dataikuapi/launchpad_client.py
 dataikuapi/utils.py
 dataikuapi/_vendor/__init__.py
+dataikuapi/_vendor/requests_toolbelt/__init__.py
+dataikuapi/_vendor/requests_toolbelt/_compat.py
+dataikuapi/_vendor/requests_toolbelt/multipart/__init__.py
+dataikuapi/_vendor/requests_toolbelt/multipart/encoder.py
+dataikuapi/agentmanagement/__init__.py
+dataikuapi/agentmanagement/_utils.py
+dataikuapi/agentmanagement/agent.py
+dataikuapi/agentmanagement/alerting.py
+dataikuapi/agentmanagement/cobuild.py
+dataikuapi/agentmanagement/metrics.py
+dataikuapi/agentmanagement/operations.py
+dataikuapi/agentmanagement/platform.py
+dataikuapi/agentmanagement/risk.py
+dataikuapi/agentmanagement/settings.py
+dataikuapi/agentmanagement/topic_family.py
 dataikuapi/apinode_admin/__init__.py
 dataikuapi/apinode_admin/auth.py
 dataikuapi/apinode_admin/service.py
@@ -37,7 +53,6 @@ dataikuapi/dss/businessapp.py
 dataikuapi/dss/cobuild.py
 dataikuapi/dss/codestudio.py
 dataikuapi/dss/continuousactivity.py
-dataikuapi/dss/dam.py
 dataikuapi/dss/dashboard.py
 dataikuapi/dss/data_collection.py
 dataikuapi/dss/data_directories_footprint.py
@@ -64,7 +79,6 @@ dataikuapi/dss/managedfolder.py
 dataikuapi/dss/meaning.py
 dataikuapi/dss/messaging_channel.py
 dataikuapi/dss/metrics.py
-dataikuapi/dss/mira.py
 dataikuapi/dss/ml.py
 dataikuapi/dss/mlflow.py
 dataikuapi/dss/modelcomparison.py

{dataiku_api_client-15.1.0 → dataiku_api_client-15.2.0}/dataikuapi/__init__.py

@@ -8,7 +8,8 @@ from .apinode_admin_client import APINodeAdminClient
 from .dss.recipe import GroupingRecipeCreator, UpsertRecipeCreator, JoinRecipeCreator, StackRecipeCreator, WindowRecipeCreator, SyncRecipeCreator, SamplingRecipeCreator, SQLQueryRecipeCreator, CodeRecipeCreator, SplitRecipeCreator, SortRecipeCreator, TopNRecipeCreator, DistinctRecipeCreator, DownloadRecipeCreator, PredictionScoringRecipeCreator, ClusteringScoringRecipeCreator
 
 from .dss.admin import DSSUserImpersonationRule, DSSGroupImpersonationRule
-from .dss.dam import DAMAgentFilter
+from .agentmanagement_client import AgentManagementClient
+from .agentmanagement.agent import AgentFilter
 
 import sys
 import warnings

dataiku_api_client-15.2.0/dataikuapi/_vendor/requests_toolbelt/__init__.py

@@ -0,0 +1,8 @@
+# Vendored from requests-toolbelt.
+# Source: https://github.com/requests/toolbelt/tree/1.0.0
+# License: Apache-2.0
+# Modified from upstream by Dataiku.
+
+from .multipart.encoder import MultipartEncoder
+
+__all__ = ["MultipartEncoder"]

dataiku_api_client-15.2.0/dataikuapi/_vendor/requests_toolbelt/_compat.py

@@ -0,0 +1,66 @@
+#
+# Vendored from requests-toolbelt.
+# Source: https://github.com/requests/toolbelt/tree/1.0.0
+# License: Apache-2.0
+# Modified from upstream by Dataiku.
+#
+"""Private module full of compatibility hacks.
+
+Primarily this is for downstream redistributions of requests that unvendor
+urllib3 without providing a shim.
+
+.. warning::
+
+    This module is private. If you use it, and something breaks, you were
+    warned
+"""
+
+# Not used:
+# import requests
+
+try:
+    from requests.packages.urllib3 import fields
+except ImportError:
+    from urllib3 import fields
+
+# Not used:
+# try:
+#     from requests.packages.urllib3.connection import HTTPConnection
+#     from requests.packages.urllib3 import connection
+# except ImportError:
+#     try:
+#         from urllib3.connection import HTTPConnection
+#         from urllib3 import connection
+#     except ImportError:
+#         HTTPConnection = None
+#         connection = None
+
+# Not used:
+# if requests.__build__ < 0x020300:
+#     timeout = None
+# else:
+#     try:
+#         from requests.packages.urllib3.util import timeout
+#     except ImportError:
+#         from urllib3.util import timeout
+
+# Not used:
+# import sys
+# PY3 = sys.version_info > (3, 0)
+
+# Not used:
+# if PY3:
+#     from collections.abc import Mapping, MutableMapping
+#     import queue
+#     from urllib.parse import urlencode, urljoin
+# else:
+#     from collections import Mapping, MutableMapping
+#     import Queue as queue
+#     from urllib import urlencode
+#     from urlparse import urljoin
+
+# Not used:
+# try:
+#     basestring = basestring
+# except NameError:
+#     basestring = (str, bytes)

dataiku_api_client-15.2.0/dataikuapi/_vendor/requests_toolbelt/multipart/__init__.py

@@ -0,0 +1,9 @@
+#
+# Vendored from requests-toolbelt.
+# Source: https://github.com/requests/toolbelt/tree/1.0.0
+# License: Apache-2.0
+# Modified from upstream by Dataiku.
+#
+from .encoder import MultipartEncoder
+
+__all__ = ["MultipartEncoder"]

dataiku_api_client-15.2.0/dataikuapi/_vendor/requests_toolbelt/multipart/encoder.py

@@ -0,0 +1,471 @@
+# -*- coding: utf-8 -*-
+#
+# Vendored from requests-toolbelt.
+# Source: https://github.com/requests/toolbelt/tree/1.0.0
+# License: Apache-2.0
+# Modified from upstream by Dataiku.
+#
+"""
+
+requests_toolbelt.multipart.encoder
+===================================
+
+This holds all of the implementation details of the MultipartEncoder
+
+"""
+import contextlib
+import io
+import os
+from uuid import uuid4
+
+# Not used:
+# import requests
+
+from .._compat import fields
+
+
+class MultipartEncoder(object):
+
+    """
+
+    The ``MultipartEncoder`` object is a generic interface to the engine that
+    will create a ``multipart/form-data`` body for you.
+
+    The basic usage is:
+
+    .. code-block:: python
+
+        import requests
+        from requests_toolbelt import MultipartEncoder
+
+        encoder = MultipartEncoder({'field': 'value',
+                                    'other_field': 'other_value'})
+        r = requests.post('https://httpbin.org/post', data=encoder,
+                          headers={'Content-Type': encoder.content_type})
+
+    If you do not need to take advantage of streaming the post body, you can
+    also do:
+
+    .. code-block:: python
+
+        r = requests.post('https://httpbin.org/post',
+                          data=encoder.to_string(),
+                          headers={'Content-Type': encoder.content_type})
+
+    If you want the encoder to use a specific order, you can use an
+    OrderedDict or more simply, a list of tuples:
+
+    .. code-block:: python
+
+        encoder = MultipartEncoder([('field', 'value'),
+                                    ('other_field', 'other_value')])
+
+    .. versionchanged:: 0.4.0
+
+    You can also provide tuples as part values as you would provide them to
+    requests' ``files`` parameter.
+
+    .. code-block:: python
+
+        encoder = MultipartEncoder({
+            'field': ('file_name', b'{"a": "b"}', 'application/json',
+                      {'X-My-Header': 'my-value'})
+        })
+
+    .. warning::
+
+        This object will end up directly in :mod:`httplib`. Currently,
+        :mod:`httplib` has a hard-coded read size of **8192 bytes**. This
+        means that it will loop until the file has been read and your upload
+        could take a while. This is **not** a bug in requests. A feature is
+        being considered for this object to allow you, the user, to specify
+        what size should be returned on a read. If you have opinions on this,
+        please weigh in on `this issue`_.
+
+    .. _this issue:
+        https://github.com/requests/toolbelt/issues/75
+
+    """
+
+    def __init__(self, fields, boundary=None, encoding='utf-8'):
+        #: Boundary value either passed in by the user or created
+        self.boundary_value = boundary or uuid4().hex
+
+        # Computed boundary
+        self.boundary = '--{}'.format(self.boundary_value)
+
+        #: Encoding of the data being passed in
+        self.encoding = encoding
+
+        # Pre-encoded boundary
+        self._encoded_boundary = b''.join([
+            encode_with(self.boundary, self.encoding),
+            encode_with('\r\n', self.encoding)
+            ])
+
+        #: Fields provided by the user
+        self.fields = fields
+
+        #: Whether or not the encoder is finished
+        self.finished = False
+
+        #: Pre-computed parts of the upload
+        self.parts = []
+
+        # Pre-computed parts iterator
+        self._iter_parts = iter([])
+
+        # The part we're currently working with
+        self._current_part = None
+
+        # Cached computation of the body's length
+        self._len = None
+
+        # Our buffer
+        self._buffer = CustomBytesIO(encoding=encoding)
+
+        # Pre-compute each part's headers
+        self._prepare_parts()
+
+        # Load boundary into buffer
+        self._write_boundary()
+
+    @property
+    def len(self):
+        """Length of the multipart/form-data body.
+
+        requests will first attempt to get the length of the body by calling
+        ``len(body)`` and then by checking for the ``len`` attribute.
+
+        On 32-bit systems, the ``__len__`` method cannot return anything
+        larger than an integer (in C) can hold. If the total size of the body
+        is even slightly larger than 4GB users will see an OverflowError. This
+        manifested itself in `bug #80`_.
+
+        As such, we now calculate the length lazily as a property.
+
+        .. _bug #80:
+            https://github.com/requests/toolbelt/issues/80
+        """
+        return self._len or self._calculate_length()
+
+# Not used:
+#     def __repr__(self):
+#         pass
+
+    def _calculate_length(self):
+        """
+        This uses the parts to calculate the length of the body.
+
+        This returns the calculated length so __len__ can be lazy.
+        """
+        boundary_len = len(self.boundary)
+        self._len = sum(
+            (boundary_len + total_len(p) + 4) for p in self.parts
+            ) + boundary_len + 4
+        return self._len
+
+    def _calculate_load_amount(self, read_size):
+        """This calculates how many bytes need to be added to the buffer.
+
+        When a consumer read's ``x`` from the buffer, there are two cases to
+        satisfy:
+
+            1. Enough data in the buffer to return the requested amount
+            2. Not enough data
+
+        This function uses the amount of unread bytes in the buffer and
+        determines how much the Encoder has to load before it can return the
+        requested amount of bytes.
+
+        :param int read_size: the number of bytes the consumer requests
+        :returns: int -- the number of bytes that must be loaded into the
+            buffer before the read can be satisfied. This will be strictly
+            non-negative
+        """
+        amount = read_size - total_len(self._buffer)
+        return amount if amount > 0 else 0
+
+    def _load(self, amount):
+        """Load ``amount`` number of bytes into the buffer."""
+        self._buffer.smart_truncate()
+        part = self._current_part or self._next_part()
+        while amount == -1 or amount > 0:
+            written = 0
+            if part and not part.bytes_left_to_write():
+                written += self._write(b'\r\n')
+                written += self._write_boundary()
+                part = self._next_part()
+
+            if not part:
+                written += self._write_closing_boundary()
+                self.finished = True
+                break
+
+            written += part.write_to(self._buffer, amount)
+
+            if amount != -1:
+                amount -= written
+
+    def _next_part(self):
+        try:
+            p = self._current_part = next(self._iter_parts)
+        except StopIteration:
+            p = None
+        return p
+
+    def _iter_fields(self):
+        _fields = self.fields
+        if hasattr(self.fields, 'items'):
+            _fields = list(self.fields.items())
+        for k, v in _fields:
+            file_name = None
+            file_type = None
+            file_headers = None
+            if isinstance(v, (list, tuple)):
+                if len(v) == 2:
+                    file_name, file_pointer = v
+                elif len(v) == 3:
+                    file_name, file_pointer, file_type = v
+                else:
+                    file_name, file_pointer, file_type, file_headers = v
+            else:
+                file_pointer = v
+
+            field = fields.RequestField(name=k, data=file_pointer,
+                                        filename=file_name,
+                                        headers=file_headers)
+            field.make_multipart(content_type=file_type)
+            yield field
+
+    def _prepare_parts(self):
+        """This uses the fields provided by the user and creates Part objects.
+
+        It populates the `parts` attribute and uses that to create a
+        generator for iteration.
+        """
+        enc = self.encoding
+        self.parts = [Part.from_field(f, enc) for f in self._iter_fields()]
+        self._iter_parts = iter(self.parts)
+
+    def _write(self, bytes_to_write):
+        """Write the bytes to the end of the buffer.
+
+        :param bytes bytes_to_write: byte-string (or bytearray) to append to
+            the buffer
+        :returns: int -- the number of bytes written
+        """
+        return self._buffer.append(bytes_to_write)
+
+    def _write_boundary(self):
+        """Write the boundary to the end of the buffer."""
+        return self._write(self._encoded_boundary)
+
+    def _write_closing_boundary(self):
+        """Write the bytes necessary to finish a multipart/form-data body."""
+        with reset(self._buffer):
+            self._buffer.seek(-2, 2)
+            self._buffer.write(b'--\r\n')
+        return 2
+
+# Not used:
+#     def _write_headers(self, headers):
+#         pass
+
+    @property
+    def content_type(self):
+        return str(
+            'multipart/form-data; boundary={}'.format(self.boundary_value)
+            )
+
+# Not used:
+#     def to_string(self):
+#         pass
+
+    def read(self, size=-1):
+        """Read data from the streaming encoder.
+
+        :param int size: (optional), If provided, ``read`` will return exactly
+            that many bytes. If it is not provided, it will return the
+            remaining bytes.
+        :returns: bytes
+        """
+        if self.finished:
+            return self._buffer.read(size)
+
+        bytes_to_load = size
+        if bytes_to_load != -1 and bytes_to_load is not None:
+            bytes_to_load = self._calculate_load_amount(int(size))
+
+        self._load(bytes_to_load)
+        return self._buffer.read(size)
+
+def encode_with(string, encoding):
+    """Encoding ``string`` with ``encoding`` if necessary.
+
+    :param str string: If string is a bytes object, it will not encode it.
+        Otherwise, this function will encode it with the provided encoding.
+    :param str encoding: The encoding with which to encode string.
+    :returns: encoded bytes object
+    """
+    if not (string is None or isinstance(string, bytes)):
+        return string.encode(encoding)
+    return string
+
+
+# Not used:
+# def readable_data(data, encoding):
+#     pass
+
+
+def total_len(o):
+    if hasattr(o, '__len__'):
+        return len(o)
+
+    if hasattr(o, 'len'):
+        return o.len
+
+    if hasattr(o, 'fileno'):
+        try:
+            fileno = o.fileno()
+        except io.UnsupportedOperation:
+            pass
+        else:
+            return os.fstat(fileno).st_size
+
+    if hasattr(o, 'getvalue'):
+        return len(o.getvalue())
+
+
+@contextlib.contextmanager
+def reset(buffer):
+    """Keep track of the buffer's current position and write to the end.
+
+    This is a context manager meant to be used when adding data to the buffer.
+    It eliminates the need for every function to be concerned with the
+    position of the cursor in the buffer.
+    """
+    original_position = buffer.tell()
+    buffer.seek(0, 2)
+    yield
+    buffer.seek(original_position, 0)
+
+
+def coerce_data(data, encoding):
+    """Ensure that every object's __len__ behaves uniformly."""
+    if not isinstance(data, CustomBytesIO):
+        if hasattr(data, 'getvalue'):
+            if hasattr(data, 'read'):
+                # Consume from the current cursor, as requests' ``files``
+                # parameter does, rather than restarting at byte zero.
+                return CustomBytesIO(data.read(), encoding)
+            return CustomBytesIO(data.getvalue(), encoding)
+
+        if hasattr(data, 'fileno'):
+            return FileWrapper(data)
+
+        if not hasattr(data, 'read'):
+            return CustomBytesIO(data, encoding)
+
+    return data
+
+
+# Not used:
+# def to_list(fields):
+#     pass
+
+
+class Part(object):
+    def __init__(self, headers, body):
+        self.headers = headers
+        self.body = body
+        self.headers_unread = True
+        self.len = len(self.headers) + total_len(self.body)
+
+    @classmethod
+    def from_field(cls, field, encoding):
+        """Create a part from a Request Field generated by urllib3."""
+        headers = encode_with(field.render_headers(), encoding)
+        body = coerce_data(field.data, encoding)
+        return cls(headers, body)
+
+    def bytes_left_to_write(self):
+        """Determine if there are bytes left to write.
+
+        :returns: bool -- ``True`` if there are bytes left to write, otherwise
+            ``False``
+        """
+        to_read = 0
+        if self.headers_unread:
+            to_read += len(self.headers)
+
+        return (to_read + total_len(self.body)) > 0
+
+    def write_to(self, buffer, size):
+        """Write the requested amount of bytes to the buffer provided.
+
+        The number of bytes written may exceed size on the first read since we
+        load the headers ambitiously.
+
+        :param CustomBytesIO buffer: buffer we want to write bytes to
+        :param int size: number of bytes requested to be written to the buffer
+        :returns: int -- number of bytes actually written
+        """
+        written = 0
+        if self.headers_unread:
+            written += buffer.append(self.headers)
+            self.headers_unread = False
+
+        while total_len(self.body) > 0 and (size == -1 or written < size):
+            amount_to_read = size
+            if size != -1:
+                amount_to_read = size - written
+            written += buffer.append(self.body.read(amount_to_read))
+
+        return written
+
+
+class CustomBytesIO(io.BytesIO):
+    def __init__(self, buffer=None, encoding='utf-8'):
+        buffer = encode_with(buffer, encoding)
+        super(CustomBytesIO, self).__init__(buffer)
+
+    def _get_end(self):
+        current_pos = self.tell()
+        self.seek(0, 2)
+        length = self.tell()
+        self.seek(current_pos, 0)
+        return length
+
+    @property
+    def len(self):
+        length = self._get_end()
+        return length - self.tell()
+
+    def append(self, bytes_):
+        with reset(self):
+            written = self.write(bytes_)
+        return written
+
+    def smart_truncate(self):
+        to_be_read = total_len(self)
+        already_read = self._get_end() - to_be_read
+
+        if already_read >= to_be_read:
+            old_bytes = self.read()
+            self.seek(0, 0)
+            self.truncate()
+            self.write(old_bytes)
+            self.seek(0, 0)
+
+
+class FileWrapper(object):
+    def __init__(self, file_object):
+        self.fd = file_object
+
+    @property
+    def len(self):
+        return total_len(self.fd) - self.fd.tell()
+
+    def read(self, length=-1):
+        return self.fd.read(length)

dataiku_api_client-15.2.0/dataikuapi/agentmanagement/__init__.py

@@ -0,0 +1 @@
+"""Resource handles for the Dataiku Agent Management API."""