deriva 1.7.8__tar.gz → 1.7.10__tar.gz

{deriva-1.7.8/deriva.egg-info → deriva-1.7.10}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: deriva
-Version: 1.7.8
+Version: 1.7.10
 Summary: Python APIs and CLIs (Command-Line Interfaces) for the DERIVA platform.
 Home-page: https://github.com/informatics-isi-edu/deriva-py
 Author: USC Information Sciences Institute, Informatics Systems Research Division
@@ -26,12 +26,25 @@ License-File: LICENSE
 Requires-Dist: packaging
 Requires-Dist: requests
 Requires-Dist: pika
-Requires-Dist: urllib3<3,>=1.26
+Requires-Dist: urllib3<3,>=1.26.20
 Requires-Dist: portalocker>=1.2.1
-Requires-Dist: bdbag>=1.7.3
+Requires-Dist: bdbag>=1.7.5
 Requires-Dist: globus_sdk<4,>=3
 Requires-Dist: fair-research-login>=0.3.1
 Requires-Dist: fair-identifiers-client>=0.5.1
 Requires-Dist: jsonschema>=3.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 For further information, visit the project [homepage](https://github.com/informatics-isi-edu/deriva-py).

{deriva-1.7.8 → deriva-1.7.10}/deriva/config/acl_config.py

@@ -291,7 +291,8 @@ class AclConfig:
         elif group.startswith(self.ROBOT_PREFIX_FORMAT.format(server=self.server)):
             self.validate_webauthn_robot(group)
         else:
-            warnings.warn("Can't determine format of group '{g}'".format(g=group))
+            if self.verbose:
+                warnings.warn("Can't determine format of group '{g}'".format(g=group))
 
     def validate_globus_group(self, group):
         guid = group[len(self.GLOBUS_PREFIX):]

{deriva-1.7.8 → deriva-1.7.10}/deriva/core/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.8"
+__version__ = "1.7.10"
 
 from deriva.core.utils.core_utils import *
 from deriva.core.base_cli import BaseCLI, KeyValuePairArgs
@@ -55,7 +55,7 @@ def get_credential(host,
             scope_map = globus_client.hosts_to_scope_map(hosts=[host], match_scope_tag=match_scope_tag,
                                                          force_refresh=force_scope_lookup,
                                                          warn_on_discovery_failure=True if not creds else False)
-            tokens = globus_client.is_logged_in(exclude_defaults=True)
+            tokens = globus_client.is_logged_in(exclude_defaults=True, hosts_to_scope_map=scope_map)
             if tokens:
                 # 1. look for the explicitly requested scope in the token store, if specified
                 token = globus_client.find_access_token_for_scope(requested_scope, tokens)

{deriva-1.7.8 → deriva-1.7.10}/deriva/core/catalog_cli.py

@@ -6,7 +6,7 @@ import traceback
 from pprint import pp
 from requests.exceptions import HTTPError, ConnectionError
 from deriva.core import __version__ as VERSION, BaseCLI, KeyValuePairArgs, DerivaServer, DerivaPathError, \
-    get_credential, format_credential, format_exception, DEFAULT_HEADERS
+    get_credential, format_credential, format_exception, read_config, DEFAULT_SESSION_CONFIG, DEFAULT_HEADERS
 from deriva.core.ermrest_model import nochange
 from deriva.core.utils import eprint
 
@@ -191,6 +191,11 @@ class DerivaCatalogCLI (BaseCLI):
         else:
             return get_credential(host_name)
 
+    @staticmethod
+    def _get_session_config():
+        config = read_config()
+        return config.get("session", DEFAULT_SESSION_CONFIG)
+
     def _post_parser_init(self, args):
         """Shared initialization for all sub-commands.
         """
@@ -202,7 +207,8 @@ class DerivaCatalogCLI (BaseCLI):
                                    credentials=DerivaCatalogCLI._get_credential(
                                        self.host,
                                        token=args.token,
-                                       oauth2_token=args.oauth2_token))
+                                       oauth2_token=args.oauth2_token),
+                                   session_config=DerivaCatalogCLI._get_session_config())
 
     @staticmethod
     def _decorate_headers(headers, file_format, method="get"):
@@ -279,10 +285,10 @@ class DerivaCatalogCLI (BaseCLI):
         catalog = self.server.connect_ermrest(args.id)
         try:
             if args.output_file:
-                catalog.getAsFile(args.path,
-                                  destfilename=args.output_file,
-                                  headers=headers,
-                                  delete_if_empty=args.auto_delete)
+                catalog.get_as_file(args.path,
+                                    destfilename=args.output_file,
+                                    headers=headers,
+                                    delete_if_empty=args.auto_delete)
             else:
                 pp(catalog.get(args.path, headers=headers).json())
         except HTTPError as e:

{deriva-1.7.8 → deriva-1.7.10}/deriva/core/datapath.py

@@ -11,7 +11,8 @@ from requests import HTTPError
 import warnings
 from . import DEFAULT_HEADERS, ermrest_model as _erm
 
-__all__ = ['DataPathException', 'Min', 'Max', 'Sum', 'Avg', 'Cnt', 'CntD', 'Array', 'ArrayD', 'Bin']
+__all__ = ['DataPathException', 'Min', 'Max', 'Sum', 'Avg', 'Cnt', 'CntD', 'Array', 'ArrayD', 'Bin', 'All', 'Any',
+           'simple_denormalization', 'simple_denormalization_with_whole_entities']
 
 logger = logging.getLogger(__name__)
 """Logger for this module"""
@@ -1265,6 +1266,19 @@ class _ColumnWrapper (object):
 
     __eq__ = eq
 
+    def ne(self, other):
+        """Returns a 'not equal' comparison predicate.
+
+        :param other: `None` or any other literal value.
+        :return: a filter predicate object
+        """
+        if other is None:
+            return _ComparisonPredicate(self, "::null::", '').negate()
+        else:
+            return _ComparisonPredicate(self, "=", other).negate()
+
+    __ne__ = ne
+
     def lt(self, other):
         """Returns a 'less than' comparison predicate.
 
@@ -1311,8 +1325,6 @@ class _ColumnWrapper (object):
         :param other: a _string_ literal value.
         :return: a filter predicate object
         """
-        if not isinstance(other, str):
-            logger.warning("'regexp' method comparison only supports string literals.")
         return _ComparisonPredicate(self, "::regexp::", other)
 
     def ciregexp(self, other):
@@ -1321,8 +1333,6 @@ class _ColumnWrapper (object):
         :param other: a _string_ literal value.
         :return: a filter predicate object
         """
-        if not isinstance(other, str):
-            logger.warning("'ciregexp' method comparison only supports string literals.")
         return _ComparisonPredicate(self, "::ciregexp::", other)
 
     def ts(self, other):
@@ -1331,8 +1341,6 @@ class _ColumnWrapper (object):
         :param other: a _string_ literal value.
         :return: a filter predicate object
         """
-        if not isinstance(other, str):
-            logger.warning("'ts' method comparison only supports string literals.")
         return _ComparisonPredicate(self, "::ts::", other)
 
     def alias(self, name):
@@ -1395,6 +1403,16 @@ class _ColumnAlias (object):
 
     __eq__ = eq
 
+    def ne(self, other):
+        """Returns a 'not equal' comparison predicate.
+
+        :param other: `None` or any other literal value.
+        :return: a filter predicate object
+        """
+        return self._base_column.ne(other)
+
+    __ne__ = ne
+
     def lt(self, other):
         """Returns a 'less than' comparison predicate.
 
@@ -1713,7 +1731,7 @@ class _ComparisonPredicate (_Predicate):
         assert isinstance(lop, _ColumnWrapper)
         assert isinstance(rop, _ColumnWrapper) or isinstance(rop, int) or \
                isinstance(rop, float) or isinstance(rop, str) or \
-               isinstance(rop, date)
+               isinstance(rop, date) or isinstance(rop, _Quantifier)
         assert isinstance(op, str)
         self._lop = lop
         self._op = op
@@ -1739,6 +1757,9 @@ class _ComparisonPredicate (_Predicate):
         if isinstance(self._rop, _ColumnWrapper):
             # The only valid circumstance for a _ColumnWrapper rop is in a link 'on' predicate for simple key/fkey joins
             return "(%s)=(%s)" % (self._lop._instancename, self._rop._fqname)
+        elif isinstance(self._rop, _Quantifier):
+            # Quantifiers can be trusted to properly urlquote their literals
+            return "%s%s%s" % (self._lop._instancename, self._op, str(self._rop))
         else:
             # All other comparisons are serialized per the usual form
             return "%s%s%s" % (self._lop._instancename, self._op, urlquote(str(self._rop)))
@@ -1810,6 +1831,34 @@ class _NegationPredicate (_Predicate):
         return "!(%s)" % self._child
 
 
+class _Quantifier (object):
+    """Base class of quantifiers."""
+    def __init__(self, quantifier_name, *args):
+        """Initializes the quantifier object.
+
+        :param quantifier_name: name of the quantifier per ERMrest specification.
+        :param args: arguments of the quantifier per ERMrest specification.
+        """
+        super(_Quantifier, self).__init__()
+        self._quantifier_name = quantifier_name
+        self._args = args
+
+    def __str__(self):
+        return "%s(%s)" % (self._quantifier_name, ','.join([urlquote(str(arg)) for arg in self._args]))
+
+
+class All (_Quantifier):
+    """Universal quantifier."""
+    def __init__(self, *args):
+        super(All, self).__init__('all', *args)
+
+
+class Any (_Quantifier):
+    """Existential quantifier."""
+    def __init__(self, *args):
+        super(Any, self).__init__('any', *args)
+
+
 class AggregateFunction (object):
     """Base class of all aggregate functions."""
     def __init__(self, fn_name, arg):

{deriva-1.7.8 → deriva-1.7.10}/deriva/core/deriva_binding.py

@@ -139,9 +139,10 @@ class DerivaBinding (object):
             server
         )
         self._server_uri = self._base_server_uri
+        self._auth_uri = self._base_server_uri + "/authn/session"
 
-        self.session_config = DEFAULT_SESSION_CONFIG if not session_config else session_config
         self._session = None
+        self.session_config = DEFAULT_SESSION_CONFIG if not session_config else session_config
         self._get_new_session(self.session_config)
 
         self._caching = caching
@@ -160,9 +161,6 @@ class DerivaBinding (object):
         self._close_session()
         self._session = get_new_requests_session(self._server_uri + '/',
                                                  session_config if session_config else self.session_config)
-        # allow loopback requests to bypass SSL cert verification
-        if "https://localhost" in self._server_uri:
-            self._session.verify = False
 
     def _pre_get(self, path, headers):
         self.check_path(path)
@@ -222,19 +220,21 @@ class DerivaBinding (object):
             self._session.headers.update({'Authorization': 'Bearer {token}'.format(token=credentials['bearer-token'])})
         elif 'cookie' in credentials:
             cname, cval = credentials['cookie'].split('=', 1)
-            self._session.cookies.set(cname, cval, domain=server, path='/')
+            # Fix for cookielib domain rewrite to *.local when no "." in hostname. In this case, don't set the domain.
+            # Covers "localhost" and other dev/test scenarios. See "https://github.com/psf/requests/issues/5388"
+            self._session.cookies.set(cname, cval, domain="" if "." not in server else server, path='/')
         elif 'username' in credentials and 'password' in credentials:
             self.post_authn_session(credentials)
 
     def get_authn_session(self):
         headers = { 'deriva-client-context': self.dcctx.encoded() }
-        r = self._session.get(self._base_server_uri + "/authn/session", headers=headers)
+        r = self._session.get(self._auth_uri, headers=headers)
         _response_raise_for_status(r)
         return r
 
     def post_authn_session(self, credentials):
         headers = { 'deriva-client-context': self.dcctx.encoded() }
-        r = self._session.post(self._base_server_uri + "/authn/session", data=credentials, headers=headers)
+        r = self._session.post(self._auth_uri, data=credentials, headers=headers)
         _response_raise_for_status(r)
         return r
 

{deriva-1.7.8 → deriva-1.7.10}/deriva/core/ermrest_catalog.py

@@ -481,12 +481,26 @@ class ErmrestCatalog(DerivaBinding):
     def getAsFile(self,
                   path,
                   destfilename,
-                  headers=DEFAULT_HEADERS,
-                  callback=None,
-                  delete_if_empty=False,
-                  paged=False,
-                  page_size=DEFAULT_PAGE_SIZE,
-                  page_sort_columns=frozenset(["RID"])):
+                  headers = DEFAULT_HEADERS,
+                  callback = None,
+                  delete_if_empty = False,
+                  paged = False,
+                  page_size = DEFAULT_PAGE_SIZE,
+                  page_sort_columns = frozenset(["RID"])):
+        """
+           Deprecated, call `get_as_file` instead.
+        """
+        self.get_as_file(path, destfilename, headers, callback, delete_if_empty, paged, page_size, page_sort_columns)
+
+    def get_as_file(self,
+                    path,
+                    destfilename,
+                    headers=DEFAULT_HEADERS,
+                    callback=None,
+                    delete_if_empty=False,
+                    paged=False,
+                    page_size=DEFAULT_PAGE_SIZE,
+                    page_sort_columns=frozenset(["RID"])):
         """
            Retrieve catalog data streamed to destination file.
            Caller is responsible to clean up file even on error, when the file may or may not exist.

{deriva-1.7.8 → deriva-1.7.10}/deriva/core/ermrest_model.py

@@ -188,7 +188,7 @@ def equivalent(doc1, doc2, method=None):
         def canon_cat_acls(d):
             return {
                 k: d.get(k, [])
-                for k in {'owner', 'read', 'write', 'insert', 'update', 'delete'}
+                for k in {'owner', 'enumerate', 'write', 'select', 'insert', 'update', 'delete'}
             }
         return equivalent(canon_cat_acls(doc1), canon_cat_acls(doc2), method='acls')
     elif method == 'foreign_key_acls':

{deriva-1.7.8 → deriva-1.7.10}/deriva/core/utils/core_utils.py

@@ -48,7 +48,8 @@ DEFAULT_SESSION_CONFIG = {
     "allow_retry_on_all_methods": False,
     "cookie_jar": DEFAULT_COOKIE_JAR_FILE,
     "max_request_size": DEFAULT_MAX_REQUEST_SIZE,
-    "max_chunk_limit": DEFAULT_MAX_CHUNK_LIMIT
+    "max_chunk_limit": DEFAULT_MAX_CHUNK_LIMIT,
+    "bypass_cert_verify_host_list": []
 }
 OAUTH2_SCOPES_KEY = "oauth2_scopes"
 DEFAULT_CONFIG = {
@@ -189,11 +190,15 @@ def get_new_requests_session(url=None, session_config=DEFAULT_SESSION_CONFIG):
                     not session_config.get("allow_retry_on_all_methods", False) else False,
                     raise_on_status=True)
     adapter = TimeoutHTTPAdapter(timeout=session_config.get("timeout", DEFAULT_REQUESTS_TIMEOUT), max_retries=retries)
+    session.mount('http://', adapter)
+    session.mount('https://', adapter)
+
     if url:
-        session.mount(url, adapter)
-    else:
-        session.mount('http://', adapter)
-        session.mount('https://', adapter)
+        # allow whitelisted hosts to bypass SSL cert verification
+        upr = urlparse(url)
+        bypass_cert_verify_host_list = session_config.get("bypass_cert_verify_host_list", [])
+        if upr.scheme == "https" and upr.hostname in bypass_cert_verify_host_list:
+            session.verify = False
 
     return session
 
@@ -301,7 +306,7 @@ def get_oauth_scopes_for_host(host,
                 result = scopes
                 break
     if not result or force_refresh:
-        session = get_new_requests_session(session_config=DEFAULT_SESSION_CONFIG)
+        session = get_new_requests_session(url, session_config=config.get("session", DEFAULT_SESSION_CONFIG))
         try:
             r = session.get(url, headers=DEFAULT_HEADERS)
             r.raise_for_status()

{deriva-1.7.8 → deriva-1.7.10}/deriva/core/utils/globus_auth_utils.py

@@ -5,7 +5,7 @@ import json
 import logging
 import platform
 import traceback
-import importlib
+import time
 import datetime
 import tzlocal
 import webbrowser
@@ -15,7 +15,8 @@ from bdbag.fetch.auth import keychain as bdbkc
 from deriva.core import __version__ as VERSION, DEFAULT_CONFIG_PATH, DEFAULT_GLOBUS_CREDENTIAL_FILE, urlparse, urljoin,\
     read_config, format_exception, BaseCLI, get_oauth_scopes_for_host, get_new_requests_session
 from deriva.core.utils import eprint
-from globus_sdk import ConfidentialAppAuthClient, AuthClient, AccessTokenAuthorizer, GlobusError, GlobusAPIError
+from globus_sdk import ConfidentialAppAuthClient, AuthClient, AccessTokenAuthorizer, RefreshTokenAuthorizer, \
+    GlobusError, GlobusAPIError, AuthAPIError
 from fair_research_login.client import NativeClient, LoadError, NoSavedTokens, TokensExpired
 
 NATIVE_APP_CLIENT_ID = "8ef15ba9-2b4a-469c-a163-7fd910c9d111"
@@ -586,12 +587,47 @@ class GlobusNativeLogin:
         if not scopes:
             return None
         try:
-            return self.client.load_tokens(scopes)
+            tokens = self.client.load_tokens(list(scopes))
+            return self.refresh_tokens_preemptively(tokens, time_before_expiry=86400)
         except LoadError as e:
             logging.debug("Unable to load or find tokens for specified scopes [%s]: %s" %
                           (scopes, format_exception(e)))
             return None
 
+    def refresh_tokens_preemptively(self, tokens, time_before_expiry=0):
+        needs_refresh = {}
+
+        for rs, ts in {t: ts for t, ts in tokens.items() if bool(ts['refresh_token'])}.items():
+            expiry_threshold = int(time.time()) + time_before_expiry
+            if ts['expires_at_seconds'] < expiry_threshold:
+                needs_refresh.update({rs:ts})
+
+        if not needs_refresh:
+            return tokens
+
+        for rs, ts in needs_refresh.items():
+            authorizer = RefreshTokenAuthorizer(
+                ts['refresh_token'],
+                self.client.client,
+                access_token=ts['access_token'],
+                expires_at=int(time.time()),
+                # setting the expires_at to the current time is vicious hack but necessary since the globus_sdk
+                # client doesn't allow you to refresh an access token unless it has already expired
+            )
+            try:
+                authorizer.ensure_valid_token()
+                ts['access_token'] = authorizer.access_token
+                ts['expires_at_seconds'] = authorizer.expires_at
+            except AuthAPIError as e:
+                if e.message == 'invalid_grant':
+                    logging.warning('Refresh Token expired for resource server: %s', rs)
+
+        self.client.save_tokens(needs_refresh)
+        result = {rs: ts for rs, ts in tokens.items() if rs not in needs_refresh}
+        result.update(needs_refresh)
+
+        return result
+
     def hosts_to_scope_map(self,
                            hosts,
                            match_scope_tag=None,
@@ -662,6 +698,7 @@ class GlobusNativeLogin:
             access_token = token.get("access_token")
             if (token_scope == scope) and (access_token is not None):
                 return access_token
+        return None
 
     def update_bdbag_keychain(self, token=None, host=None, keychain_file=None, allow_redirects=False, delete=False):
         if (token is None) or (host is None):
@@ -699,7 +736,7 @@ class GlobusNativeLogin:
             prefill_named_grant = self.client.app_name + " with requested scopes [%s] " % ", ".join(scopes)
         tokens = self.client.login(no_local_server=no_local_server,
                                    no_browser=no_browser,
-                                   requested_scopes=scopes,
+                                   requested_scopes=list(scopes),
                                    refresh_tokens=refresh_tokens,
                                    prefill_named_grant=prefill_named_grant,
                                    query_params=additional_params,

{deriva-1.7.8 → deriva-1.7.10}/deriva/transfer/download/deriva_export.py

@@ -45,6 +45,7 @@ class DerivaExport:
         self.timeout = kwargs.get("timeout")
         self.export_type = kwargs.get("export_type", "bdbag")
         self.base_server_uri = "https://" + self.host
+        self.auth_service_url = self.base_server_uri + "/authn/session"
         self.service_url = self.base_server_uri + EXPORT_SERVICE_PATH % self.export_type
         self.session_config = DEFAULT_SESSION_CONFIG.copy()
         if isinstance(self.timeout, tuple):
@@ -77,16 +78,23 @@ class DerivaExport:
             raise DerivaDownloadAuthenticationError(
                 "The requested service requires authentication and a valid login credential could "
                 "not be found (or was not provided) for the specified host.")
+
         if 'bearer-token' in self.credential:
             self.session.headers.update(
                 {'Authorization': 'Bearer {token}'.format(token=self.credential['bearer-token'])})
         elif 'cookie' in self.credential:
             cname, cval = self.credential['cookie'].split('=', 1)
-            self.session.cookies.set(cname, cval, domain=self.host, path='/')
+            self.session.cookies.set(cname, cval, domain="" if "." not in self.host else self.host, path='/')
+        else:
+            try:
+                r = self.session.post(self.auth_service_url, data=self.credential)
+                r.raise_for_status()
+            except HTTPError as e:
+                raise DerivaDownloadAuthenticationError(
+                    "Exception during POST authentication flow: %s" % format_exception(e))
 
     def validate_authn_session(self):
-        url = self.base_server_uri + "/authn/session"
-        r = self.session.get(url)
+        r = self.session.get(self.auth_service_url)
         if r.status_code == requests.codes.not_found or r.status_code == requests.codes.unauthorized:
             logger.warning("Unable to authenticate. Check for missing or expired credentials.")
         r.raise_for_status()

{deriva-1.7.8 → deriva-1.7.10}/deriva/transfer/download/processors/query/base_query_processor.py

@@ -71,13 +71,13 @@ class BaseQueryProcessor(BaseProcessor):
             make_dirs(output_dir)
         try:
             if as_file:
-                return self.catalog.getAsFile(self.query, self.output_abspath,
-                                              headers=headers,
-                                              callback=self.callback,
-                                              delete_if_empty=True,
-                                              paged=self.paged_query,
-                                              page_size=self.paged_query_size,
-                                              page_sort_columns=self.paged_query_sort_columns)
+                return self.catalog.get_as_file(self.query, self.output_abspath,
+                                                headers=headers,
+                                                callback=self.callback,
+                                                delete_if_empty=True,
+                                                paged=self.paged_query,
+                                                page_size=self.paged_query_size,
+                                                page_sort_columns=self.paged_query_sort_columns)
             else:
                 return self.catalog.get(self.query, headers=headers).json()
         except requests.HTTPError as e:
@@ -142,21 +142,21 @@ class BaseQueryProcessor(BaseProcessor):
 
         return url
 
-    def getExternalSession(self, host):
-        sessions = self.sessions
+    def getExternalSession(self, url):
         auth_params = self.kwargs.get("auth_params", dict())
         cookies = auth_params.get("cookies")
         auth_url = auth_params.get("auth_url")
         login_params = auth_params.get("login_params")
         session_config = self.kwargs.get("session_config")
 
-        session = sessions.get(host)
+        host = urlsplit(url).hostname
+        session = self.sessions.get(host)
         if session is not None:
             return session
 
         if not session_config:
             session_config = DEFAULT_SESSION_CONFIG
-        session = get_new_requests_session(session_config=session_config)
+        session = get_new_requests_session(url, session_config=session_config)
 
         if cookies:
             session.cookies.update(cookies)
@@ -166,7 +166,7 @@ class BaseQueryProcessor(BaseProcessor):
                 raise DerivaDownloadError(
                     'GetExternalSession Failed with Status Code: %s\n%s\n' % (r.status_code, r.text))
 
-        sessions[host] = session
+        self.sessions[host] = session
         return session
 
     def create_default_paths(self):

{deriva-1.7.8 → deriva-1.7.10}/deriva/transfer/download/processors/query/file_download_query_processor.py

@@ -31,13 +31,12 @@ class FileDownloadQueryProcessor(BaseQueryProcessor):
         return self.outputs
 
     def getExternalFile(self, url, output_path, headers=None):
-        host = urlsplit(url).netloc
         if output_path:
             if not headers:
                 headers = self.HEADERS.copy()
             else:
                 headers.update(self.HEADERS)
-            session = self.getExternalSession(host)
+            session = self.getExternalSession(url)
             with session.get(url, headers=headers, stream=True) as r:
                 if r.status_code != 200:
                     file_error = "File [%s] transfer failed." % output_path
@@ -58,6 +57,7 @@ class FileDownloadQueryProcessor(BaseQueryProcessor):
                     length = int(r.headers.get('Content-Length'))
                     content_type = r.headers.get("Content-Type")
                     return output_path, length, content_type
+        return None
 
     def downloadFiles(self, input_manifest):
         logging.info("Attempting to download file(s) based on the results of query: %s" % self.query)