mage-ai 0.9.57__py3-none-any.whl → 0.9.59__py3-none-any.whl

mage_ai/api/resources/GitBranchResource.py

@@ -3,28 +3,34 @@ from typing import Dict, List
 
 from mage_ai.api.errors import ApiError
 from mage_ai.api.resources.GenericResource import GenericResource
-from mage_ai.authentication.oauth.constants import OAUTH_PROVIDER_GITHUB
+from mage_ai.authentication.oauth.constants import ProviderName
 from mage_ai.data_preparation.git import REMOTE_NAME, Git, api
 from mage_ai.data_preparation.git.clients.base import Client as GitClient
 from mage_ai.data_preparation.git.utils import get_provider_from_remote_url
 from mage_ai.data_preparation.preferences import get_preferences
+from mage_ai.shared.path_fixer import remove_base_repo_path
+from mage_ai.shared.strings import capitalize_remove_underscore_lower
 
 
 def build_file_object(obj):
     arr = []
     for k, v in obj.items():
         children = build_file_object(v)
-        arr.append(dict(
-            children=children if len(children) >= 1 else None,
-            name=k,
-        ))
+        arr.append(
+            dict(
+                children=children if len(children) >= 1 else None,
+                name=k,
+            )
+        )
 
     return arr
 
 
 class GitBranchResource(GenericResource):
     @classmethod
-    def get_git_manager(self, user, setup_repo: bool = True) -> Git:
+    def get_git_manager(
+        self, user, setup_repo: bool = True, config_overwrite: Dict = None
+    ) -> Git:
         return Git.get_manager(setup_repo=setup_repo, user=user)
 
     @classmethod
@@ -43,7 +49,7 @@ class GitBranchResource(GenericResource):
         if repository:
             repository = repository[0]
 
-            provider = OAUTH_PROVIDER_GITHUB
+            provider = ProviderName.GITHUB
             if remote_url:
                 provider = get_provider_from_remote_url(remote_url)
 
@@ -84,38 +90,65 @@ class GitBranchResource(GenericResource):
 
         display_format = kwargs.get('meta', {}).get('_format')
         if 'with_basic_details' == display_format:
-            return self(dict(
-                files={},
-                is_git_integration_enabled=preferences.is_git_integration_enabled(),
-                modified_files=[],
-                name=git_manager.current_branch,
-                staged_files=[],
-                sync_config=get_preferences().sync_config,
-                untracked_files=[],
-            ), user, **kwargs)
+            return self(
+                dict(
+                    files={},
+                    is_git_integration_enabled=preferences.is_git_integration_enabled(),
+                    modified_files=[],
+                    name=git_manager.current_branch,
+                    staged_files=[],
+                    sync_config=get_preferences().sync_config,
+                    untracked_files=[],
+                ),
+                user,
+                **kwargs,
+            )
 
         modified_files = git_manager.modified_files
         staged_files = await git_manager.staged_files()
         untracked_files = await git_manager.untracked_files()
 
-        return self(dict(
-            files={},
-            is_git_integration_enabled=preferences.is_git_integration_enabled(),
-            modified_files=modified_files,
-            name=git_manager.current_branch,
-            staged_files=staged_files,
-            sync_config=get_preferences().sync_config,
-            untracked_files=untracked_files,
-        ), user, **kwargs)
+        return self(
+            dict(
+                files={},
+                is_git_integration_enabled=preferences.is_git_integration_enabled(),
+                modified_files=modified_files,
+                name=git_manager.current_branch,
+                staged_files=staged_files,
+                sync_config=get_preferences().sync_config,
+                untracked_files=untracked_files,
+            ),
+            user,
+            **kwargs,
+        )
 
     async def update(self, payload, **kwargs):
+        query = kwargs.get('query') or {}
+
         git_manager = self.get_git_manager(user=self.current_user)
         action_type = payload.get('action_type')
+        action_payload = payload.get('action_payload', dict())
+        action_remote = action_payload.get('remote', None)
+        action_branch = action_payload.get('branch', None)
+
         files = payload.get('files', None)
         message = payload.get('message', None)
-        remote = payload.get('remote', None)
 
-        access_token = api.get_access_token_for_user(self.current_user)
+        url = None
+        remote_url = query.get('remote_url', None)
+        if remote_url:
+            url = remote_url[0]
+        elif action_remote:
+            remote = git_manager.repo.remotes[action_remote]
+            url = list(remote.urls)[0]
+
+        provider = ProviderName.GITHUB
+        if url:
+            provider = get_provider_from_remote_url(url)
+
+        access_token = api.get_access_token_for_user(
+            self.current_user, provider=provider
+        )
         http_access_token = git_manager.get_access_token()
 
         token = None
@@ -124,6 +157,23 @@ class GitBranchResource(GenericResource):
         elif http_access_token:
             token = http_access_token
 
+        config_overwrite = None
+        if token:
+            user_from_api = api.get_user(token, provider=provider)
+            # Default to mage user email if no email is returned from API
+            email = user_from_api.get(
+                'email', self.current_user.email if self.current_user else None
+            )
+            config_overwrite = dict(
+                username=user_from_api.get('username'),
+                email=email,
+            )
+
+        # Recreate git manager with updated config
+        git_manager = self.get_git_manager(
+            user=self.current_user, config_overwrite=config_overwrite
+        )
+
         if action_type == 'status':
             status = git_manager.status()
             untracked_files = await git_manager.untracked_files()
@@ -137,102 +187,104 @@ class GitBranchResource(GenericResource):
         elif action_type == 'commit':
             if not message:
                 error = ApiError.RESOURCE_ERROR
-                error.update({
-                    'message': 'Message is empty, please add a message for your commit.',
-                })
+                error.update(
+                    {
+                        'message': 'Message is empty, please add a message for your commit.',
+                    }
+                )
                 raise ApiError(error)
+
             git_manager.commit(message, files)
         elif action_type == 'push':
-            push = payload.get('push', None)
-
-            if push and 'remote' in push and 'branch' in push:
+            if action_remote:
                 from git.exc import GitCommandError
 
                 try:
-                    remote = git_manager.repo.remotes[push['remote']]
-                    url = list(remote.urls)[0]
-
                     if token:
                         custom_progress = api.push(
-                            remote.name,
+                            action_remote,
                             url,
-                            push['branch'],
+                            action_branch,
                             token,
+                            config_overwrite=config_overwrite,
                         )
                         if custom_progress.other_lines:
                             lines = custom_progress.other_lines
-                            if type(lines) is list:
+                            if isinstance(lines, list):
                                 lines = '\n'.join(lines)
                             self.model['progress'] = lines
                     else:
-                        self.model['error'] = \
-                            'Please authenticate with GitHub before trying to push.'
+                        self.model[
+                            'error'
+                        ] = 'Please authenticate with {} before trying to push.'.format(
+                            capitalize_remove_underscore_lower(provider),
+                        )
                 except GitCommandError as err:
                     self.model['error'] = str(err)
             else:
                 git_manager.push()
         elif action_type == 'pull':
-            pull = payload.get('pull', None)
-            if pull and 'remote' in pull:
+            if action_remote:
                 from git.exc import GitCommandError
 
                 try:
-                    branch_name = pull.get('branch')
-                    remote = git_manager.repo.remotes[pull['remote']]
-                    url = list(remote.urls)[0]
-
                     if token:
                         custom_progress = None
-                        if branch_name:
+                        if action_branch:
                             custom_progress = api.pull(
-                                remote.name,
+                                action_remote,
                                 url,
-                                pull.get('branch'),
+                                action_branch,
                                 token,
+                                config_overwrite=config_overwrite,
                             )
                         else:
                             custom_progress = api.fetch(
-                                remote.name,
+                                action_remote,
                                 url,
                                 token,
+                                config_overwrite=config_overwrite,
                             )
 
                         if custom_progress and custom_progress.other_lines:
                             lines = custom_progress.other_lines
-                            if type(lines) is list:
+                            if isinstance(lines, list):
                                 lines = '\n'.join(lines)
                             self.model['progress'] = lines
                     else:
-                        self.model['error'] = \
-                            'Please authenticate with GitHub before trying to pull.'
+                        self.model[
+                            'error'
+                        ] = 'Please authenticate with {} before trying to pull.'.format(
+                            capitalize_remove_underscore_lower(provider),
+                        )
                 except GitCommandError as err:
                     self.model['error'] = str(err)
             else:
                 git_manager.pull()
         elif action_type == 'fetch':
-            fetch = payload.get('fetch', None)
-            if fetch and 'remote' in fetch:
+            if action_remote:
                 from git.exc import GitCommandError
 
                 try:
-                    remote = git_manager.repo.remotes[fetch['remote']]
-                    url = list(remote.urls)[0]
-
                     if token:
                         custom_progress = api.fetch(
-                            remote.name,
+                            action_remote,
                             url,
                             token,
+                            config_overwrite=config_overwrite,
                         )
 
                         if custom_progress and custom_progress.other_lines:
                             lines = custom_progress.other_lines
-                            if type(lines) is list:
+                            if isinstance(lines, list):
                                 lines = '\n'.join(lines)
                             self.model['progress'] = lines
                     else:
-                        self.model['error'] = \
-                            'Please authenticate with GitHub before trying to fetch.'
+                        self.model[
+                            'error'
+                        ] = 'Please authenticate with {} before trying to fetch.'.format(
+                            capitalize_remove_underscore_lower(provider),
+                        )
                 except GitCommandError as err:
                     self.model['error'] = str(err)
             else:
@@ -242,44 +294,44 @@ class GitBranchResource(GenericResource):
                 for file_path in files:
                     git_manager.reset_file(file_path)
             else:
-                reset = payload.get('reset', {})
-                if reset and 'remote' in reset:
+                if action_remote:
                     from git.exc import GitCommandError
 
                     try:
-                        branch_name = reset.get('branch')
-                        remote = git_manager.repo.remotes[reset['remote']]
-                        url = list(remote.urls)[0]
-
                         if token:
                             api.reset_hard(
-                                remote.name,
+                                action_remote,
                                 url,
-                                branch_name,
+                                action_branch,
                                 token,
+                                config_overwrite=config_overwrite,
                             )
                         else:
-                            self.model['error'] = \
-                                'Please authenticate with GitHub before trying to pull.'
+                            self.model[
+                                'error'
+                            ] = 'Please authenticate with {} before trying to reset.'.format(
+                                capitalize_remove_underscore_lower(provider),
+                            )
                     except GitCommandError as err:
                         self.model['error'] = str(err)
         elif action_type == 'clone':
-            clone = payload.get('clone', None)
-            if clone and 'remote' in clone:
+            if action_remote:
                 from git.exc import GitCommandError
-                try:
-                    remote = git_manager.repo.remotes[clone['remote']]
-                    url = list(remote.urls)[0]
 
+                try:
                     if token:
                         api.clone(
-                            remote.name,
+                            action_remote,
                             url,
                             token,
+                            config_overwrite=config_overwrite,
                         )
                     else:
-                        self.model['error'] = \
-                            'Please authenticate with GitHub before trying to pull.'
+                        self.model[
+                            'error'
+                        ] = 'Please authenticate with {} before trying to clone.'.format(
+                            capitalize_remove_underscore_lower(provider),
+                        )
                 except GitCommandError as err:
                     self.model['error'] = str(err)
             else:
@@ -291,11 +343,13 @@ class GitBranchResource(GenericResource):
             for file_path in files:
                 git_manager.checkout_file(file_path)
         elif action_type in ['add_remote', 'remove_remote']:
-            if not remote:
+            if not action_payload:
                 error = ApiError.RESOURCE_ERROR
-                error.update({
-                    'message': 'Remote is empty, please add a remote.',
-                })
+                error.update(
+                    {
+                        'message': 'Remote is empty, please add a remote.',
+                    }
+                )
                 raise ApiError(error)
 
             args = []
@@ -305,22 +359,26 @@ class GitBranchResource(GenericResource):
                 keys.append('url')
 
             for key in keys:
-                val = remote.get(key)
+                val = action_payload.get(key)
                 if not val:
                     error = ApiError.RESOURCE_ERROR
-                    error.update({
-                        'message': f'Remote is missing {key}.',
-                    })
+                    error.update(
+                        {
+                            'message': f'Remote is missing {key}.',
+                        }
+                    )
                     raise ApiError(error)
                 args.append(val)
 
             if action_type == 'add_remote':
-                if remote.get('name') == REMOTE_NAME:
+                if action_payload.get('name') == REMOTE_NAME:
                     error = ApiError.RESOURCE_ERROR
-                    error.update({
-                        'message': f'Remote name {REMOTE_NAME} is reserved, ' +
-                        'please select a different name.',
-                    })
+                    error.update(
+                        {
+                            'message': f'Remote name {REMOTE_NAME} is reserved, '
+                            + 'please select a different name.',
+                        }
+                    )
                     raise ApiError(error)
                 git_manager.add_remote(*args)
             elif action_type == 'remove_remote':
@@ -330,12 +388,8 @@ class GitBranchResource(GenericResource):
             'merge',
             'rebase',
         ]:
-            data = payload.get('delete', None) or \
-                payload.get('merge', None) or \
-                payload.get('rebase', None)
-
-            if data and 'base_branch' in data:
-                base_branch = data['base_branch']
+            if action_payload:
+                base_branch = action_payload.get('base_branch')
 
                 if 'delete' == action_type:
                     git_manager.delete_branch(base_branch)
@@ -345,10 +399,12 @@ class GitBranchResource(GenericResource):
                     git_manager.rebase_branch(base_branch, message=message)
             else:
                 error = ApiError.RESOURCE_ERROR
-                error.update({
-                    'message': 'Please select a base branch to ' +
-                    f'{action_type} into the current branch.',
-                })
+                error.update(
+                    {
+                        'message': 'Please select a base branch to '
+                        + f'{action_type} into the current branch.',
+                    }
+                )
                 raise ApiError(error)
 
         return self
@@ -358,8 +414,10 @@ class GitBranchResource(GenericResource):
         modified_files: List[str],
         staged_files: List[str],
         untracked_files: List[str],
-        limit: int = None
+        limit: int = None,
     ) -> Dict:
+        git_manager = self.get_git_manager(user=self.current_user)
+
         arr = []
 
         if modified_files and isinstance(modified_files, list):
@@ -372,9 +430,20 @@ class GitBranchResource(GenericResource):
         if limit:
             arr = arr[:limit]
 
+        files_absolute_path = {}
+
         files = {}
-        for filename in arr:
-            # filename: default_repo/transformers/load.py
+        for filename_init in arr:
+
+            # Git repo_path: /home/src/project_romeo/test
+            # filename_init: examples/load.py
+            # filename: test/examples/load.py
+
+            filename = os.path.join(
+                os.path.basename(git_manager.repo_path),
+                filename_init,
+            )
+
             parts = filename.split(os.sep)
             number_of_parts = len(parts)
 
@@ -399,7 +468,13 @@ class GitBranchResource(GenericResource):
                     obj[part] = obj_final
                     obj_final = obj
 
-            files[parts[0]] = obj_final
+            key = parts[0]
+            files[key] = obj_final
+            files_absolute_path[filename_init] = remove_base_repo_path(
+                os.path.join(git_manager.repo_path, filename_init),
+            )
+
+        self.model['files_absolute_path'] = files_absolute_path
 
         return build_file_object(files)
 

mage_ai/api/resources/GitCustomBranchResource.py

@@ -7,8 +7,15 @@ from mage_ai.data_preparation.sync import AuthType
 
 class GitCustomBranchResource(GitBranchResource):
     @classmethod
-    def get_git_manager(self, user, setup_repo: bool = False) -> Git:
-        return Git.get_manager(auth_type=AuthType.OAUTH, setup_repo=False, user=user)
+    def get_git_manager(
+        self, user, setup_repo: bool = False, config_overwrite: Dict = None
+    ) -> Git:
+        return Git.get_manager(
+            auth_type=AuthType.OAUTH,
+            config_overwrite=config_overwrite,
+            setup_repo=setup_repo,
+            user=user,
+        )
 
     @classmethod
     async def member(self, pk, user, **kwargs):

mage_ai/api/resources/GitFileResource.py

@@ -1,33 +1,44 @@
 import os
 import urllib.parse
+from pathlib import Path
 
 from mage_ai.api.resources.GenericResource import GenericResource
 from mage_ai.data_preparation.git import Git
 from mage_ai.data_preparation.models.file import File
-from mage_ai.settings.repo import get_repo_name, get_repo_path
+from mage_ai.settings.utils import base_repo_path
 
 
 class GitFileResource(GenericResource):
     @classmethod
     async def member(self, pk, user, **kwargs):
-        repo_name = get_repo_name()
+        query = kwargs.get('query', {})
+
+        git_manager = Git.get_manager(user=user)
 
         file_path = urllib.parse.unquote(pk)
-        file_path_without_repo_name = file_path
-        file_path_parts = file_path_without_repo_name.split(os.sep)
-        if len(file_path_parts) >= 1 and file_path_parts[0] == repo_name:
-            file_path_without_repo_name = os.path.join(*file_path_parts[1:])
 
-        file = File.from_path(file_path_without_repo_name, get_repo_path())
-        if not file.exists():
-            file = File.from_path(file_path_without_repo_name, '')
+        derive = query.get('derive', [False])
+        if derive:
+            derive = derive[0]
 
-        git_manager = Git.get_manager(user=user)
+        if derive:
+            try:
+                diff = Path(git_manager.repo_path).relative_to(base_repo_path())
+            except ValueError:
+                diff = git_manager.repo_path
+            try:
+                file_path = str(Path(file_path).relative_to(diff))
+            except ValueError:
+                pass
+
+        file_path_absolute = os.path.join(git_manager.repo_path, file_path)
+        file = File.from_path(file_path_absolute)
+        if not file.exists():
+            file = File.from_path(file_path_absolute, '')
 
         modified_files = git_manager.modified_files
         is_modified = file_path in modified_files
 
-        query = kwargs.get('query', {})
         base_branch = query.get('base_branch', [git_manager.current_branch])
         if base_branch:
             base_branch = base_branch[0]
@@ -46,16 +57,18 @@ class GitFileResource(GenericResource):
                 content_from_base = git_manager.show_file_from_branch(base_branch, file_path)
                 if base_branch == compare_branch:
                     content_from_compare = content_from_base
-                else:
+                elif compare_branch:
                     content_from_compare = git_manager.show_file_from_branch(
                         compare_branch,
                         file_path,
                     )
+                else:
+                    content_from_compare = file.content
             except git.exc.GitCommandError as err:
                 error = str(err)
 
         return self(dict(
-            content=file.content() if os.isfile(file.file_path) else None,
+            content=file.content() if os.path.isfile(file.file_path) else None,
             content_from_base=content_from_base,
             content_from_compare=content_from_compare,
             error=error,

mage_ai/api/resources/KernelResource.py

@@ -30,6 +30,7 @@ class KernelResource(GenericResource):
     @classmethod
     @safe_db_query
     def member(self, pk, user, **kwargs):
+        kernel_fallback = None
         kernels_by_id = {}
 
         for kernel_name in KernelName:
@@ -37,7 +38,14 @@ class KernelResource(GenericResource):
             if kernel.has_kernel:
                 kernels_by_id[kernel.kernel_id] = kernel
 
-        kernel = kernels_by_id.get(pk) or kernel_managers[DEFAULT_KERNEL_NAME]
+                if not kernel_fallback:
+                    kernel_fallback = kernel
+
+        kernel = kernels_by_id.get(pk)
+        if not kernel:
+            kernel = kernel_fallback
+        if not kernel:
+            kernel = kernel_managers[DEFAULT_KERNEL_NAME]
 
         return self(kernel, user, **kwargs)
 

mage_ai/api/resources/LogResource.py

@@ -237,7 +237,7 @@ class LogResource(GenericResource):
             model2.block_uuid = row.block_uuid
             model2.pipeline_run = model
 
-            logs = await model2.logs_async()
+            logs = await model2.logs_async(repo_path=pipeline.repo_path if pipeline else None)
             block_log_file_path = logs.get('path')
             if block_log_file_path not in processed_block_run_log_files:
                 block_run_logs.append(logs)

mage_ai/api/resources/OauthResource.py

@@ -9,9 +9,8 @@ from mage_ai.authentication.oauth.constants import (
     GIT_OAUTH_PROVIDERS,
     GITHUB_CLIENT_ID,
     GITHUB_STATE,
-    OAUTH_PROVIDER_GHE,
-    OAUTH_PROVIDER_GITHUB,
     VALID_OAUTH_PROVIDERS,
+    ProviderName,
     get_ghe_hostname,
 )
 from mage_ai.authentication.oauth.utils import (
@@ -138,8 +137,8 @@ class OauthResource(GenericResource):
 
         ghe_hostname = get_ghe_hostname()
 
-        if pk == OAUTH_PROVIDER_GITHUB and ghe_hostname:
-            provider = OAUTH_PROVIDER_GHE
+        if pk == ProviderName.GITHUB and ghe_hostname:
+            provider = ProviderName.GHE
         else:
             provider = pk
 
@@ -194,7 +193,7 @@ class OauthResource(GenericResource):
                 model['url'] = redirect_uri_final
         # Otherwise, return the authorization url to start the oauth flow.
         else:
-            if OAUTH_PROVIDER_GITHUB == provider:
+            if ProviderName.GITHUB == provider:
                 query = dict(
                     client_id=GITHUB_CLIENT_ID,
                     redirect_uri=urllib.parse.quote_plus(