querysource 4.4.2__tar.gz → 4.4.3__tar.gz

{querysource-4.4.2/querysource.egg-info → querysource-4.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: querysource
-Version: 4.4.2
+Version: 4.4.3
 Summary: Aiohttp web service for querying several databases easily
 Author-email: Jesus Lara <jesuslarag@gmail.com>
 License: BSD-3-Clause

{querysource-4.4.2 → querysource-4.4.3}/querysource/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '4.4.3.dev0+g7613ad3de.d20260608'
-__version_tuple__ = version_tuple = (4, 4, 3, 'dev0', 'g7613ad3de.d20260608')
+__version__ = version = '4.4.4.dev0+gf6f711fc9.d20260608'
+__version_tuple__ = version_tuple = (4, 4, 4, 'dev0', 'gf6f711fc9.d20260608')
 
-__commit_id__ = commit_id = 'g7613ad3de'
+__commit_id__ = commit_id = 'gf6f711fc9'

{querysource-4.4.2 → querysource-4.4.3}/querysource/handlers/multi.py

@@ -140,7 +140,8 @@ class QueryHandler(AbstractHandler):
             data = {}
             _queries = options.get('queries', {})
             _files = options.get('files', {})
-            if not (_queries or _files):  # Check if both are effectively empty
+            _sources = options.get('sources', {})
+            if not (_queries or _files or _sources):  # Check if all inputs are effectively empty
                 raise self.Error(
                     message='Invalid POST Option passed to MultiQuery.',
                     code=400
@@ -203,9 +204,9 @@ class QueryHandler(AbstractHandler):
             "writer_options": writer_options,
         }
         ## Step 1: PBAC pre-flight (all-or-nothing) before thread fan-out.
-        # Detect raw inline query: any non-slug, non-file query component.
+        # Detect raw inline query: any non-slug, non-file/source query component.
         _has_raw = bool(
-            not slug and not _queries and not _files
+            not slug and not _queries and not _files and not _sources
         ) or bool(
             isinstance(options, dict) and options.get('query') and
             not _queries and not _files and not slug
@@ -364,6 +365,7 @@ class QueryHandler(AbstractHandler):
                     'X-Total-Time': f'{total_time:.2f} seconds',
                 }
             )
+        output_errors: list[str] = []
         if isinstance(data, dict):
             if 'Output' in options:
                 ## Optionally saving result to destination (registry-based dispatch)
@@ -379,7 +381,7 @@ class QueryHandler(AbstractHandler):
                                 step_name,
                                 dest_err,
                             )
-                            # Per spec: continue to next destination on failure
+                            output_errors.append(f"{step_name}: {dest_err}")
         ### Step 6: passing Result to DataOutput
         try:
             if result is None or isinstance(result, DataFrame) and result.empty:
@@ -410,6 +412,8 @@ class QueryHandler(AbstractHandler):
             remote_queries = getattr(qs, '_remote_queries', [])
             if remote_queries:
                 response.headers['X-Remote-Queries'] = ','.join(remote_queries)
+            if output_errors:
+                response.headers['X-Output-Errors'] = ' | '.join(output_errors)
             return response
         except (DataNotFound) as ex:
             return self.NoData(

{querysource-4.4.2 → querysource-4.4.3}/querysource/queries/multi/__init__.py

@@ -94,7 +94,8 @@ class MultiQS(BaseQuery):
             ## Getting data from Queries or Files
             self._queries = query.pop('queries', {})
             self._files = query.pop('files', {})
-            self._sources = query.pop('sources', [])
+            raw_sources = query.pop('sources', [])
+            self._sources = self._normalize_sources(raw_sources)
         else:
             self._sources = []
         if not (self.slug or self._queries or self._files or self._sources):
@@ -110,6 +111,58 @@ class MultiQS(BaseQuery):
         # FEAT-101: track names of queries dispatched to remote qworker.
         self._remote_queries: list = []
 
+    @staticmethod
+    def _expand_dotted_keys(cfg: dict) -> dict:
+        """Expand dot-notation keys into nested dicts.
+
+        Frontend sends ``{"source.file_id": {"file_id": 123}}`` instead of
+        ``{"source": {"file_id": 123}}``.  For each dotted key, the parent
+        segment becomes the top-level key and the value (a dict) is merged in.
+        Multiple dotted keys sharing the same parent are merged together.
+        """
+        expanded = {}
+        for key, value in cfg.items():
+            if '.' in key:
+                parent = key.split('.')[0]
+                if isinstance(value, dict):
+                    existing = expanded.get(parent, {})
+                    expanded[parent] = {**existing, **value}
+                else:
+                    expanded[key] = value
+            else:
+                expanded[key] = value
+        return expanded
+
+    @staticmethod
+    def _normalize_sources(raw) -> list:
+        """Normalize the ``sources`` payload to the internal list format.
+
+        Accepts two shapes:
+
+        * **List** (canonical internal format)::
+
+            [{"SmartSheetSource": {"credentials": {...}, "source": {...}}}]
+
+        * **Dict** (frontend convenience format)::
+
+            {"alias": {"type": "SmartSheetSource", "source.file_id": {"file_id": 123}}}
+
+          Each entry's ``type`` field is extracted as the source-type key.
+          Dot-notation keys (e.g. ``source.file_id``) are expanded into nested
+          dicts via ``_expand_dotted_keys``.
+        """
+        if isinstance(raw, list):
+            return raw
+        if isinstance(raw, dict):
+            normalized = []
+            for _alias, cfg in raw.items():
+                cfg = dict(cfg)
+                source_type = cfg.pop('type', _alias)
+                cfg = MultiQS._expand_dotted_keys(cfg)
+                normalized.append({source_type: cfg})
+            return normalized
+        return []
+
     async def query(self):
         """
         Executing Multiple Queries/Files

{querysource-4.4.2 → querysource-4.4.3}/querysource/queries/multi/_introspect.py

@@ -900,7 +900,16 @@ def describe_class(cls: type, category: str | None = None) -> dict:
         example_text = json.dumps(example_dict, indent=2)
     if not example_text and body_literal:
         # rST literal block — typically a YAML config example for destinations.
-        example_text = body_literal
+        # Try to parse as YAML and re-serialize as JSON so the UI shows JSON.
+        try:
+            import yaml  # noqa: PLC0415
+            parsed = yaml.safe_load(body_literal)
+            if isinstance(parsed, dict):
+                example_text = json.dumps(parsed, indent=2)
+            else:
+                example_text = body_literal
+        except Exception:
+            example_text = body_literal
 
     icon = getattr(cls, "_icon", None) or DEFAULT_CATEGORY_ICONS.get(
         category, DEFAULT_CATEGORY_ICONS["Components"]

{querysource-4.4.2 → querysource-4.4.3}/querysource/queries/multi/destinations/sharepoint.py

@@ -66,6 +66,9 @@ class ToSharepoint(AbstractDestination):
         self._client_secret: str = resolved.get("client_secret", "")
         self._tenant_id: str = resolved.get("tenant_id", "")
         self._site: str = resolved.get("site", "")
+        self._tenant_name: str = resolved.get("tenant_name", "")
+        # site_id can be provided directly to skip Graph site resolution
+        self._site_id: str = resolved.get("site_id", "")
 
         # Destination config
         self._filename: str = dest_cfg.get("filename", "output.xlsx")
@@ -118,6 +121,13 @@ class ToSharepoint(AbstractDestination):
                 "Install them with: pip install azure-identity msgraph-sdk"
             ) from exc
 
+        # The msgraph/kiota SDK uses platform.version() to build the User-Agent
+        # header. On Linux the string has a trailing space which aiohttp rejects
+        # as an illegal header value. Patch it before the client is constructed.
+        import platform as _platform
+        _orig_version = _platform.version
+        _platform.version = lambda: _orig_version().strip()
+
         if not all([self._tenant_id, self._client_id, self._client_secret]):
             raise OutputError(
                 "ToSharepoint: 'tenant_id', 'client_id', and 'client_secret' "
@@ -137,8 +147,29 @@ class ToSharepoint(AbstractDestination):
     # ------------------------------------------------------------------
 
     async def _resolve_site_id(self, graph_client) -> str:
-        """Return the Graph site-id for :attr:`_site`."""
-        # Primary lookup: tenant:path format
+        """Return the Graph site-id for :attr:`_site`.
+
+        Resolution order:
+        1. ``site_id`` credential provided directly → return as-is (no API call).
+        2. Hostname-based path: ``{tenant_name}.sharepoint.com:/sites/{site}:``
+        3. Fallback path: ``root:/sites/{site}:``
+        4. Search by display name via ``$search``.
+        """
+        # Fast path: site_id already known
+        if self._site_id:
+            return self._site_id
+
+        # Primary lookup: hostname-qualified path (most reliable)
+        if self._tenant_name:
+            try:
+                site_path = f"{self._tenant_name}.sharepoint.com:/sites/{self._site}:"
+                site = await graph_client.sites.by_site_id(site_path).get()
+                if site and site.id:
+                    return site.id
+            except Exception:
+                pass
+
+        # Secondary lookup: root-relative path
         try:
             site_path = f"root:/sites/{self._site}:"
             site = await graph_client.sites.by_site_id(site_path).get()
@@ -167,19 +198,78 @@ class ToSharepoint(AbstractDestination):
             f"Verify the site name and credentials."
         )
 
-    async def _get_drive_id(self, graph_client, site_id: str) -> str:
-        """Return the document library drive-id for *site_id*."""
+    def _parse_directory_path(self, directory: str) -> tuple:
+        """Split *directory* into ``(library_name, path_within_library)``.
+
+        When *directory* contains at least two segments, the first segment is
+        the document-library name and the rest is the folder path inside that
+        library.  When only one segment is given it is treated as a subfolder
+        inside the default ``"Documents"`` library (single-segment paths are
+        rarely library names, and this matches the common convention).
+        ``"Shared Documents"`` is normalised to ``"Documents"``.
+
+        Examples::
+
+            "Shared Documents/Reports/2026" → ("Documents", "Reports/2026")
+            "Documents/Tests"               → ("Documents", "Tests")
+            "Tests"                         → ("Documents", "Tests")
+            "troc/Project Management"       → ("troc", "Project Management")
+        """
+        if not directory:
+            return "Documents", ""
+
+        directory = directory.replace("\\", "/").strip().strip("/")
+        if not directory:
+            return "Documents", ""
+
+        parts = directory.split("/")
+
+        if len(parts) == 1:
+            # Single segment → always treat as subfolder of default library
+            return "Documents", parts[0]
+
+        library_name = parts[0]
+        path_within = "/".join(parts[1:])
+
+        if library_name.lower() == "shared documents":
+            library_name = "Documents"
+
+        return library_name, path_within
+
+    async def _resolve_drive(
+        self, graph_client, site_id: str, library_name: str = "Documents"
+    ) -> str:
+        """Return the drive-id for *library_name* inside *site_id*.
+
+        Performs a case-insensitive search across all document libraries.
+        If the requested library is not found, logs the available names and
+        falls back to the first library named "Documents" / "Shared Documents",
+        or the first library overall.
+        """
         try:
             drives = await graph_client.sites.by_site_id(site_id).drives.get()
-            if drives and drives.value:
-                # Prefer a drive named "Documents" or "Shared Documents"
-                for drive in drives.value:
-                    if drive.name.lower() in ("documents", "shared documents"):
-                        return drive.id
-                return drives.value[0].id
-            raise OutputError(
-                f"ToSharepoint: no document libraries found for site '{site_id}'."
+            if not drives or not drives.value:
+                raise OutputError(
+                    f"ToSharepoint: no document libraries found for site '{site_id}'."
+                )
+
+            # Case-insensitive exact match
+            for drive in drives.value:
+                if drive.name.lower() == library_name.lower():
+                    return drive.id
+
+            # Log available libraries and fall back to default
+            available = [d.name for d in drives.value]
+            self.logger.warning(
+                "ToSharepoint: library '%s' not found. Available: %s. Using default.",
+                library_name,
+                available,
             )
+            for drive in drives.value:
+                if drive.name.lower() in ("documents", "shared documents"):
+                    return drive.id
+            return drives.value[0].id
+
         except OutputError:
             raise
         except Exception as err:
@@ -354,30 +444,9 @@ class ToSharepoint(AbstractDestination):
         graph_client = self._build_graph_client()
 
         site_id = await self._resolve_site_id(graph_client)
-        drive_id = await self._get_drive_id(graph_client, site_id)
-
-        # Parse directory: first segment is the library name, rest is the path
-        parts = self._directory.split("/", 1)
-        library_part = parts[0]
-        path_part = parts[1] if len(parts) > 1 else ""
-
-        # Find the specific library drive if name was given
-        if library_part:
-            try:
-                drives = await graph_client.sites.by_site_id(site_id).drives.get()
-                for drive in (drives.value or []):
-                    if drive.name.lower() == library_part.lower() or (
-                        library_part.lower() == "shared documents"
-                        and drive.name.lower() == "documents"
-                    ):
-                        drive_id = drive.id
-                        break
-                else:
-                    path_part = self._directory  # fallback: treat whole dir as path
-            except Exception:
-                path_part = self._directory
-
-        parent_id = await self._ensure_folder(graph_client, drive_id, path_part)
+        library_name, path_within = self._parse_directory_path(self._directory)
+        drive_id = await self._resolve_drive(graph_client, site_id, library_name)
+        parent_id = await self._ensure_folder(graph_client, drive_id, path_within)
 
         if len(content) <= _SMALL_FILE_THRESHOLD:
             self.logger.info(

{querysource-4.4.2 → querysource-4.4.3}/querysource/version.py

@@ -6,7 +6,7 @@ __description__ = (
     'QuerySource Query parser and generator.'
     'Supports SQL, NoSQL, MongoDB, Cassandra, Elasticsearch, etc.'
 )
-__version__ = '4.4.2'
+__version__ = '4.4.3'
 __url__ = 'https://github.com/phenobarbital/querysource'
 __copyright__ = 'Copyright (c) 2018-2025 Jesus Lara'
 __author__ = 'Jesus Lara'

{querysource-4.4.2 → querysource-4.4.3/querysource.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: querysource
-Version: 4.4.2
+Version: 4.4.3
 Summary: Aiohttp web service for querying several databases easily
 Author-email: Jesus Lara <jesuslarag@gmail.com>
 License: BSD-3-Clause