tableauserverclient 0.37__tar.gz → 0.39__tar.gz

{tableauserverclient-0.37 → tableauserverclient-0.39}/MANIFEST.in

@@ -4,8 +4,6 @@ include CONTRIBUTORS.md
 include LICENSE
 include LICENSE.versioneer
 include README.md
-include tableauserverclient/_version.py
-include versioneer.py
 recursive-include docs *.md
 recursive-include samples *.py
 recursive-include samples *.txt
@@ -18,5 +16,4 @@ recursive-include test *.png
 recursive-include test *.py
 recursive-include test *.xml
 recursive-include test *.tde
-global-include *.pyi
 global-include *.typed

{tableauserverclient-0.37 → tableauserverclient-0.39}/PKG-INFO

@@ -1,30 +1,8 @@
 Metadata-Version: 2.4
 Name: tableauserverclient
-Version: 0.37
+Version: 0.39
 Summary: A Python module for working with the Tableau Server REST API.
 Author-email: Tableau <github@tableau.com>
-License: The MIT License (MIT)
-        
-        Copyright (c) 2022 Tableau
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
 Project-URL: repository, https://github.com/tableau/server-client-python
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -36,20 +14,21 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-License-File: LICENSE.versioneer
 Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: packaging>=23.1
 Requires-Dist: requests>=2.32
-Requires-Dist: urllib3<3,>=2.2.2
+Requires-Dist: urllib3<3,>=2.6.0
 Requires-Dist: typing_extensions>=4.0
 Provides-Extra: test
-Requires-Dist: black==24.8; extra == "test"
+Requires-Dist: black==24.10; extra == "test"
 Requires-Dist: build; extra == "test"
 Requires-Dist: mypy==1.4; extra == "test"
 Requires-Dist: pytest>=7.0; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-subtests; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
 Requires-Dist: requests-mock<2.0,>=1.0; extra == "test"
+Requires-Dist: types-requests>=2.32.4.20250913; extra == "test"
 Dynamic: license-file
 
 # Tableau Server Client (Python)

{tableauserverclient-0.37 → tableauserverclient-0.39}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=75.0", "versioneer[toml]==0.29", "wheel"]
+requires = ["setuptools>=77.0", "versioneer[toml]==0.29", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -8,14 +8,14 @@ name="tableauserverclient"
 dynamic = ["version"]
 description='A Python module for working with the Tableau Server REST API.'
 authors = [{name="Tableau", email="github@tableau.com"}]
-license = {file = "LICENSE"}
+license-files = ["LICENSE"]
 readme = "README.md"
 
 dependencies = [
     'defusedxml>=0.7.1',  # latest as at 7/31/23
     'packaging>=23.1',   # latest as at 7/31/23
     'requests>=2.32',  # latest as at 7/31/23
-    'urllib3>=2.2.2,<3',
+    'urllib3>=2.6.0,<3',
     'typing_extensions>=4.0',
 ]
 requires-python = ">=3.9"
@@ -32,8 +32,13 @@ classifiers = [
 repository = "https://github.com/tableau/server-client-python"
 
 [project.optional-dependencies]
-test = ["black==24.8", "build", "mypy==1.4", "pytest>=7.0", "pytest-cov", "pytest-subtests",
-    "requests-mock>=1.0,<2.0"]
+test = ["black==24.10", "build", "mypy==1.4", "pytest>=7.0", "pytest-cov", "pytest-subtests",
+    "pytest-xdist", "requests-mock>=1.0,<2.0", "types-requests>=2.32.4.20250913"]
+
+[tool.setuptools.packages.find]
+where = ["tableauserverclient"]
+[tool.setuptools.dynamic]
+version = {attr = "versioneer.get_version"}
 
 [tool.black]
 line-length = 120
@@ -61,5 +66,5 @@ addopts = "--junitxml=./test.junit.xml"
 VCS = "git"
 style = "pep440-pre"
 versionfile_source = "tableauserverclient/bin/_version.py"
-versionfile_build = "tableauserverclient/bin/_version.py"
+versionfile_build = "_version.py"
 tag_prefix = "v"

tableauserverclient-0.39/samples/create_user.py

@@ -0,0 +1,73 @@
+####
+# This script demonstrates how to create a user using the Tableau
+# Server Client.
+#
+# To run the script, you must have installed Python 3.7 or later.
+####
+
+
+import argparse
+import logging
+import os
+import sys
+from typing import Sequence
+
+import tableauserverclient as TSC
+
+
+def parse_args(args: Sequence[str] | None) -> argparse.Namespace:
+    """
+    Parse command line parameters
+    """
+    if args is None:
+        args = sys.argv[1:]
+    parser = argparse.ArgumentParser(description="Creates a sample user group.")
+    # Common options; please keep those in sync across all samples
+    parser.add_argument("--server", "-s", help="server address")
+    parser.add_argument("--site", "-S", help="site name")
+    parser.add_argument("--token-name", "-p", help="name of the personal access token used to sign into the server")
+    parser.add_argument("--token-value", "-v", help="value of the personal access token used to sign into the server")
+    parser.add_argument(
+        "--logging-level",
+        "-l",
+        choices=["debug", "info", "error"],
+        default="error",
+        help="desired logging level (set to error by default)",
+    )
+    # Options specific to this sample
+    # This sample has no additional options, yet. If you add some, please add them here
+    parser.add_argument("--role", "-r", help="Site Role for the new user", default="Unlicensed")
+    parser.add_argument(
+        "--user",
+        "-u",
+        help="Username for the new user. If using active directory, it should be in the format of SAMAccountName@FullyQualifiedDomainName",
+    )
+    parser.add_argument(
+        "--email", "-e", help="Email address of the new user. If using active directory, this field is optional."
+    )
+
+    return parser.parse_args(args)
+
+
+def main():
+    args = parse_args(None)
+
+    # Set logging level based on user input, or error by default
+    logging_level = getattr(logging, args.logging_level.upper())
+    logging.basicConfig(level=logging_level)
+
+    tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site)
+    server = TSC.Server(args.server, use_server_version=True, http_options={"verify": False})
+    with server.auth.sign_in(tableau_auth):
+        # this code shows 2 different error codes for common mistakes
+        # 400013: Invalid site role
+        # 409000: user already exists on site
+
+        user = TSC.UserItem(args.user, args.role)
+        if args.email:
+            user.email = args.email
+        user = server.users.add(user)
+
+
+if __name__ == "__main__":
+    main()

{tableauserverclient-0.37 → tableauserverclient-0.39}/samples/extracts.py

@@ -42,7 +42,6 @@ def main():
     server.add_http_options({"verify": False})
     server.use_server_version()
     with server.auth.sign_in(tableau_auth):
-
         wb = None
         ds = None
         if args.workbook:

tableauserverclient-0.39/samples/metadata_paginated_query.py

@@ -0,0 +1,87 @@
+####
+# This script demonstrates how to use the metadata API to query information on a published data source
+#
+# To run the script, you must have installed Python 3.7 or later.
+####
+
+import argparse
+import logging
+from pprint import pprint
+
+import tableauserverclient as TSC
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Use the metadata API to get information on a published data source.")
+    # Common options; please keep those in sync across all samples
+    parser.add_argument("--server", "-s", help="server address")
+    parser.add_argument("--site", "-S", help="site name")
+    parser.add_argument("--token-name", "-n", help="name of the personal access token used to sign into the server")
+    parser.add_argument("--token-value", "-v", help="value of the personal access token used to sign into the server")
+    parser.add_argument(
+        "--logging-level",
+        "-l",
+        choices=["debug", "info", "error"],
+        default="error",
+        help="desired logging level (set to error by default)",
+    )
+    # Options specific to this sample
+    parser.add_argument(
+        "datasource_name",
+        nargs="?",
+        help="The name of the published datasource. If not present, we query all data sources.",
+    )
+
+    args = parser.parse_args()
+
+    # Set logging level based on user input, or error by default
+    logging_level = getattr(logging, args.logging_level.upper())
+    logging.basicConfig(level=logging_level)
+
+    # Sign in to server
+    tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site)
+    server = TSC.Server(args.server, use_server_version=True)
+    with server.auth.sign_in(tableau_auth):
+        # Execute the query
+        result = server.metadata.query(
+            """
+            # Query must declare that it accepts first and afterToken variables
+            query paged($first:Int, $afterToken:String) {
+              workbooksConnection(first: $first, after:$afterToken) {
+                nodes {
+                  luid
+                  name
+                  projectName
+                  description
+                }
+                totalCount
+                pageInfo {
+                  endCursor
+                  hasNextPage
+                }
+              }
+            }
+            """,
+            # "first" adjusts the page size. Here we set it to 5 to demonstrate pagination.
+            # Set it to a higher number to reduce the number of pages. Including
+            # first and afterToken is optional, and if not included, TSC will
+            # use its default page size of 100.
+            variables={"first": 5, "afterToken": None},
+        )
+
+        # Multiple pages are captured in result["pages"]. Each page contains
+        # the result of one execution of the query above.
+        for page in result["pages"]:
+            # Display warnings/errors (if any)
+            if page.get("errors"):
+                print("### Errors/Warnings:")
+                pprint(result["errors"])
+
+            # Print the results
+            if result.get("data"):
+                print("### Results:")
+                pprint(result["data"]["workbooksConnection"]["nodes"])
+
+
+if __name__ == "__main__":
+    main()

tableauserverclient-0.39/samples/update_connection_auth.py

@@ -0,0 +1,62 @@
+import argparse
+import logging
+import tableauserverclient as TSC
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Update a single connection on a datasource or workbook to embed credentials"
+    )
+
+    # Common options
+    parser.add_argument("--server", "-s", help="Server address", required=True)
+    parser.add_argument("--site", "-S", help="Site name", required=True)
+    parser.add_argument("--token-name", "-p", help="Personal access token name", required=True)
+    parser.add_argument("--token-value", "-v", help="Personal access token value", required=True)
+    parser.add_argument(
+        "--logging-level",
+        "-l",
+        choices=["debug", "info", "error"],
+        default="error",
+        help="Logging level (default: error)",
+    )
+
+    # Resource and connection details
+    parser.add_argument("resource_type", choices=["workbook", "datasource"])
+    parser.add_argument("resource_id", help="Workbook or datasource ID")
+    parser.add_argument("connection_id", help="Connection ID to update")
+    parser.add_argument("datasource_username", help="Username to set for the connection")
+    parser.add_argument("datasource_password", help="Password to set for the connection")
+    parser.add_argument("authentication_type", help="Authentication type")
+
+    args = parser.parse_args()
+
+    # Logging setup
+    logging_level = getattr(logging, args.logging_level.upper())
+    logging.basicConfig(level=logging_level)
+
+    tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site)
+    server = TSC.Server(args.server, use_server_version=True)
+
+    with server.auth.sign_in(tableau_auth):
+        endpoint = {"workbook": server.workbooks, "datasource": server.datasources}.get(args.resource_type)
+
+        update_function = endpoint.update_connection
+        resource = endpoint.get_by_id(args.resource_id)
+        endpoint.populate_connections(resource)
+
+        connections = [conn for conn in resource.connections if conn.id == args.connection_id]
+        assert len(connections) == 1, f"Connection ID '{args.connection_id}' not found."
+
+        connection = connections[0]
+        connection.username = args.datasource_username
+        connection.password = args.datasource_password
+        connection.auth_type = args.authentication_type
+        connection.embed_password = True
+
+        updated_connection = update_function(resource, connection)
+        print(f"Updated connection: {updated_connection.__dict__}")
+
+
+if __name__ == "__main__":
+    main()

tableauserverclient-0.39/samples/update_connections_auth.py

@@ -0,0 +1,64 @@
+import argparse
+import logging
+import tableauserverclient as TSC
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Bulk update all workbook or datasource connections")
+
+    # Common options
+    parser.add_argument("--server", "-s", help="Server address", required=True)
+    parser.add_argument("--site", "-S", help="Site name", required=True)
+    parser.add_argument("--token-name", "-p", help="Personal access token name", required=True)
+    parser.add_argument("--token-value", "-v", help="Personal access token value", required=True)
+    parser.add_argument(
+        "--logging-level",
+        "-l",
+        choices=["debug", "info", "error"],
+        default="error",
+        help="Logging level (default: error)",
+    )
+
+    # Resource-specific
+    parser.add_argument("resource_type", choices=["workbook", "datasource"])
+    parser.add_argument("resource_id")
+    parser.add_argument("datasource_username")
+    parser.add_argument("authentication_type")
+    parser.add_argument("--datasource_password", default=None, help="Datasource password (optional)")
+    parser.add_argument(
+        "--embed_password", default="true", choices=["true", "false"], help="Embed password (default: true)"
+    )
+
+    args = parser.parse_args()
+
+    # Set logging level
+    logging_level = getattr(logging, args.logging_level.upper())
+    logging.basicConfig(level=logging_level)
+
+    tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site)
+    server = TSC.Server(args.server, use_server_version=True)
+
+    with server.auth.sign_in(tableau_auth):
+        endpoint = {"workbook": server.workbooks, "datasource": server.datasources}.get(args.resource_type)
+
+        resource = endpoint.get_by_id(args.resource_id)
+        endpoint.populate_connections(resource)
+
+        connection_luids = [conn.id for conn in resource.connections]
+        embed_password = args.embed_password.lower() == "true"
+
+        # Call unified update_connections method
+        connection_items = endpoint.update_connections(
+            resource,
+            connection_luids=connection_luids,
+            authentication_type=args.authentication_type,
+            username=args.datasource_username,
+            password=args.datasource_password,
+            embed_password=embed_password,
+        )
+
+        print(f"Updated connections on {args.resource_type} {args.resource_id}: {connection_items}")
+
+
+if __name__ == "__main__":
+    main()

{tableauserverclient-0.37 → tableauserverclient-0.39}/samples/update_datasource_data.py

@@ -76,7 +76,7 @@ def main():
         print("Waiting for job...")
         # `wait_for_job` will throw if the job isn't executed successfully
         job = server.jobs.wait_for_job(job)
-        print("Job finished succesfully")
+        print("Job finished successfully")
 
 
 if __name__ == "__main__":

tableauserverclient-0.39/setup.py

@@ -0,0 +1,8 @@
+import versioneer
+from setuptools import setup
+
+setup(
+    # This line is required to set the version number when building the wheel
+    # not yet sure how to move this to pyproject.toml - it may require work in versioneer
+    cmdclass=versioneer.get_cmdclass()
+)

tableauserverclient-0.39/tableauserverclient/bin/__init__.py

@@ -0,0 +1,3 @@
+# generated during initial setup of versioneer
+from . import _version
+__version__ = _version.get_versions()['version']

{tableauserverclient-0.37 → tableauserverclient-0.39}/tableauserverclient/bin/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-24T09:59:27-0700",
+ "date": "2026-02-02T11:01:51-0800",
  "dirty": false,
  "error": null,
- "full-revisionid": "bf857041ed16dccf9c2aa494dbd0e6a6e6a62d66",
- "version": "0.37"
+ "full-revisionid": "34ac954b8edd87e367e4e1f54b4179aee54e2816",
+ "version": "0.39"
 }
 '''  # END VERSION_JSON
 

{tableauserverclient-0.37 → tableauserverclient-0.39}/tableauserverclient/helpers/strings.py

@@ -1,6 +1,6 @@
 from defusedxml.ElementTree import fromstring, tostring
 from functools import singledispatch
-from typing import TypeVar
+from typing import TypeVar, overload
 
 
 # the redact method can handle either strings or bytes, but it can't mix them.
@@ -41,3 +41,27 @@ def _(xml: str) -> str:
 @redact_xml.register  # type: ignore[no-redef]
 def _(xml: bytes) -> bytes:
     return _redact_any_type(bytearray(xml), b"password", b"..[redacted]")
+
+
+@overload
+def nullable_str_to_int(value: None) -> None: ...
+
+
+@overload
+def nullable_str_to_int(value: str) -> int: ...
+
+
+def nullable_str_to_int(value):
+    return int(value) if value is not None else None
+
+
+@overload
+def nullable_str_to_bool(value: None) -> None: ...
+
+
+@overload
+def nullable_str_to_bool(value: str) -> bool: ...
+
+
+def nullable_str_to_bool(value):
+    return str(value).lower() == "true" if value is not None else None

{tableauserverclient-0.37 → tableauserverclient-0.39}/tableauserverclient/models/__init__.py

@@ -1,3 +1,4 @@
+from tableauserverclient.models.collection_item import CollectionItem
 from tableauserverclient.models.column_item import ColumnItem
 from tableauserverclient.models.connection_credentials import ConnectionCredentials
 from tableauserverclient.models.connection_item import ConnectionItem
@@ -9,6 +10,7 @@ from tableauserverclient.models.data_freshness_policy_item import DataFreshnessP
 from tableauserverclient.models.datasource_item import DatasourceItem
 from tableauserverclient.models.dqw_item import DQWItem
 from tableauserverclient.models.exceptions import UnpopulatedPropertyError
+from tableauserverclient.models.extensions_item import ExtensionsServer, ExtensionsSiteSettings, SafeExtension
 from tableauserverclient.models.favorites_item import FavoriteItem
 from tableauserverclient.models.fileupload_item import FileuploadItem
 from tableauserverclient.models.flow_item import FlowItem
@@ -28,14 +30,16 @@ from tableauserverclient.models.linked_tasks_item import (
     LinkedTaskStepItem,
     LinkedTaskFlowRunItem,
 )
+from tableauserverclient.models.location_item import LocationItem
 from tableauserverclient.models.metric_item import MetricItem
+from tableauserverclient.models.oidc_item import SiteOIDCConfiguration
 from tableauserverclient.models.pagination_item import PaginationItem
 from tableauserverclient.models.permissions_item import PermissionsRule, Permission
 from tableauserverclient.models.project_item import ProjectItem
 from tableauserverclient.models.revision_item import RevisionItem
 from tableauserverclient.models.schedule_item import ScheduleItem
 from tableauserverclient.models.server_info_item import ServerInfoItem
-from tableauserverclient.models.site_item import SiteItem
+from tableauserverclient.models.site_item import SiteItem, SiteAuthConfiguration
 from tableauserverclient.models.subscription_item import SubscriptionItem
 from tableauserverclient.models.table_item import TableItem
 from tableauserverclient.models.tableau_auth import Credentials, TableauAuth, PersonalAccessTokenAuth, JWTAuth
@@ -48,8 +52,10 @@ from tableauserverclient.models.view_item import ViewItem
 from tableauserverclient.models.virtual_connection_item import VirtualConnectionItem
 from tableauserverclient.models.webhook_item import WebhookItem
 from tableauserverclient.models.workbook_item import WorkbookItem
+from tableauserverclient.models.extract_item import ExtractItem
 
 __all__ = [
+    "CollectionItem",
     "ColumnItem",
     "ConnectionCredentials",
     "ConnectionItem",
@@ -75,7 +81,9 @@ __all__ = [
     "MonthlyInterval",
     "HourlyInterval",
     "BackgroundJobItem",
+    "LocationItem",
     "MetricItem",
+    "SiteOIDCConfiguration",
     "PaginationItem",
     "Permission",
     "PermissionsRule",
@@ -83,7 +91,9 @@ __all__ = [
     "RevisionItem",
     "ScheduleItem",
     "ServerInfoItem",
+    "SiteAuthConfiguration",
     "SiteItem",
+    "SiteOIDCConfiguration",
     "SubscriptionItem",
     "TableItem",
     "TableauAuth",
@@ -103,4 +113,8 @@ __all__ = [
     "LinkedTaskItem",
     "LinkedTaskStepItem",
     "LinkedTaskFlowRunItem",
+    "ExtractItem",
+    "ExtensionsServer",
+    "ExtensionsSiteSettings",
+    "SafeExtension",
 ]

tableauserverclient-0.39/tableauserverclient/models/collection_item.py

@@ -0,0 +1,52 @@
+from datetime import datetime
+from typing import Optional
+from xml.etree.ElementTree import Element
+
+from defusedxml.ElementTree import fromstring
+from typing_extensions import Self
+
+from tableauserverclient.datetime_helpers import parse_datetime
+from tableauserverclient.models.user_item import UserItem
+
+
+class CollectionItem:
+    def __init__(self) -> None:
+        self.id: Optional[str] = None
+        self.name: Optional[str] = None
+        self.description: Optional[str] = None
+        self.created_at: Optional[datetime] = None
+        self.updated_at: Optional[datetime] = None
+        self.owner: Optional[UserItem] = None
+        self.total_item_count: Optional[int] = None
+        self.permissioned_item_count: Optional[int] = None
+        self.visibility: Optional[str] = None  # Assuming visibility is a string, adjust as necessary
+
+    @classmethod
+    def from_response(cls, response: bytes, ns) -> list[Self]:
+        parsed_response = fromstring(response)
+
+        collection_elements = parsed_response.findall(".//t:collection", namespaces=ns)
+        if not collection_elements:
+            raise ValueError("No collection element found in the response")
+
+        collections = [cls.from_xml(c, ns) for c in collection_elements]
+        return collections
+
+    @classmethod
+    def from_xml(cls, xml: Element, ns) -> Self:
+        collection_item = cls()
+        collection_item.id = xml.get("id")
+        collection_item.name = xml.get("name")
+        collection_item.description = xml.get("description")
+        collection_item.created_at = parse_datetime(xml.get("createdAt"))
+        collection_item.updated_at = parse_datetime(xml.get("updatedAt"))
+        owner_element = xml.find(".//t:owner", namespaces=ns)
+        if owner_element is not None:
+            collection_item.owner = UserItem.from_xml(owner_element, ns)
+        else:
+            collection_item.owner = None
+        collection_item.total_item_count = int(xml.get("totalItemCount", 0))
+        collection_item.permissioned_item_count = int(xml.get("permissionedItemCount", 0))
+        collection_item.visibility = xml.get("visibility")
+
+        return collection_item

{tableauserverclient-0.37 → tableauserverclient-0.39}/tableauserverclient/models/connection_item.py

@@ -41,6 +41,9 @@ class ConnectionItem:
     server_port: str
         The port used for the connection.
 
+    auth_type: str
+        Specifies the type of authentication used by the connection.
+
     connection_credentials: ConnectionCredentials
         The Connection Credentials object containing authentication details for
         the connection. Replaces username/password/embed_password when
@@ -59,6 +62,7 @@ class ConnectionItem:
         self.username: Optional[str] = None
         self.connection_credentials: Optional[ConnectionCredentials] = None
         self._query_tagging: Optional[bool] = None
+        self._auth_type: Optional[str] = None
 
     @property
     def datasource_id(self) -> Optional[str]:
@@ -91,8 +95,16 @@ class ConnectionItem:
             return
         self._query_tagging = value
 
+    @property
+    def auth_type(self) -> Optional[str]:
+        return self._auth_type
+
+    @auth_type.setter
+    def auth_type(self, value: Optional[str]):
+        self._auth_type = value
+
     def __repr__(self):
-        return "<ConnectionItem#{_id} embed={embed_password} type={_connection_type} username={username}>".format(
+        return "<ConnectionItem#{_id} embed={embed_password} type={_connection_type} auth={_auth_type} username={username}>".format(
             **self.__dict__
         )
 
@@ -108,10 +120,11 @@ class ConnectionItem:
             connection_item.embed_password = string_to_bool(connection_xml.get("embedPassword", ""))
             connection_item.server_address = connection_xml.get("serverAddress", connection_xml.get("server", None))
             connection_item.server_port = connection_xml.get("serverPort", connection_xml.get("port", None))
-            connection_item.username = connection_xml.get("userName", None)
+            connection_item.username = connection_xml.get("userName", connection_xml.get("username", None))
             connection_item._query_tagging = (
                 string_to_bool(s) if (s := connection_xml.get("queryTagging", None)) else None
             )
+            connection_item._auth_type = connection_xml.get("authenticationType", None)
             datasource_elem = connection_xml.find(".//t:datasource", namespaces=ns)
             if datasource_elem is not None:
                 connection_item._datasource_id = datasource_elem.get("id", None)
@@ -139,6 +152,7 @@ class ConnectionItem:
 
             connection_item.server_address = connection_xml.get("serverAddress", None)
             connection_item.server_port = connection_xml.get("serverPort", None)
+            connection_item._auth_type = connection_xml.get("authenticationType", None)
 
             connection_credentials = connection_xml.find(".//t:connectionCredentials", namespaces=ns)