atlan-application-sdk 0.1.1rc23__tar.gz → 0.1.1rc24__tar.gz

atlan_application_sdk-0.1.1rc24/.github/release_notes.md

@@ -0,0 +1,12 @@
+## v0.1.1rc24 (August 01, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc23...v0.1.1rc24
+
+### Features
+
+- Add utility function to fetch include/exclude databases from include-exclude regex (#623) (by @Abhishek Agrawal in [0c6cc62](https://github.com/atlanhq/application-sdk/commit/0c6cc62))
+
+### Bug Fixes
+
+- miner output path (#626) (by @Onkar Ravgan in [cabe7eb](https://github.com/atlanhq/application-sdk/commit/cabe7eb))
+- db name regex pattern (#630) (by @Onkar Ravgan in [bb26992](https://github.com/atlanhq/application-sdk/commit/bb26992))

{atlan_application_sdk-0.1.1rc23 → atlan_application_sdk-0.1.1rc24}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+
+## v0.1.1rc24 (August 01, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc23...v0.1.1rc24
+
+### Features
+
+- Add utility function to fetch include/exclude databases from include-exclude regex (#623) (by @Abhishek Agrawal in [0c6cc62](https://github.com/atlanhq/application-sdk/commit/0c6cc62))
+
+### Bug Fixes
+
+- miner output path (#626) (by @Onkar Ravgan in [cabe7eb](https://github.com/atlanhq/application-sdk/commit/cabe7eb))
+- db name regex pattern (#630) (by @Onkar Ravgan in [bb26992](https://github.com/atlanhq/application-sdk/commit/bb26992))
+
 ## v0.1.1rc23 (July 29, 2025)
 
 Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc22...v0.1.1rc23

{atlan_application_sdk-0.1.1rc23 → atlan_application_sdk-0.1.1rc24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc23
+Version: 0.1.1rc24
 Summary: Atlan Application SDK is a Python library for developing applications on the Atlan Platform
 Project-URL: Repository, https://github.com/atlanhq/application-sdk
 Project-URL: Documentation, https://github.com/atlanhq/application-sdk/README.md

{atlan_application_sdk-0.1.1rc23 → atlan_application_sdk-0.1.1rc24}/application_sdk/activities/query_extraction/sql.py

@@ -201,8 +201,9 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
             sql_input = SQLQueryInput(
                 engine=state.sql_client.engine,
                 query=self.get_formatted_query(self.fetch_queries_sql, workflow_args),
+                chunk_size=None,
             )
-            sql_input = await sql_input.get_daft_dataframe()
+            sql_input = await sql_input.get_dataframe()
 
             raw_output = ParquetOutput(
                 output_prefix=workflow_args["output_prefix"],
@@ -212,7 +213,7 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
                 start_marker=workflow_args["start_marker"],
                 end_marker=workflow_args["end_marker"],
             )
-            await raw_output.write_daft_dataframe(sql_input)
+            await raw_output.write_dataframe(sql_input)
 
             logger.info(
                 f"Query fetch completed, {raw_output.total_record_count} records processed",

{atlan_application_sdk-0.1.1rc23 → atlan_application_sdk-0.1.1rc24}/application_sdk/common/utils.py

@@ -25,35 +25,29 @@ logger = get_logger(__name__)
 F = TypeVar("F", bound=Callable[..., Awaitable[Any]])
 
 
-def extract_database_names_from_regex(normalized_regex: str) -> str:
+def extract_database_names_from_regex_common(
+    normalized_regex: str,
+    empty_default: str,
+    require_wildcard_schema: bool,
+) -> str:
     """
-    Extract database names from normalized regex patterns and return a regex string suitable for SQL queries.
-
-    This function parses regex patterns like 'dev\\.external_schema$|wide_world_importers\\.bronze_sales$'
-    or 'dev\\.*|wide_world_importers\\.*' to extract the database names, and returns a regex string
-    like '^(dev|wide_world_importers)$' for use in SQL queries.
+    Common implementation for extracting database names from regex patterns.
 
     Args:
         normalized_regex (str): The normalized regex pattern containing database.schema patterns
+        empty_default (str): Default value to return for empty/null inputs
+        require_wildcard_schema (bool): Whether to only extract database names for wildcard schemas
 
     Returns:
-        str: A regex string in the format ^(name1|name2|...)$ or '^$' if no names are found.
-
-    Examples:
-        >>> extract_database_names_from_regex('dev\\.external_schema$|wide_world_importers\\.bronze_sales$')
-        '^(dev|wide_world_importers)$'
-        >>> extract_database_names_from_regex('dev\\.*|wide_world_importers\\.*')
-        '^(dev|wide_world_importers)$'
-        >>> extract_database_names_from_regex('^$')
-        '^$'
-
-    Raises:
-        CommonError: If the input is invalid or processing fails
+        str: A regex string in the format ^(name1|name2|...)$ or default values
     """
     try:
-        if not normalized_regex or not isinstance(normalized_regex, str):
-            logger.warning("Invalid normalized_regex input: empty or non-string value")
-            return "'^$'"
+        # Handle special cases based on regex type
+        if not normalized_regex or normalized_regex == "^$":
+            return empty_default
+
+        if normalized_regex == ".*":
+            return "'.*'"
 
         database_names: Set[str] = set()
 
@@ -66,32 +60,50 @@ def extract_database_names_from_regex(normalized_regex: str) -> str:
                 if not pattern or not pattern.strip():
                     continue
 
-                # Split by \\. to get database name (first part)
+                # Split by \\. to get database name and schema part
                 # The \\. represents an escaped dot in the regex
                 parts = pattern.split("\\.")
-                if parts:
-                    db_name = parts[0].strip()
-                    if db_name and db_name not in (".*", "^$"):
-                        # Validate database name format
-                        if re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", db_name):
-                            database_names.add(db_name)
-                        else:
-                            logger.warning(f"Invalid database name format: {db_name}")
 
+                # Handle different validation requirements
+                if require_wildcard_schema:
+                    # For exclude regex, we need at least 2 parts and schema must be wildcard
+                    if len(parts) < 2:
+                        logger.warning(f"Invalid database name format: {pattern}")
+                        continue
+                    db_name = parts[0].strip()
+                    schema_part = parts[1].strip()
+                    # Only extract database name if the schema part is a wildcard (*)
+                    if not (
+                        db_name and db_name not in (".*", "^$") and schema_part == "*"
+                    ):
+                        continue
+                else:
+                    # For include regex, we just need the database name
+                    if not parts:
+                        continue
+                    db_name = parts[0].strip()
+                    if not (db_name and db_name not in (".*", "^$")):
+                        continue
+
+                # Validate database name format
+                if re.match(r"^[a-zA-Z_][a-zA-Z0-9_$-]*$", db_name):
+                    database_names.add(db_name)
+                else:
+                    logger.warning(f"Invalid database name format: {db_name}")
             except Exception as e:
                 logger.warning(f"Error processing pattern '{pattern}': {str(e)}")
                 continue
 
         if not database_names:
-            return "'^$'"
+            return empty_default
         return f"'^({'|'.join(sorted(database_names))})$'"
 
     except Exception as e:
         logger.error(
             f"Error extracting database names from regex '{normalized_regex}': {str(e)}"
         )
-        # Return a safe default that excludes everything
-        return "'^$'"
+        # Return appropriate default based on regex type
+        return empty_default
 
 
 def prepare_query(
@@ -147,12 +159,16 @@ def prepare_query(
         )
 
         # Extract database names from the normalized regex patterns
-        include_databases = extract_database_names_from_regex(normalized_include_regex)
-        exclude_databases = extract_database_names_from_regex(normalized_exclude_regex)
-
-        if include_databases == "'^$'" and exclude_databases == "'^$'":
-            include_databases = "'.*'"
-            exclude_databases = "'^$'"
+        include_databases = extract_database_names_from_regex_common(
+            normalized_regex=normalized_include_regex,
+            empty_default="'.*'",
+            require_wildcard_schema=False,
+        )
+        exclude_databases = extract_database_names_from_regex_common(
+            normalized_regex=normalized_exclude_regex,
+            empty_default="'^$'",
+            require_wildcard_schema=True,
+        )
 
         # Use sets directly for SQL query formatting
         exclude_empty_tables = workflow_args.get("metadata", {}).get(

{atlan_application_sdk-0.1.1rc23 → atlan_application_sdk-0.1.1rc24}/application_sdk/version.py

@@ -2,4 +2,4 @@
 Version information for the application_sdk package.
 """
 
-__version__ = "0.1.1rc23"
+__version__ = "0.1.1rc24"

{atlan_application_sdk-0.1.1rc23 → atlan_application_sdk-0.1.1rc24}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atlan-application-sdk"
-version = "0.1.1rc23"
+version = "0.1.1rc24"
 description = "Atlan Application SDK is a Python library for developing applications on the Atlan Platform"
 license = "Apache-2.0"
 authors = [