instructure-dap-client 2.3.0__tar.gz → 2.3.1__tar.gz

{instructure_dap_client-2.3.0/instructure_dap_client.egg-info → instructure_dap_client-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instructure-dap-client
-Version: 2.3.0
+Version: 2.3.1
 Summary: Data Access Platform client library
 Maintainer-email: "Instructure, Inc." <dapclient@instructure.com>
 License-Expression: MIT

{instructure_dap_client-2.3.0 → instructure_dap_client-2.3.1}/dap/__init__.py

@@ -6,7 +6,7 @@ to data collected across various educational products in bulk with high fidelity
 a canonical data model.
 """
 
-__version__ = "2.3.0"
+__version__ = "2.3.1"
 __copyright__ = "Copyright 2022-2026, Instructure, Inc."
 __license__ = "MIT"
 __maintainer__ = "Instructure, Inc."

{instructure_dap_client-2.3.0 → instructure_dap_client-2.3.1}/dap/commands/command_group.py

@@ -1,3 +1,4 @@
+import textwrap
 from typing import Optional
 import asyncclick as click
 
@@ -24,45 +25,38 @@ class CustomGroup(click.Group):
 
         url1 = "https://developerdocs.instructure.com/services/dap/dap-cli-readme/dap-cli-reference"
         url2 = "https://developerdocs.instructure.com/services/dap/query-api"
-        self._write_text_with_non_wrapped_parts(
+        self._write_text_without_breaking_urls(
             formatter,
             f"For more information and examples, check the reference at {url1} "
             f"and the OpenAPI specification for DAP API at {url2}.",
-            non_wrapped_parts=[url1, url2],
         )
 
     def list_commands(self, ctx: click.Context) -> list[str]:
         # This overrides the default alphabetical ordering of commands with the order in which they were added
         return list(self.commands.keys())
 
-    def _write_text_with_non_wrapped_parts(
+    def _write_text_without_breaking_urls(
         self,
         formatter: click.HelpFormatter,
         text: str,
-        non_wrapped_parts: list[str] = [],
     ) -> None:
         """
-        Writes text into the formatter, replacing non-wrapped parts with placeholders
-        to prevent them from being wrapped by the formatter. Then it replaces the placeholders
-        back with the original parts after the text has been written to the formatter.
+        Writes text into the formatter like ``HelpFormatter.write_text``, but never
+        splits a URL (or any other single "word") across lines: a word wider than the
+        available width overflows the target width instead of being cut apart.
         """
 
-        placeholders: dict[str, str] = {}
-
-        for i in range(len(non_wrapped_parts)):
-            part = non_wrapped_parts[i]
-            placeholder = part.replace("-", "_").replace(" ", "_")
-            placeholders[part] = placeholder
-
-        for part, placeholder in placeholders.items():
-            text = text.replace(part, placeholder)
-
-        formatter.write_text(text)
-
-        for part, placeholder in placeholders.items():
-            formatter.buffer = [
-                line.replace(placeholder, part) for line in formatter.buffer
-            ]
+        indent = " " * formatter.current_indent
+        wrapper = textwrap.TextWrapper(
+            width=formatter.width,
+            initial_indent=indent,
+            subsequent_indent=indent,
+            replace_whitespace=False,
+            break_long_words=False,
+            break_on_hyphens=False,
+        )
+        formatter.write(wrapper.fill(text))
+        formatter.write("\n")
 
 
 @click.group(

{instructure_dap_client-2.3.0 → instructure_dap_client-2.3.1/instructure_dap_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instructure-dap-client
-Version: 2.3.0
+Version: 2.3.1
 Summary: Data Access Platform client library
 Maintainer-email: "Instructure, Inc." <dapclient@instructure.com>
 License-Expression: MIT

{instructure_dap_client-2.3.0 → instructure_dap_client-2.3.1}/pysqlsync/__init__.py

@@ -9,7 +9,7 @@ Copyright 2023-2026, Levente Hunyadi; 2026 Instructure, Inc.
 :see: https://github.com/instructure-internal/pysqlsync
 """
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 __author__ = "Instructure, Inc."
 __copyright__ = "Copyright 2023-2026, Levente Hunyadi; 2026 Instructure, Inc."
 __license__ = "MIT"

{instructure_dap_client-2.3.0 → instructure_dap_client-2.3.1}/pysqlsync/dialect/mssql/data_types.py

@@ -7,9 +7,11 @@ Copyright 2023-2026, Levente Hunyadi; 2026 Instructure, Inc.
 """
 
 import enum
+from dataclasses import dataclass
 from typing import Any, Optional
 
 import pyodbc
+from strong_typing.auxiliary import MaxLength
 
 from pysqlsync.model.data_types import (
     SqlBooleanType,
@@ -40,29 +42,70 @@ class MSSQLBooleanType(SqlBooleanType):
         return "1" if value else "0"
 
 
+# `varchar(n)` holds n bytes; `nvarchar(n)` holds n UTF-16 code units. Beyond
+# these maxima only the `(max)` form is valid.
+MAX_VARCHAR_SIZE = 8000
+MAX_NVARCHAR_SIZE = 4000
+
+# Under a UTF-8 collation `varchar(n)` budgets n *bytes*, but the `MaxLength`
+# annotation it is derived from counts *characters*. A character encodes to at
+# most 4 bytes in UTF-8, so a limit declared in characters is scaled to
+# guarantee any input fits. Without this a 255-character value holding one
+# 3-byte character overflows `varchar(255)` and SQL Server rejects the insert
+# with "String or binary data would be truncated".
+MAX_UTF8_BYTES_PER_CHARACTER = 4
+
+
 class MSSQLEncoding(enum.Enum):
     UTF8 = "utf-8"
     UTF16 = "utf-16"
 
 
+@dataclass
 class MSSQLVariableCharacterType(SqlVariableCharacterType):
+    # A dataclass field, not a plain attribute: the generated `__eq__` is what
+    # schema synchronization compares to decide whether a column needs an
+    # `ALTER`. Were `encoding` excluded, `varchar(n)` and `nvarchar(n)` would
+    # compare equal and a type change would silently never be migrated.
     encoding: Optional[MSSQLEncoding] = None
 
     def __init__(self, limit: Optional[int] = None, encoding: Optional[MSSQLEncoding] = None) -> None:
         super().__init__(limit)
         self.encoding = encoding
 
-    def __str__(self) -> str:
+    def _max_size(self) -> int:
+        "Returns the widest fixed-width size this column's type family accepts."
+
         if self.encoding is MSSQLEncoding.UTF16:
-            char_type = "nvarchar"
+            return MAX_NVARCHAR_SIZE
         else:
-            char_type = "varchar"
+            return MAX_VARCHAR_SIZE
 
-        if self.limit is not None and self.limit > 0 and self.limit != 2147483647:
+    def __str__(self) -> str:
+        char_type = "nvarchar" if self.encoding is MSSQLEncoding.UTF16 else "varchar"
+
+        if self.limit is not None and self.limit > 0 and self.limit <= self._max_size() and self.limit != 2147483647:
             return f"{char_type}({self.limit})"
         else:
             return f"{char_type}(max)"
 
+    def parse_meta(self, meta: Any) -> None:
+        if isinstance(meta, MaxLength):
+            # `MaxLength` counts characters. `varchar(n)` budgets n *bytes*, so a
+            # character limit is scaled to a byte limit; `nvarchar(n)` already
+            # counts UTF-16 code units, the same unit `MaxLength` counts in, so no
+            # scaling applies there.
+            scale = MAX_UTF8_BYTES_PER_CHARACTER if self.encoding is not MSSQLEncoding.UTF16 else 1
+            budget = meta.value * scale
+            # A budget past the fixed-width maximum is held as `None`, the same
+            # value discovery reports for a `(max)` column, so that a generated
+            # type and the one read back from the database compare equal.
+            # Keeping the overflowed count instead would make schema
+            # synchronization emit a redundant `ALTER` on every run.
+            self.limit = budget if budget <= self._max_size() else None
+        else:
+            super().parse_meta(meta)
+
 
 class MSSQLDateTimeType(SqlTimestampType):
     def __init__(self) -> None:
@@ -72,6 +115,28 @@ class MSSQLDateTimeType(SqlTimestampType):
         return "datetime2"
 
 
+# Character parameters bind as the wide ODBC types, whose declared size is in
+# UTF-16 code units and so cannot exceed the `nvarchar` maximum — half what a
+# `varchar` column may declare. A wider declaration describes a fixed-width
+# Unicode type that does not exist, and ODBC Driver 18 rejects the descriptor
+# with HY104 "Invalid precision value". Report such a column as unbounded: the
+# driver then binds it as a LOB, which carries any length without error.
+MAX_WIDE_COLUMN_SIZE = MAX_NVARCHAR_SIZE
+
+
+def _wide_column_size(limit: Optional[int]) -> int:
+    """
+    Returns the column size to declare for a wide (Unicode) character parameter.
+
+    :param limit: The column's declared character limit, or `None` if unbounded.
+    :returns: The limit if it fits a fixed-width wide type, or 0 to bind as a LOB.
+    """
+
+    if not limit or limit > MAX_WIDE_COLUMN_SIZE:
+        return 0
+    return limit
+
+
 def sql_to_odbc_type(data_type: SqlDataType) -> tuple[int, int, int]:
     """
     Returns the ODBC data type associated with the SQL data type.
@@ -116,9 +181,9 @@ def sql_to_odbc_type(data_type: SqlDataType) -> tuple[int, int, int]:
         # the narrow `SQL_CHAR`/`SQL_VARCHAR` makes `fast_executemany` miscount
         # the buffer width, observed to silently corrupt non-Latin text. SQL
         # Server converts UTF-16 to the column's UTF-8 storage on insert.
-        return pyodbc.SQL_WCHAR, data_type.limit or 0, 0
+        return pyodbc.SQL_WCHAR, _wide_column_size(data_type.limit), 0
     elif isinstance(data_type, SqlVariableCharacterType):
-        return pyodbc.SQL_WVARCHAR, data_type.limit or 0, 0
+        return pyodbc.SQL_WVARCHAR, _wide_column_size(data_type.limit), 0
     elif isinstance(data_type, SqlFixedBinaryType):
         return pyodbc.SQL_BINARY, data_type.storage or 0, 0
     elif isinstance(data_type, SqlVariableBinaryType):

{instructure_dap_client-2.3.0 → instructure_dap_client-2.3.1}/pysqlsync/model/data_types.py

@@ -6,6 +6,7 @@ Copyright 2023-2026, Levente Hunyadi; 2026 Instructure, Inc.
 :see: https://github.com/instructure-internal/pysqlsync
 """
 
+import copy
 import datetime
 import decimal
 from dataclasses import dataclass
@@ -387,10 +388,14 @@ def _compatible_type(left: SqlDataType, right: SqlDataType) -> SqlDataType:
         if isinstance(right, SqlFixedCharacterType):
             return type(left)(limit=max_or_none(left.limit, right.limit))
         elif isinstance(right, SqlVariableCharacterType):
-            return type(right)(limit=max_or_none(left.limit, right.limit))
+            merged = copy.copy(right)
+            merged.limit = max_or_none(left.limit, right.limit)
+            return merged
     elif isinstance(left, SqlVariableCharacterType):
         if isinstance(right, (SqlFixedCharacterType, SqlVariableCharacterType)):
-            return type(left)(limit=max_or_none(left.limit, right.limit))
+            merged = copy.copy(left)
+            merged.limit = max_or_none(left.limit, right.limit)
+            return merged
 
     # binary types
     if isinstance(left, SqlFixedBinaryType):