�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fopt%2F'>opt</a>/<a href='?path=%2Fopt%2Fgsutil%2F'>gsutil</a>/<a href='?path=%2Fopt%2Fgsutil%2Fgslib%2F'>gslib</a>/</p><hr><h3>✏️ Editing: tab_complete.py</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'># -*- coding: utf-8 -*-
# Copyright 2014 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
&quot;&quot;&quot;Shell tab completion.&quot;&quot;&quot;

from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
from __future__ import unicode_literals

import itertools
import json
import threading
import time

import boto

from boto.gs.acl import CannedACLStrings
from gslib.storage_url import IsFileUrlString
from gslib.storage_url import StorageUrlFromString
from gslib.storage_url import StripOneSlash
from gslib.utils.boto_util import GetTabCompletionCacheFilename
from gslib.utils.boto_util import GetTabCompletionLogFilename
from gslib.wildcard_iterator import CreateWildcardIterator

TAB_COMPLETE_CACHE_TTL = 15

_TAB_COMPLETE_MAX_RESULTS = 1000

_TIMEOUT_WARNING = &quot;&quot;&quot;
Tab completion aborted (took &gt;%ss), you may complete the command manually.
The timeout can be adjusted in the gsutil configuration file.
&quot;&quot;&quot;.rstrip()


class CompleterType(object):
  CLOUD_BUCKET = &#039;cloud_bucket&#039;
  CLOUD_OBJECT = &#039;cloud_object&#039;
  CLOUD_OR_LOCAL_OBJECT = &#039;cloud_or_local_object&#039;
  LOCAL_OBJECT = &#039;local_object&#039;
  LOCAL_OBJECT_OR_CANNED_ACL = &#039;local_object_or_canned_acl&#039;
  NO_OP = &#039;no_op&#039;


class LocalObjectCompleter(object):
  &quot;&quot;&quot;Completer object for local files.&quot;&quot;&quot;

  def __init__(self):
    # This is only safe to import if argcomplete is present in the install
    # (which happens for Cloud SDK installs), so import on usage, not on load.
    # pylint: disable=g-import-not-at-top
    from argcomplete.completers import FilesCompleter
    self.files_completer = FilesCompleter()

  def __call__(self, prefix, **kwargs):
    return self.files_completer(prefix, **kwargs)


class LocalObjectOrCannedACLCompleter(object):
  &quot;&quot;&quot;Completer object for local files and canned ACLs.

  Currently, only Google Cloud Storage canned ACL names are supported.
  &quot;&quot;&quot;

  def __init__(self):
    self.local_object_completer = LocalObjectCompleter()

  def __call__(self, prefix, **kwargs):
    local_objects = self.local_object_completer(prefix, **kwargs)
    canned_acls = [acl for acl in CannedACLStrings if acl.startswith(prefix)]
    return local_objects + canned_acls


class TabCompletionCache(object):
  &quot;&quot;&quot;Cache for tab completion results.&quot;&quot;&quot;

  def __init__(self, prefix, results, timestamp, partial_results):
    self.prefix = prefix
    self.results = results
    self.timestamp = timestamp
    self.partial_results = partial_results

  @staticmethod
  def LoadFromFile(filename):
    &quot;&quot;&quot;Instantiates the cache from a file.

    Args:
      filename: The file to load.
    Returns:
      TabCompletionCache instance with loaded data or an empty cache
          if the file cannot be loaded
    &quot;&quot;&quot;
    try:
      with open(filename, &#039;r&#039;) as fp:
        cache_dict = json.loads(fp.read())
        prefix = cache_dict[&#039;prefix&#039;]
        results = cache_dict[&#039;results&#039;]
        timestamp = cache_dict[&#039;timestamp&#039;]
        partial_results = cache_dict[&#039;partial-results&#039;]
    except Exception:  # pylint: disable=broad-except
      # Guarding against incompatible format changes in the cache file.
      # Erring on the side of not breaking tab-completion in case of cache
      # issues.
      prefix = None
      results = []
      timestamp = 0
      partial_results = False

    return TabCompletionCache(prefix, results, timestamp, partial_results)

  def GetCachedResults(self, prefix):
    &quot;&quot;&quot;Returns the cached results for prefix or None if not in cache.&quot;&quot;&quot;
    current_time = time.time()
    if current_time - self.timestamp &gt;= TAB_COMPLETE_CACHE_TTL:
      return None

    results = None

    if prefix == self.prefix:
      results = self.results
    elif (not self.partial_results and prefix.startswith(self.prefix) and
          prefix.count(&#039;/&#039;) == self.prefix.count(&#039;/&#039;)):
      results = [x for x in self.results if x.startswith(prefix)]

    if results is not None:
      # Update cache timestamp to make sure the cache entry does not expire if
      # the user is performing multiple completions in a single
      # bucket/subdirectory since we can answer these requests from the cache.
      # e.g. gs://prefix&lt;tab&gt; -&gt; gs://prefix-mid&lt;tab&gt; -&gt; gs://prefix-mid-suffix
      self.timestamp = time.time()
      return results

  def UpdateCache(self, prefix, results, partial_results):
    &quot;&quot;&quot;Updates the in-memory cache with the results for the given prefix.&quot;&quot;&quot;
    self.prefix = prefix
    self.results = results
    self.partial_results = partial_results
    self.timestamp = time.time()

  def WriteToFile(self, filename):
    &quot;&quot;&quot;Writes out the cache to the given file.&quot;&quot;&quot;
    json_str = json.dumps({
        &#039;prefix&#039;: self.prefix,
        &#039;results&#039;: self.results,
        &#039;partial-results&#039;: self.partial_results,
        &#039;timestamp&#039;: self.timestamp,
    })

    try:
      with open(filename, &#039;w&#039;) as fp:
        fp.write(json_str)
    except IOError:
      pass


class CloudListingRequestThread(threading.Thread):
  &quot;&quot;&quot;Thread that performs a listing request for the given URL string.&quot;&quot;&quot;

  def __init__(self, wildcard_url_str, gsutil_api):
    &quot;&quot;&quot;Instantiates Cloud listing request thread.

    Args:
      wildcard_url_str: The URL to list.
      gsutil_api: gsutil Cloud API instance to use.
    &quot;&quot;&quot;
    super(CloudListingRequestThread, self).__init__()
    self.daemon = True
    self._wildcard_url_str = wildcard_url_str
    self._gsutil_api = gsutil_api
    self.results = None

  def run(self):
    it = CreateWildcardIterator(
        self._wildcard_url_str,
        self._gsutil_api).IterAll(bucket_listing_fields=[&#039;name&#039;])
    self.results = [
        str(c) for c in itertools.islice(it, _TAB_COMPLETE_MAX_RESULTS)
    ]


class TimeoutError(Exception):
  pass


class CloudObjectCompleter(object):
  &quot;&quot;&quot;Completer object for Cloud URLs.&quot;&quot;&quot;

  def __init__(self, gsutil_api, bucket_only=False):
    &quot;&quot;&quot;Instantiates completer for Cloud URLs.

    Args:
      gsutil_api: gsutil Cloud API instance to use.
      bucket_only: Whether the completer should only match buckets.
    &quot;&quot;&quot;
    self._gsutil_api = gsutil_api
    self._bucket_only = bucket_only

  def _PerformCloudListing(self, wildcard_url, timeout):
    &quot;&quot;&quot;Perform a remote listing request for the given wildcard URL.

    Args:
      wildcard_url: The wildcard URL to list.
      timeout: Time limit for the request.
    Returns:
      Cloud resources matching the given wildcard URL.
    Raises:
      TimeoutError: If the listing does not finish within the timeout.
    &quot;&quot;&quot;
    request_thread = CloudListingRequestThread(wildcard_url, self._gsutil_api)
    request_thread.start()
    request_thread.join(timeout)

    if request_thread.is_alive():
      # This is only safe to import if argcomplete is present in the install
      # (which happens for Cloud SDK installs), so import on usage, not on load.
      # pylint: disable=g-import-not-at-top
      import argcomplete
      argcomplete.warn(_TIMEOUT_WARNING % timeout)
      raise TimeoutError()

    results = request_thread.results

    return results

  def __call__(self, prefix, **kwargs):
    if not prefix:
      prefix = &#039;gs://&#039;
    elif IsFileUrlString(prefix):
      return []

    wildcard_url = prefix + &#039;*&#039;
    url = StorageUrlFromString(wildcard_url)
    if self._bucket_only and not url.IsBucket():
      return []

    timeout = boto.config.getint(&#039;GSUtil&#039;, &#039;tab_completion_timeout&#039;, 5)
    if timeout == 0:
      return []

    start_time = time.time()

    cache = TabCompletionCache.LoadFromFile(GetTabCompletionCacheFilename())
    cached_results = cache.GetCachedResults(prefix)

    timing_log_entry_type = &#039;&#039;
    if cached_results is not None:
      results = cached_results
      timing_log_entry_type = &#039; (from cache)&#039;
    else:
      try:
        results = self._PerformCloudListing(wildcard_url, timeout)
        if self._bucket_only and len(results) == 1:
          results = [StripOneSlash(results[0])]
        partial_results = (len(results) == _TAB_COMPLETE_MAX_RESULTS)
        cache.UpdateCache(prefix, results, partial_results)
      except TimeoutError:
        timing_log_entry_type = &#039; (request timeout)&#039;
        results = []

    cache.WriteToFile(GetTabCompletionCacheFilename())

    end_time = time.time()
    num_results = len(results)
    elapsed_seconds = end_time - start_time
    _WriteTimingLog(
        &#039;%s results%s in %.2fs, %.2f results/second for prefix: %s\n&#039; %
        (num_results, timing_log_entry_type, elapsed_seconds,
         num_results / elapsed_seconds, prefix))

    return results


class CloudOrLocalObjectCompleter(object):
  &quot;&quot;&quot;Completer object for Cloud URLs or local files.

  Invokes the Cloud object completer if the input looks like a Cloud URL and
  falls back to local file completer otherwise.
  &quot;&quot;&quot;

  def __init__(self, gsutil_api):
    self.cloud_object_completer = CloudObjectCompleter(gsutil_api)
    self.local_object_completer = LocalObjectCompleter()

  def __call__(self, prefix, **kwargs):
    if IsFileUrlString(prefix):
      completer = self.local_object_completer
    else:
      completer = self.cloud_object_completer
    return completer(prefix, **kwargs)


class NoOpCompleter(object):
  &quot;&quot;&quot;Completer that always returns 0 results.&quot;&quot;&quot;

  def __call__(self, unused_prefix, **unused_kwargs):
    return []


def MakeCompleter(completer_type, gsutil_api):
  &quot;&quot;&quot;Create a completer instance of the given type.

  Args:
    completer_type: The type of completer to create.
    gsutil_api: gsutil Cloud API instance to use.
  Returns:
    A completer instance.
  Raises:
    RuntimeError: if completer type is not supported.
  &quot;&quot;&quot;
  if completer_type == CompleterType.CLOUD_OR_LOCAL_OBJECT:
    return CloudOrLocalObjectCompleter(gsutil_api)
  elif completer_type == CompleterType.LOCAL_OBJECT:
    return LocalObjectCompleter()
  elif completer_type == CompleterType.LOCAL_OBJECT_OR_CANNED_ACL:
    return LocalObjectOrCannedACLCompleter()
  elif completer_type == CompleterType.CLOUD_BUCKET:
    return CloudObjectCompleter(gsutil_api, bucket_only=True)
  elif completer_type == CompleterType.CLOUD_OBJECT:
    return CloudObjectCompleter(gsutil_api)
  elif completer_type == CompleterType.NO_OP:
    return NoOpCompleter()
  else:
    raise RuntimeError(&#039;Unknown completer &quot;%s&quot;&#039; % completer_type)


def _WriteTimingLog(message):
  &quot;&quot;&quot;Write an entry to the tab completion timing log, if it&#039;s enabled.&quot;&quot;&quot;
  if boto.config.getbool(&#039;GSUtil&#039;, &#039;tab_completion_time_logs&#039;, False):
    with open(GetTabCompletionLogFilename(), &#039;ab&#039;) as fp:
      fp.write(message)
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fopt%2Fgsutil%2Fgslib'>🔙 Back</a></p>