prefect-github 0.3.2__tar.gz → 0.4.1__tar.gz

{prefect_github-0.3.2/prefect_github.egg-info → prefect_github-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-github
-Version: 0.3.2
+Version: 0.4.1
 Summary: Prefect integrations interacting with GitHub
 Author-email: "Prefect Technologies, Inc." <help@prefect.io>
 License: Apache License 2.0
@@ -11,13 +11,12 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sgqlc>=15.0

{prefect_github-0.3.2 → prefect_github-0.4.1}/prefect_github/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.4.1'
+__version_tuple__ = version_tuple = (0, 4, 1)
 
-__commit_id__ = commit_id = 'g8a37e7b1b'
+__commit_id__ = commit_id = 'gd77914141'

{prefect_github-0.3.2 → prefect_github-0.4.1}/prefect_github/graphql.py

@@ -13,11 +13,28 @@ from anyio import to_thread
 from sgqlc.operation import Operation, Selection
 
 from prefect import task
-from prefect.utilities.asyncutils import sync_compatible
+from prefect._internal.compatibility.async_dispatch import async_dispatch
 from prefect_github import GitHubCredentials
 from prefect_github.utils import camel_to_snake_case
 
 
+def _execute_graphql_op_sync(
+    op: Union[Operation, str],
+    github_credentials: GitHubCredentials,
+    error_key: str = "errors",
+    **vars,
+) -> Dict[str, Any]:
+    """
+    Sync helper function for executing GraphQL operations.
+    """
+    endpoint = github_credentials.get_client()
+    result = endpoint(op, vars)
+    if error_key in result:
+        errors = pformat(result[error_key])
+        raise RuntimeError(f"Error encountered:\n{errors}")
+    return result["data"]
+
+
 async def _execute_graphql_op(
     op: Union[Operation, str],
     github_credentials: GitHubCredentials,
@@ -25,7 +42,7 @@ async def _execute_graphql_op(
     **vars,
 ) -> Dict[str, Any]:
     """
-    Helper function for executing GraphQL operations.
+    Async helper function for executing GraphQL operations.
     """
     endpoint = github_credentials.get_client()
     partial_endpoint = partial(endpoint, op, vars)
@@ -62,8 +79,24 @@ def _subset_return_fields(
 
 
 @task
-@sync_compatible
-async def execute_graphql(
+async def aexecute_graphql(
+    op: Union[Operation, str],
+    github_credentials: GitHubCredentials,
+    error_key: str = "errors",
+    **vars,
+) -> Dict[str, Any]:
+    """
+    Async version of execute_graphql. See execute_graphql for full documentation.
+    """
+    result = await _execute_graphql_op(
+        op, github_credentials, error_key=error_key, **vars
+    )
+    return result
+
+
+@task
+@async_dispatch(aexecute_graphql)
+def execute_graphql(
     op: Union[Operation, str],
     github_credentials: GitHubCredentials,
     error_key: str = "errors",
@@ -142,7 +175,4 @@ async def execute_graphql(
         example_execute_graphql_flow()
         ```
     """
-    result = await _execute_graphql_op(
-        op, github_credentials, error_key=error_key, **vars
-    )
-    return result
+    return _execute_graphql_op_sync(op, github_credentials, error_key=error_key, **vars)

{prefect_github-0.3.2 → prefect_github-0.4.1}/prefect_github/repository.py

@@ -8,8 +8,10 @@ GitHub query_repository* tasks and the GitHub storage block.
 # is outdated, rerun scripts/generate.py.
 
 import io
+import re
 import shlex
 import shutil
+import subprocess
 from datetime import datetime
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -20,8 +22,9 @@ from pydantic import Field
 from sgqlc.operation import Operation
 
 from prefect import task
+from prefect._internal.compatibility.async_dispatch import async_dispatch
+from prefect._internal.urls import strip_auth_from_url
 from prefect.filesystems import ReadableDeploymentStorage
-from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.processutils import run_process
 from prefect_github import GitHubCredentials
 from prefect_github.graphql import _execute_graphql_op, _subset_return_fields
@@ -31,6 +34,15 @@ from prefect_github.utils import initialize_return_fields_defaults, strip_kwargs
 config_path = Path(__file__).parent.resolve() / "configs" / "query" / "repository.json"
 return_fields_defaults = initialize_return_fields_defaults(config_path)
 
+_URL_PATTERN = re.compile(r"https?://[^\s'\"<>]+")
+
+
+def _sanitize_git_error(message: str) -> str:
+    def _replace(match: re.Match[str]) -> str:
+        return strip_auth_from_url(match.group(0))
+
+    return _URL_PATTERN.sub(_replace, message)
+
 
 class GitHubRepository(ReadableDeploymentStorage):
     """
@@ -96,14 +108,13 @@ class GitHubRepository(ReadableDeploymentStorage):
 
         return str(content_source), str(content_destination)
 
-    @sync_compatible
-    async def get_directory(
+    async def aget_directory(
         self, from_path: Optional[str] = None, local_path: Optional[str] = None
     ) -> None:
         """
         Clones a GitHub project specified in `from_path` to the provided `local_path`;
         defaults to cloning the repository reference configured on the Block to the
-        present working directory.
+        present working directory. Async version.
 
         Args:
             from_path: If provided, interpreted as a subdirectory of the underlying
@@ -130,14 +141,59 @@ class GitHubRepository(ReadableDeploymentStorage):
             process = await run_process(cmd, stream_output=(out_stream, err_stream))
             if process.returncode != 0:
                 err_stream.seek(0)
-                raise RuntimeError(f"Failed to pull from remote:\n {err_stream.read()}")
+                sanitized_error = _sanitize_git_error(err_stream.read())
+                raise RuntimeError(f"Failed to pull from remote:\n {sanitized_error}")
+
+            content_source, content_destination = self._get_paths(
+                dst_dir=local_path, src_dir=tmp_path_str, sub_directory=from_path
+            )
+
+            shutil.copytree(
+                src=content_source,
+                dst=content_destination,
+                dirs_exist_ok=True,
+                symlinks=True,
+            )
+
+    @async_dispatch(aget_directory)
+    def get_directory(
+        self, from_path: Optional[str] = None, local_path: Optional[str] = None
+    ) -> None:
+        """
+        Clones a GitHub project specified in `from_path` to the provided `local_path`;
+        defaults to cloning the repository reference configured on the Block to the
+        present working directory.
+
+        Args:
+            from_path: If provided, interpreted as a subdirectory of the underlying
+                repository that will be copied to the provided local path.
+            local_path: A local path to clone to; defaults to present working directory.
+        """
+        cmd = f"git clone {self._create_repo_url()}"
+        if self.reference:
+            cmd += f" -b {self.reference}"
+
+        cmd += " --depth 1"
+
+        with TemporaryDirectory(suffix="prefect") as tmp_dir:
+            tmp_path_str = tmp_dir
+            cmd += f' "{tmp_path_str}"'
+            cmd = shlex.split(cmd)
+
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                sanitized_error = _sanitize_git_error(result.stderr)
+                raise RuntimeError(f"Failed to pull from remote:\n {sanitized_error}")
 
             content_source, content_destination = self._get_paths(
                 dst_dir=local_path, src_dir=tmp_path_str, sub_directory=from_path
             )
 
             shutil.copytree(
-                src=content_source, dst=content_destination, dirs_exist_ok=True
+                src=content_source,
+                dst=content_destination,
+                dirs_exist_ok=True,
+                symlinks=True,
             )
 
 

{prefect_github-0.3.2 → prefect_github-0.4.1/prefect_github.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-github
-Version: 0.3.2
+Version: 0.4.1
 Summary: Prefect integrations interacting with GitHub
 Author-email: "Prefect Technologies, Inc." <help@prefect.io>
 License: Apache License 2.0
@@ -11,13 +11,12 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sgqlc>=15.0

{prefect_github-0.3.2 → prefect_github-0.4.1}/pyproject.toml

@@ -8,7 +8,7 @@ dependencies = ["sgqlc>=15.0", "prefect>=3.0.0"]
 dynamic = ["version"]
 description = "Prefect integrations interacting with GitHub"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = { text = "Apache License 2.0" }
 keywords = ["prefect"]
 authors = [{ name = "Prefect Technologies, Inc.", email = "help@prefect.io" }]
@@ -18,7 +18,6 @@ classifiers = [
   "Intended Audience :: System Administrators",
   "License :: OSI Approved :: Apache Software License",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",

prefect_github-0.4.1/tests/test_graphql.py

@@ -0,0 +1,117 @@
+from typing import Coroutine
+
+import pytest
+from prefect_github.graphql import (
+    _subset_return_fields,
+    aexecute_graphql,
+    execute_graphql,
+)
+from prefect_github.schemas import graphql_schema
+from sgqlc.operation import Operation, Selector
+
+from prefect import flow
+
+
+@pytest.mark.parametrize(
+    "return_fields_key", ["return_fields", "return_fields_defaults"]
+)
+def test_subset_return_fields(return_fields_key):
+    op = Operation(graphql_schema.Query)
+    op_stack = graphql_schema.Query.__field_names__[:1]
+    op_selection = getattr(op, op_stack[0])
+    subset_kwargs = {"return_fields": [], "return_fields_defaults": {}}
+    return_fields = ["id"]
+    if return_fields_key == "return_fields":
+        subset_kwargs[return_fields_key] = return_fields
+    else:
+        subset_kwargs[return_fields_key] = {op_stack: return_fields}
+    op_selection = _subset_return_fields(op_selection, op_stack, **subset_kwargs)
+    assert isinstance(op_selection, Selector)
+
+
+class MockCredentials:
+    def __init__(self, error_key=None):
+        self.result = (
+            {error_key: "Errors encountered:"} if error_key else {"data": "success"}
+        )
+
+    def get_endpoint(self):
+        return lambda op, vars: self.result
+
+    def get_client(self):
+        return lambda op, vars: self.result
+
+
+@pytest.mark.parametrize("error_key", ["errors", False])
+def test_execute_graphql(error_key):
+    mock_credentials = MockCredentials(error_key=error_key)
+
+    @flow
+    def test_flow():
+        return execute_graphql("op", mock_credentials)
+
+    if error_key:
+        with pytest.raises(RuntimeError, match="Errors encountered:"):
+            test_flow()
+    else:
+        assert test_flow() == "success"
+
+
+class TestExecuteGraphqlAsyncDispatch:
+    """Tests for execute_graphql migrated from @sync_compatible to @async_dispatch.
+
+    These tests verify the critical behavior from issue #15008 where
+    @sync_compatible would incorrectly return coroutines in sync context.
+    """
+
+    def test_execute_graphql_sync_context_returns_value_not_coroutine(self):
+        """execute_graphql must return value (not coroutine) in sync context.
+
+        This is the critical regression test for issues #14712 and #14625.
+        """
+        mock_credentials = MockCredentials(error_key=False)
+
+        @flow
+        def test_flow():
+            result = execute_graphql("op", mock_credentials)
+            # the result inside the flow should be the actual value, not a coroutine
+            assert not isinstance(result, Coroutine), "sync context returned coroutine"
+            return result
+
+        assert test_flow() == "success"
+
+    async def test_execute_graphql_async_context_works(self):
+        """execute_graphql should work correctly in async context."""
+        mock_credentials = MockCredentials(error_key=False)
+
+        @flow
+        async def test_flow():
+            # when decorated with @task, the task machinery handles execution
+            # so we get a result directly, not a coroutine
+            result = execute_graphql("op", mock_credentials)
+            return result
+
+        assert await test_flow() == "success"
+
+    def test_aexecute_graphql_is_exported(self):
+        """aexecute_graphql should be available for direct async usage."""
+        # just verify it's importable and is a task
+        assert callable(aexecute_graphql)
+
+    def test_task_identity_preserved(self):
+        """Both execute_graphql and aexecute_graphql should have Task identity.
+
+        This verifies decorator order is correct (@task must be outermost).
+        See PR #20300 for the dbt decorator ordering fix.
+        """
+        # .with_options() is only available on proper Task objects
+        assert hasattr(execute_graphql, "with_options"), (
+            "execute_graphql missing .with_options() - check decorator order"
+        )
+        assert hasattr(aexecute_graphql, "with_options"), (
+            "aexecute_graphql missing .with_options() - check decorator order"
+        )
+
+        # verify we can actually call with_options
+        configured = execute_graphql.with_options(retries=3)
+        assert configured is not None

{prefect_github-0.3.2 → prefect_github-0.4.1}/tests/test_repository.py

@@ -1,15 +1,14 @@
 import os
 from pathlib import Path
 from tempfile import TemporaryDirectory
-from typing import Tuple
+from typing import Coroutine, Tuple
+from unittest.mock import AsyncMock
 
 import prefect_github
 import pytest
 from prefect_github import GitHubCredentials
 from prefect_github.repository import GitHubRepository
 
-from prefect.testing.utilities import AsyncMock
-
 
 class TestGitHubRepository:
     async def test_subprocess_errors_are_surfaced(self):
@@ -73,6 +72,34 @@ class TestGitHubRepository:
             in " ".join(mock.await_args[0][0])
         )
 
+    async def test_get_directory_redacts_token_in_error(self, monkeypatch):
+        """Ensure GitHub access tokens are not surfaced in git error messages."""
+
+        class p:
+            returncode = 1
+
+        async def mock(cmd, stream_output=None, **kwargs):
+            if stream_output:
+                _, err_stream = stream_output
+                err_stream.write(
+                    "fatal: Authentication failed for "
+                    "'https://XYZ@github.com/PrefectHQ/prefect.git/'"
+                )
+            return p()
+
+        monkeypatch.setattr(prefect_github.repository, "run_process", mock)
+        credential = GitHubCredentials(token="XYZ")
+        g = GitHubRepository(
+            repository_url="https://github.com/PrefectHQ/prefect.git",
+            credentials=credential,
+        )
+        with pytest.raises(RuntimeError) as excinfo:
+            await g.get_directory()
+
+        message = str(excinfo.value)
+        assert "XYZ" not in message
+        assert "https://github.com/PrefectHQ/prefect.git" in message
+
     def setup_test_directory(
         self, tmp_src: str, sub_dir: str = "puppy"
     ) -> Tuple[str, str]:
@@ -189,3 +216,92 @@ class TestGitHubRepository:
 
                 assert set(os.listdir(tmp_dst)) == set([sub_dir_name])
                 assert set(os.listdir(Path(tmp_dst) / sub_dir_name)) == child_contents
+
+    async def test_get_directory_preserves_symlinks(self, monkeypatch):
+        """Test that get_directory preserves symlinks instead of following them.
+
+        This verifies the fix for issue #7868 where symlinks were being resolved
+        and their target files copied, potentially exposing sensitive files.
+        """
+
+        class p:
+            returncode = 0
+
+        mock = AsyncMock(return_value=p())
+        monkeypatch.setattr(prefect_github.repository, "run_process", mock)
+
+        with TemporaryDirectory() as tmp_src:
+            # Create a real file
+            real_file = Path(tmp_src) / "real_file.txt"
+            real_file.write_text("real content")
+
+            # Create a symlink
+            symlink_file = Path(tmp_src) / "link_file.txt"
+            symlink_file.symlink_to(real_file)
+
+            self.MockTmpDir.dir = tmp_src
+
+            with TemporaryDirectory() as tmp_dst:
+                monkeypatch.setattr(
+                    prefect_github.repository,
+                    "TemporaryDirectory",
+                    self.MockTmpDir,
+                )
+
+                g = GitHubRepository(
+                    repository_url="https://github.com/PrefectHQ/prefect.git",
+                )
+                await g.get_directory(local_path=tmp_dst)
+
+                # Verify the symlink is preserved as a symlink
+                copied_symlink = Path(tmp_dst) / "link_file.txt"
+                assert copied_symlink.is_symlink(), (
+                    "Symlink should be preserved as a symlink"
+                )
+
+                # Verify the real file is copied
+                copied_real = Path(tmp_dst) / "real_file.txt"
+                assert copied_real.exists()
+                assert copied_real.read_text() == "real content"
+
+
+class TestGitHubRepositoryAsyncDispatch:
+    """Tests for GitHubRepository.get_directory migrated from @sync_compatible to @async_dispatch.
+
+    These tests verify the critical behavior from issue #15008 where
+    @sync_compatible would incorrectly return coroutines in sync context.
+    """
+
+    def test_get_directory_sync_context_returns_none_not_coroutine(self, monkeypatch):
+        """get_directory must return None (not coroutine) in sync context.
+
+        This is the critical regression test for issues #14712 and #14625.
+        """
+        import subprocess
+        from unittest.mock import MagicMock
+
+        mock_result = MagicMock()
+        mock_result.returncode = 0
+        mock_result.stderr = ""
+        monkeypatch.setattr(subprocess, "run", MagicMock(return_value=mock_result))
+
+        g = GitHubRepository(repository_url="prefect")
+        result = g.get_directory()
+
+        assert not isinstance(result, Coroutine), "sync context returned coroutine"
+        assert result is None
+
+    async def test_get_directory_async_context_returns_coroutine(self, monkeypatch):
+        """get_directory should dispatch to async and return coroutine in async context."""
+
+        class p:
+            returncode = 0
+
+        mock = AsyncMock(return_value=p())
+        monkeypatch.setattr(prefect_github.repository, "run_process", mock)
+
+        g = GitHubRepository(repository_url="prefect")
+        result = g.get_directory()
+
+        assert isinstance(result, Coroutine)
+        await result  # should complete without error

prefect_github-0.3.2/tests/test_graphql.py

@@ -1,51 +0,0 @@
-import pytest
-from prefect_github.graphql import _subset_return_fields, execute_graphql
-from prefect_github.schemas import graphql_schema
-from sgqlc.operation import Operation, Selector
-
-from prefect import flow
-
-
-@pytest.mark.parametrize(
-    "return_fields_key", ["return_fields", "return_fields_defaults"]
-)
-def test_subset_return_fields(return_fields_key):
-    op = Operation(graphql_schema.Query)
-    op_stack = graphql_schema.Query.__field_names__[:1]
-    op_selection = getattr(op, op_stack[0])
-    subset_kwargs = {"return_fields": [], "return_fields_defaults": {}}
-    return_fields = ["id"]
-    if return_fields_key == "return_fields":
-        subset_kwargs[return_fields_key] = return_fields
-    else:
-        subset_kwargs[return_fields_key] = {op_stack: return_fields}
-    op_selection = _subset_return_fields(op_selection, op_stack, **subset_kwargs)
-    assert isinstance(op_selection, Selector)
-
-
-class MockCredentials:
-    def __init__(self, error_key=None):
-        self.result = (
-            {error_key: "Errors encountered:"} if error_key else {"data": "success"}
-        )
-
-    def get_endpoint(self):
-        return lambda op, vars: self.result
-
-    def get_client(self):
-        return lambda op, vars: self.result
-
-
-@pytest.mark.parametrize("error_key", ["errors", False])
-def test_execute_graphql(error_key):
-    mock_credentials = MockCredentials(error_key=error_key)
-
-    @flow
-    def test_flow():
-        return execute_graphql("op", mock_credentials)
-
-    if error_key:
-        with pytest.raises(RuntimeError, match="Errors encountered:"):
-            test_flow()
-    else:
-        assert test_flow() == "success"