materials-commons-cli 2.0b9__tar.gz → 2.1.1__tar.gz

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/PKG-INFO

@@ -1,18 +1,12 @@
-Metadata-Version: 1.1
+Metadata-Version: 2.1
 Name: materials_commons-cli
-Version: 2.0b9
+Version: 2.1.1
 Summary: Materials Commons CLI
 Home-page: https://materials-commons.github.io/materials-commons-cli/html/index.html
 Author: Materials Commons development team
 Author-email: materials-commons-authors@umich.edu
 License: MIT
-Description: This package contains the materials_commons.cli module. This module is an interface
-            to the Materials Commons project. We assume you have used (or are otherwise familiar with) the Materials
-            Commons web site, https://materialscommons.org/, or a similar site based on the
-            Materials Commons code (https://github.com/materials-commons/materialscommons), and intend to use these
-            tools in that context.
 Keywords: materials science mc materials-commons prisms
-Platform: UNKNOWN
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -20,3 +14,10 @@ Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
+License-File: LICENSE
+
+This package contains the materials_commons.cli module. This module is an interface
+    to the Materials Commons project. We assume you have used (or are otherwise familiar with) the Materials
+    Commons web site, https://materialscommons.org/, or a similar site based on the
+    Materials Commons code (https://github.com/materials-commons/materialscommons), and intend to use these
+    tools in that context.

materials_commons-cli-2.1.1/materials_commons/cli/__init__.py

@@ -0,0 +1 @@
+__version__ = '2.1.1'

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/materials_commons/cli/functions.py

@@ -60,21 +60,21 @@ def epoch_time(time_value):
     """Attempts to convert various time representations into s since the epoch
 
     Args:
-        time_value: A representation of time.
+        time_value: A representation of time, expects UTC time.
 
     Returns:
-        An integer s since the epoch. Uses the following:
+        An float s since the epoch. Uses the following:
 
             +-------------------+------------------------------------------------------------+
             | If this type      | Then do this conversion                                    |
             +-------------------+------------------------------------------------------------+
-            | str               | time.mktime(dateutil.parser.parse(time_value).timetuple()) |
+            | str               | dateutil.parser.parse(time_value).timestamp()              |
             +-------------------+------------------------------------------------------------+
             | float, int        | time_value                                                 |
             +-------------------+------------------------------------------------------------+
-            | datetime.datetime | time.mktime(time_value.timetuple())                        |
+            | datetime.datetime | time_value.replace(tzinfo=datetime.timezone.utc).timestamp() |
             +-------------------+------------------------------------------------------------+
-            | dict              | time_value['epoch_time']                                   |
+            | dict              | float(time_value['epoch_time'])                            |
             +-------------------+------------------------------------------------------------+
             | None              | None                                                       |
             +-------------------+------------------------------------------------------------+
@@ -82,13 +82,13 @@ def epoch_time(time_value):
             +-------------------+------------------------------------------------------------+
     """
     if isinstance(time_value, str): # expect ISO 8601 str
-        return time.mktime(dateutil.parser.parse(time_value).timetuple())
+        return dateutil.parser.parse(time_value).timestamp()
     elif isinstance(time_value, (float, int)):
-        return time_value
+        return float(time_value)
     elif isinstance(time_value, datetime.datetime):
-        return time.mktime(time_value.timetuple())
+        return time_value.replace(tzinfo=datetime.timezone.utc).timestamp()
     elif isinstance(time_value, dict) and ('epoch_time' in time_value):
-        return time_value['epoch_time']
+        return float(time_value['epoch_time'])
     elif time_value is None:
         return None
     else:
@@ -98,12 +98,12 @@ def format_time(time_value, fmt="%Y %b %d %H:%M:%S"):
     """Attempts to put various time representations into specified format for printing
 
     Args:
-        time_value: A representation of time.
+        time_value: A representation of time, expects UTC time.
 
         fmt (str): Format to use for the return value.
 
     Returns:
-        A string representation using the specified format. Uses the following:
+        A string representation, in local time, using the specified format. Uses the following:
 
             +-------------------+-------------------------------------------------+
             | If this type      | Then do this conversion                         |
@@ -112,7 +112,7 @@ def format_time(time_value, fmt="%Y %b %d %H:%M:%S"):
             +-------------------+-------------------------------------------------+
             | float, int        | time.strftime(fmt, time.localtime(time_value))  |
             +-------------------+-------------------------------------------------+
-            | datetime.datetime | time.strftime(fmt, time.localtime(time_value))  |
+            | datetime.datetime | time_value.strftime(fmt)                        |
             +-------------------+-------------------------------------------------+
             | dict              | format_time(time_value['epoch_time'])           |
             +-------------------+-------------------------------------------------+
@@ -122,11 +122,11 @@ def format_time(time_value, fmt="%Y %b %d %H:%M:%S"):
             +-------------------+-------------------------------------------------+
     """
     if isinstance(time_value, str): # expect ISO 8601 str
-        return dateutil.parser.parse(time_value).strftime(fmt)
+        return dateutil.parser.parse(time_value).astimezone().strftime(fmt)
     elif isinstance(time_value, (float, int)):
         return time.strftime(fmt, time.localtime(time_value))
     elif isinstance(time_value, datetime.datetime):
-        return time_value.strftime(fmt)
+        return time_value.astimezone().strftime(fmt)
     elif isinstance(time_value, dict) and ('epoch_time' in time_value):
         return format_time(time_value['epoch_time'])
     elif time_value is None:

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/materials_commons/cli/globus.py

@@ -1,4 +1,5 @@
 import globus_sdk
+from globus_sdk.scopes import TransferScopes
 import os
 
 import materials_commons.api as mcapi
@@ -9,8 +10,16 @@ from materials_commons.cli.user_config import Config
 
 CLIENT_ID = '1e4aacbc-8c10-4812-a54a-8434d2030a41'
 
+def check_for_consent_required(client, target):
+    try:
+        client.operation_ls(target, path="/")
+    except globus_sdk.TransferAPIError as err:
+        if err.info.consent_required:
+            return err.info.consent_required.required_scopes
+    return None
+
 
-def get_transfer_rt_or_login():
+def get_transfer_rt_or_login(scopes=TransferScopes.all, reauth=False):
     """Get the Globus transfer refresh token, prompting for login if necessary
 
     If not yet configured, will prompt user to login and enter a code used to obtain the refresh
@@ -25,13 +34,14 @@ def get_transfer_rt_or_login():
     config = Config()
 
     # return existing transfer_rt
-    if config.globus.transfer_rt:
-        return config.globus.transfer_rt
+    if not reauth:
+        if config.globus.transfer_rt:
+            return config.globus.transfer_rt
 
     # authenticate
 
     client = globus_sdk.NativeAppAuthClient(CLIENT_ID)
-    client.oauth2_start_flow(refresh_tokens=True)
+    client.oauth2_start_flow(refresh_tokens=True, requested_scopes=scopes)
 
     authorize_url = client.oauth2_get_authorize_url()
     try:
@@ -202,31 +212,50 @@ class GlobusOperations(object):
         return
 
 
-    def upload_v0(self, proj, paths, upload, working_dir, recursive=False,
+    def upload_v0(self, proj, paths, upload, working_dir, recursive=False, no_compare=False,
                   label=None, localtree=None, remotetree=None):
         """Upload files and directories to project
 
         Arguments:
             proj: Project
-            paths: list of str, Materials Commons paths (include project directory)
+            paths (List of str): Materials Commons paths (include project directory) to upload
             upload: mcapi.GlobusUpload, Globus upload request
             working_dir (str): Current working directory, used for finding
                 relative paths and printing messages.
             recursive: bool, If True, upload directories recursively
+            no_compare (bool): If False (default), compare checksum to skip overwriting equivalent
+                files. If True, transfer without checking.
             label: str, Globus transfer label to make finding tasks simpler
 
         Returns:
             None or task_id: str, transfer task id. Returns nothing to transfer.
         """
-        paths = treefuncs.make_mcpaths_for_upload(proj.local_path, paths)
-
         if not len(paths):
             return None
 
         files_data, dirs_data, child_data, non_existing = treefuncs.treecompare(proj, paths, checksum=True, localtree=localtree, remotetree=remotetree)
 
         # https://globus-sdk-python.readthedocs.io/en/stable/clients/transfer/#globus_sdk.TransferData
-        tdata = globus_sdk.TransferData(self.tc, self.local_endpoint_id, upload.globus_endpoint_id, label=label)
+        sync_level = "checksum"
+        if no_compare is True:
+            sync_level = None
+
+        consent_required_scopes = []
+        consent_required = check_for_consent_required(self.tc, self.local_endpoint_id)
+        if consent_required is not None:
+            consent_required_scopes.extend(consent_required)
+
+        consent_required = check_for_consent_required(self.tc, upload.globus_endpoint_id)
+        if consent_required is not None:
+            consent_required_scopes.extend(consent_required)
+
+        if consent_required_scopes:
+            print("One or more of the endpoints requires consent in order to be used.\n"
+                  "You must login a second time to grant consents.\n\n")
+            tr = get_transfer_rt_or_login(scopes=consent_required_scopes, reauth=True)
+            self.tc = make_transfer_client(tr)
+
+        tdata = globus_sdk.TransferData(self.tc, self.local_endpoint_id, upload.globus_endpoint_id, label=label, sync_level=sync_level)
 
         # add items
         n_items = 0
@@ -270,7 +299,7 @@ class GlobusOperations(object):
 
         return task_id
 
-    def download_v0(self, proj, paths, download, working_dir, recursive=False,
+    def download_v0(self, proj, paths, download, working_dir, recursive=False, no_compare=False,
                     label=None, localtree=None, remotetree=None, force=False):
         """Download files and directories from project
 
@@ -282,6 +311,8 @@ class GlobusOperations(object):
             working_dir (str): Current working directory, used for finding
                 relative paths and printing messages.
             recursive: bool, If True, download directories recursively
+            no_compare (bool): If False (default), compare checksum to skip overwriting equivalent
+                files. If True, transfer without checking.
             label: str, Globus transfer label to make finding tasks simpler
             force: bool, If True force download even if local file exists
 
@@ -295,7 +326,26 @@ class GlobusOperations(object):
         files_data, dirs_data, child_data, non_existing = treefuncs.treecompare(proj, paths, checksum=True, localtree=localtree, remotetree=remotetree)
 
         # https://globus-sdk-python.readthedocs.io/en/stable/clients/transfer/#globus_sdk.TransferData
-        tdata = globus_sdk.TransferData(self.tc, download.globus_endpoint_id, self.local_endpoint_id, label=label)
+        sync_level = "checksum"
+        if no_compare is True:
+            sync_level = None
+
+        consent_required_scopes = []
+        consent_required = check_for_consent_required(self.tc, self.local_endpoint_id)
+        if consent_required is not None:
+            consent_required_scopes.extend(consent_required)
+
+        consent_required = check_for_consent_required(self.tc, download.globus_endpoint_id)
+        if consent_required is not None:
+            consent_required_scopes.extend(consent_required)
+
+        if consent_required_scopes:
+            print("One or more of the endpoints requires consent in order to be used.\n"
+                  "You must login a second time to grant consents.\n\n")
+            tr = get_transfer_rt_or_login(scopes=consent_required_scopes, reauth=True)
+            self.tc = make_transfer_client(tr)
+
+        tdata = globus_sdk.TransferData(self.tc, download.globus_endpoint_id, self.local_endpoint_id, label=label, sync_level=sync_level)
 
         # add items
         n_items = 0

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/materials_commons/cli/parser.py

@@ -1,5 +1,4 @@
 import argparse
-import imp
 import os
 import sys
 from io import StringIO
@@ -9,10 +8,9 @@ import materials_commons.api as mcapi
 from materials_commons.cli.subcommands.clone import clone_subcommand
 from materials_commons.cli.subcommands.config import config_subcommand
 from materials_commons.cli.subcommands.dataset import DatasetSubcommand
-# from materials_commons.cli.subcommands.diff import diff_subcommand
 from materials_commons.cli.subcommands.down import down_subcommand
 from materials_commons.cli.subcommands.expt import ExptSubcommand
-# from materials_commons.cli.subcommands.fetch import fetch_subcommand
+from materials_commons.cli.subcommands.fetch import fetch_subcommand
 from materials_commons.cli.subcommands.init import init_subcommand
 from materials_commons.cli.subcommands.ls import ls_subcommand
 from materials_commons.cli.subcommands.mkdir import mkdir_subcommand
@@ -42,24 +40,18 @@ standard_usage = [
     {'name': 'mkdir', 'desc': 'Make directories', 'subcommand': mkdir_subcommand},
     {'name': 'rm', 'desc': 'Remove files and directories', 'subcommand': rm_subcommand},
     {'name': 'mv', 'desc': 'Move files', 'subcommand': mv_subcommand},
-    # {'name': 'diff', 'desc': 'Compare local and remote files', 'subcommand': diff_subcommand},
-    # {'name': 'fetch', 'desc': 'Remote data fetching and configuration', 'subcommand': fetch_subcommand},
+    {'name': 'fetch', 'desc': 'Remote data fetching and configuration', 'subcommand': fetch_subcommand},
     {'name': 'up', 'desc': 'Upload files', 'subcommand': up_subcommand},
     {'name': 'down', 'desc': 'Download files', 'subcommand': down_subcommand},
     {'name': 'globus', 'desc': 'Manage Globus uploads and downloads', 'subcommand': globus_subcommand},
     {'name': 'versions', 'desc': 'List file versions', 'subcommand': versions_subcommand},
-    # {'name': 'templates', 'desc': 'List process templates', 'subcommand': TemplatesSubcommand()},
     # {'name': 'proc', 'desc': 'List processes', 'subcommand': ProcSubcommand()},
     # {'name': 'samp', 'desc': 'List samples', 'subcommand': SampSubcommand()},
     {'name': 'config', 'desc': 'Configure `mc`', 'subcommand': config_subcommand}
 ]
 standard_interfaces = {d['name']: d for d in standard_usage}
 
-developer_usage = [
-    # {'name': 'actions', 'desc': 'List REST API actions', 'subcommand': ActionsSubcommand()}
-]
-
-def make_parser(custom_interfaces={}, developer_interfaces={}):
+def make_parser():
 
     usage_help = StringIO()
     usage_help.write("mc <command> [<args>]\n\n")
@@ -68,18 +60,6 @@ def make_parser(custom_interfaces={}, developer_interfaces={}):
     for name, interface in standard_interfaces.items():
         usage_help.write("  {:10} {:40}\n".format(name, interface['desc']))
 
-    # read custom interfaces from config file
-    if len(custom_interfaces):
-        usage_help.write("\nSpecialized commands are:\n")
-        for name, interface in custom_interfaces.items():
-            usage_help.write("  {:10} {:40}\n".format(name, interface['desc']))
-
-    # hide from most users
-    if len(developer_interfaces):
-        usage_help.write("\nDeveloper commands are:\n")
-        for name, interface in developer_interfaces.items():
-            usage_help.write("  {:10} {:40}\n".format(name, interface['desc']))
-
     parser = argparse.ArgumentParser(
         description='Materials Commons command line interface',
         usage=usage_help.getvalue())
@@ -100,13 +80,7 @@ def main(argv=None, working_dir=None):
             mcapi.Client.set_debug_on()
             pass
 
-        custom_interfaces = {d['name']: d for d in config.interfaces}
-
-        developer_interfaces = {}
-        if config.developer_mode:
-            developer_interfaces = {d['name']: d for d in developer_usage}
-
-        parser = make_parser(custom_interfaces, developer_interfaces)
+        parser = make_parser()
 
         if len(argv) < 2:
             parser.print_help()
@@ -120,23 +94,6 @@ def main(argv=None, working_dir=None):
             result = standard_interfaces[args.command]['subcommand'](argv[2:], working_dir)
             return result
 
-        elif args.command in custom_interfaces:
-            # load module and run command
-            modulename = custom_interfaces[args.command]['module']
-            subcommandname = custom_interfaces[args.command]['subcommand']
-            f, filename, description = imp.find_module(modulename)
-            try:
-                module = imp.load_module(modulename, f, filename, description)
-                result = getattr(module, subcommandname)(argv[2:], working_dir)
-            finally:
-                if f:
-                    f.close()
-            return result
-
-        elif args.command in developer_interfaces:
-            result = developer_interfaces[args.command]['subcommand'](argv[2:], working_dir)
-            return result
-
         else:
             print('Unrecognized command')
             parser.print_help()

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/materials_commons/cli/subcommands/dataset.py

@@ -147,7 +147,7 @@ class DatasetSubcommand(ListObjects):
     def print_details(self, obj, args, out=sys.stdout):
         # TODO: fix this
         out.write("** WARNING: `mc dataset --details` is under development, some dataset attributes (for example: tags) may appear as 'null' even if they do exist. **\n")
-        if args.all:
+        if args.all or not clifuncs.project_exists(self.working_dir):
             client = self.get_remote(args)
             if args.file_selection:
                 out.write("** NOTE: --file-selection: Not available for public datasets **\n")
@@ -191,13 +191,18 @@ class DatasetSubcommand(ListObjects):
 
         .. note:: The downloaded dataset is named dataset.<dataset_uuid>.zip
         """
-        proj = clifuncs.make_local_project(self.working_dir)
+
+        if args.all or not clifuncs.project_exists(self.working_dir):
+            remote = self.get_remote(args)
+        else:
+            proj = clifuncs.make_local_project(self.working_dir)
+            remote = proj.remote
         for obj in objects:
             self.print_details(obj, args, out=out)
             out.write("Downloading...\n")
             dataset_id = obj.id
             to = "dataset." + obj.uuid + ".zip"
-            proj.remote.download_published_dataset_zipfile(dataset_id, to)
+            remote.download_published_dataset_zipfile(dataset_id, to)
             out.write("DONE\n\n")
         return
 

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/materials_commons/cli/subcommands/down.py

@@ -300,7 +300,7 @@ def down_subcommand(argv, working_dir):
                 + " not ready for downloading. Materials Commons is still preparing the project"
                 + " files for download. For large projects this may take some time.")
             print("Use `mc globus download` to check when it is ready and try again.")
-            raise cliexcept.MCCLIException("Invalid download request")
+            return
 
         print("Download is ready.")
 
@@ -310,9 +310,8 @@ def down_subcommand(argv, working_dir):
 
         globus_ops = cliglobus.GlobusOperations()
         task_id = globus_ops.download_v0(proj, paths, download, working_dir,
-                                         recursive=args.recursive, label=label,
-                                         localtree=localtree,
-                                         remotetree=remotetree,
+                                         recursive=args.recursive, label=label, localtree=localtree,
+                                         remotetree=remotetree, no_compare=args.no_compare,
                                          force=args.force)
 
         if task_id:

materials_commons-cli-2.1.1/materials_commons/cli/subcommands/fetch.py

@@ -0,0 +1,92 @@
+import argparse
+import os
+import sys
+import time
+
+import materials_commons.api as mcapi
+import materials_commons.cli.functions as clifuncs
+import materials_commons.cli.tree_functions as treefuncs
+import materials_commons.cli.file_functions as filefuncs
+from materials_commons.cli.treedb import LocalTree, RemoteTree
+
+
+def print_fetch_status(pconfig):
+    if pconfig.remote_updatetime:
+        print("Fetch lock set at:", clifuncs.format_time(pconfig.remote_updatetime))
+        print("Project data will at least reflect remote changes that happened before this time.")
+        print("**Changes that happen after this time may not be reflected in CLI output**.")
+        print("Do `mc fetch --unlock` to turn off the fetch lock.")
+    else:
+        print("Fetch lock off")
+        print("Project data will always be fetched from remote.")
+
+def make_parser():
+    desc = "By default, remote data is fetched for every request. To be more efficient, some remote data can be fetched and cached using `mc fetch --lock`. When 'locked', remote data is recovered from a local cache if it has been updated since the lock was put in place. Any data fetched before the lock was put in place is still updated as necessary. To the extent possible, the cache will be updated when the remote is modified via the `mc` command line. While the lock is in place, use `mc fetch <path>` to force the update of data for particular files or directories. To reset the lock time, use `mc fetch --lock` again. To stop caching, use `mc fetch --unlock`."
+
+    parser = argparse.ArgumentParser(
+        description=desc,
+        prog='mc fetch')
+    parser.add_argument('paths', nargs='*', default=[], help='Files or directories')
+    parser.add_argument('-r', '--recursive', action="store_true", default=False, help='Fetch data recursively for specified paths.')
+    parser.add_argument('--verbose', action="store_true", default=False, help='Print verbosely.')
+    parser.add_argument('--no-children', action="store_true", default=False, help='Do not update data for children of directories.')
+    parser.add_argument('--lock', action="store_true", default=False, help='Only fetch data to replace records older than now.')
+    parser.add_argument('--unlock', action="store_true", default=False, help='Always fetch data.')
+    parser.add_argument('--status', action="store_true", default=False, help='Display fetch lock status.')
+    return parser
+
+def fetch_subcommand(argv, working_dir):
+    """
+    Fetch remote data
+
+    mc fetch [--recursive] [<path>...]
+    mc fetch --lock
+    mc fetch --unlock
+    mc fetch --status
+
+    """
+    parser = make_parser()
+    args = parser.parse_args(argv)
+
+    proj = clifuncs.make_local_project(working_dir)
+    pconfig = clifuncs.read_project_config(proj.local_path)
+
+    if args.lock:
+        pconfig.remote_updatetime = time.time()
+        pconfig.save()
+        print_fetch_status(pconfig)
+
+    elif args.unlock:
+        pconfig.remote_updatetime = None
+        pconfig.save()
+        print_fetch_status(pconfig)
+
+    elif args.status:
+        print_fetch_status(pconfig)
+
+    else:
+        if not args.paths:
+            print("Nothing to fetch")
+            return
+
+        remotetree = RemoteTree(proj, time.time())
+        refpath = os.path.dirname(proj.local_path)
+
+        get_children = True
+        if args.no_children:
+            get_children = False
+
+        mcpaths = treefuncs.clipaths_to_mcpaths(proj.local_path, args.paths,
+                                                working_dir)
+
+        remotetree.connect()
+        for mcpath in mcpaths:
+            print("fetch:", mcpath)
+            remotetree.update(
+                mcpath,
+                get_children=get_children,
+                recurs=args.recursive,
+                verbose=args.verbose)
+        remotetree.close()
+
+    return

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/materials_commons/cli/subcommands/globus.py

@@ -59,9 +59,13 @@ class GlobusUploadTaskSubcommand(ListObjects):
         upload.project_id = upload._data["project_id"]
         status_code = upload._data["status"]
         if status_code == 0:
+            status_message = "Done"  # user should not see this
+        elif status_code == 1:
             status_message = "Finishing"  # processing uploaded files into project
         elif status_code == 2:
-            status_message = "Ready"    # user may upload
+            status_message = "Ready"  # user may upload
+        elif status_code == 3:
+            status_message = "Not started"  # user should not see this
         else:
             status_message = "Error - Unknown status code: " + str(status_code)
         upload.status_code = status_code
@@ -284,7 +288,8 @@ class GlobusDownloadTaskSubcommand(ListObjects):
             headers=['', 'project_name', 'project_id', 'type', 'name', 'id', 'created', 'status'],
             deletable=True,
             creatable=True,
-            custom_selection_actions=['goto'],
+            custom_actions=['unset'],
+            custom_selection_actions=['goto', 'set'],
             request_confirmation_actions={
                 'goto': 'You want to goto these downloads in a web browser?'
             }

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/materials_commons/cli/subcommands/ls.py

@@ -1,5 +1,6 @@
 import argparse
 import copy
+import json
 import os
 import sys
 import time
@@ -119,9 +120,11 @@ def _ls_print(proj, data, refpath=None, printjson=False, checksum=False, checkds
         headers += ['selected', 'selected_by']
 
     if printjson:
+        output = []
         for path, record in data.items():
             if record['r_obj']:
-                print(record['r_obj'].input_data)
+                output.append(record['r_obj']._data)
+        print(json.dumps(output))
     else:
         path_data = _format_path_data(proj, data, columns, refpath=refpath, checksum=checksum)
         if len(path_data):

{materials_commons-cli-2.0b9 → materials_commons-cli-2.1.1}/materials_commons/cli/subcommands/up.py

@@ -74,8 +74,15 @@ def up_subcommand(argv, working_dir):
 
     if args.globus:
 
-        mcpaths = treefuncs.clipaths_to_mcpaths(proj.local_path, args.paths,
-                                                working_dir)
+        # convert input paths (absolute or relative to working_dir) to local_abspath
+        local_abspaths = treefuncs.clipaths_to_local_abspaths(
+            proj.local_path, args.paths, working_dir)
+
+        # filter, skipping .mc, those specified by .mcignore
+        local_abspaths = treefuncs.filter_local_abspaths(
+            proj.local_path, local_abspaths, working_dir)
+
+        mcpaths = treefuncs.clipaths_to_mcpaths(proj.local_path, local_abspaths, working_dir)
 
         all_uploads = {upload.id:upload for upload in proj.remote.get_all_globus_upload_requests(proj.id)}
 
@@ -104,7 +111,8 @@ def up_subcommand(argv, working_dir):
 
         globus_ops = cliglobus.GlobusOperations()
         task_id = globus_ops.upload_v0(proj, mcpaths, upload, working_dir,
-                                       recursive=args.recursive, label=label)
+                                       recursive=args.recursive, no_compare=args.no_compare,
+                                       label=label)
 
         if task_id:
             print("Globus transfer task initiated.")
@@ -119,7 +127,7 @@ def up_subcommand(argv, working_dir):
         if not args.no_compare:
             localtree = LocalTree(proj.local_path)
 
-        treefuncs.standard_upload(proj, args.paths, working_dir,
+        treefuncs.standard_upload_v2(proj, args.paths, working_dir,
                                   recursive=args.recursive, limit=args.limit[0],
                                   no_compare=args.no_compare,
                                   upload_as=upload_as, localtree=localtree,