text: # -*- coding: utf-8 -*-
  from __future__ import absolute_import, division, print_function, unicode_literals
  
  from functools import partial
  import os
  from os import lstat
  from importlib import import_module
  
  from pkg_resources import parse_version
  
  from conda import __version__ as CONDA_VERSION
  
  
  def try_exports(module, attr):
      # this assumes conda.exports exists, so only use for conda 4.3 onward
      try:
          return getattr(import_module('conda.exports'), attr)
      except AttributeError:
          return getattr(import_module(module), attr)
  
  
  try:
      # This monkey patch is addressed at #1825. The ensure_use_local is an outdated vestige
      #   and no longer has any relevant effect.
      import conda.cli.common
      conda.cli.common.ensure_use_local = lambda x: None
  except ImportError:
      # no need to patch if it doesn't exist
      pass
  
  conda_43 = parse_version(CONDA_VERSION) >= parse_version("4.3.0a0")
  conda_44 = parse_version(CONDA_VERSION) >= parse_version("4.4.0a0")
  conda_45 = parse_version(CONDA_VERSION) >= parse_version("4.5.0a0")
  conda_46 = parse_version(CONDA_VERSION) >= parse_version("4.6.0a0")
  conda_47 = parse_version(CONDA_VERSION) >= parse_version("4.7.0a0")
  conda_48 = parse_version(CONDA_VERSION) >= parse_version("4.8.0a0")
  
  if conda_44:
      from conda.exports import display_actions, execute_actions, execute_plan, install_actions
  else:
      from conda.plan import display_actions, execute_actions, execute_plan, install_actions
  
  display_actions, execute_actions, execute_plan = display_actions, execute_actions, execute_plan
  install_actions = install_actions
  
  try:
      # Conda 4.4+
      from conda.exports import _toposort
  except ImportError:
      from conda.toposort import _toposort
  _toposort = _toposort
  
  from conda.exports import TmpDownload, download, handle_proxy_407  # NOQA
  from conda.exports import untracked, walk_prefix  # NOQA
  from conda.exports import MatchSpec, NoPackagesFound, Resolve, Unsatisfiable, normalized_version  # NOQA
  from conda.exports import human_bytes, hashsum_file, md5_file, memoized, unix_path_to_win, win_path_to_unix, url_path  # NOQA
  from conda.exports import get_index  # NOQA
  from conda.exports import (Completer, InstalledPackages, add_parser_channels,  # NOQA
                             add_parser_prefix,  # NOQA
                             specs_from_args, spec_from_line, specs_from_url)  # NOQA
  from conda.exports import ArgumentParser  # NOQA
  from conda.exports import (is_linked, linked, linked_data, prefix_placeholder,  # NOQA
                             rm_rf, symlink_conda, package_cache)  # NOQA
  from conda.exports import CondaSession  # NOQA
  from conda.exports import (PY3,  StringIO, input, iteritems, lchmod, string_types,  # NOQA
                            text_type, TemporaryDirectory)  # NOQA
  from conda.exports import VersionOrder  # NOQA
  
  
  TmpDownload = TmpDownload
  download, handle_proxy_407, untracked, walk_prefix = download, handle_proxy_407, untracked, walk_prefix  # NOQA
  MatchSpec, Resolve, normalized_version = MatchSpec, Resolve, normalized_version
  human_bytes, hashsum_file, md5_file, memoized = human_bytes, hashsum_file, md5_file, memoized
  unix_path_to_win, win_path_to_unix, url_path = unix_path_to_win, win_path_to_unix, url_path
  get_index, Completer, InstalledPackages = get_index, Completer, InstalledPackages
  add_parser_channels, add_parser_prefix = add_parser_channels, add_parser_prefix
  specs_from_args, spec_from_line, specs_from_url = specs_from_args, spec_from_line, specs_from_url
  is_linked, linked, linked_data, prefix_placeholder = is_linked, linked, linked_data, prefix_placeholder # NOQA
  rm_rf, symlink_conda, package_cache = rm_rf, symlink_conda, package_cache
  PY3, input, iteritems, lchmod, string_types = PY3, input, iteritems, lchmod, string_types
  text_type, TemporaryDirectory = text_type, TemporaryDirectory
  ArgumentParser, CondaSession, VersionOrder = ArgumentParser, CondaSession, VersionOrder
  
  
  from conda.core.package_cache import ProgressiveFetchExtract  # NOQA
  from conda.models.dist import Dist, IndexRecord  # NOQA
  
  ProgressiveFetchExtract = ProgressiveFetchExtract
  Dist, IndexRecord = Dist, IndexRecord
  
  if PY3:
      import configparser  # NOQA
  else:
      import ConfigParser as configparser  # NOQA
  configparser = configparser
  
  
  from conda.exports import FileMode, PathType  # NOQA
  FileMode, PathType = FileMode, PathType
  from conda.exports import EntityEncoder  # NOQA
  
  EntityEncoder, FileMode, PathType = EntityEncoder, FileMode, PathType
  
  
  CondaError = try_exports("conda.exceptions", "CondaError")
  CondaHTTPError = try_exports("conda.exceptions", "CondaHTTPError")
  LinkError = try_exports("conda.exceptions", "LinkError")
  LockError = try_exports("conda.exceptions", "LockError")
  NoPackagesFoundError = try_exports("conda.exceptions", "NoPackagesFoundError")
  PaddingError = try_exports("conda.exceptions", "PaddingError")
  UnsatisfiableError = try_exports("conda.exceptions", "UnsatisfiableError")
  
  non_x86_linux_machines = try_exports("conda.base.context", "non_x86_linux_machines")
  context = try_exports("conda.base.context", "context")
  context_get_prefix = try_exports("conda.base.context", "get_prefix")
  reset_context = try_exports("conda.base.context", "reset_context")
  get_conda_build_local_url = try_exports("conda.models.channel", "get_conda_build_local_url")
  
  binstar_upload = context.binstar_upload
  bits = context.bits
  conda_private = context.conda_private
  default_python = context.default_python
  envs_dirs = context.envs_dirs
  pkgs_dirs = list(context.pkgs_dirs)
  cc_platform = context.platform
  root_dir = context.root_dir
  root_writable = context.root_writable
  subdir = context.subdir
  create_default_packages = context.create_default_packages
  
  get_rc_urls = lambda: list(context.channels)
  get_prefix = partial(context_get_prefix, context)
  cc_conda_build = context.conda_build if hasattr(context, 'conda_build') else {}
  
  try:
      from conda.exports import Channel
  except:
      from conda.models.channel import Channel
  get_conda_channel = Channel.from_value
  
  # disallow softlinks.  This avoids a lot of dumb issues, at the potential cost of disk space.
  os.environ[str('CONDA_ALLOW_SOFTLINKS')] = str('false')
  reset_context()
  
  get_local_urls = lambda: list(get_conda_build_local_url()) or []
  arch_name = context.arch_name
  
  
  CondaError, CondaHTTPError, get_prefix, LinkError = CondaError, CondaHTTPError, get_prefix, LinkError  # NOQA
  LockError, non_x86_linux_machines, NoPackagesFoundError = LockError, non_x86_linux_machines, NoPackagesFoundError  # NOQA
  PaddingError, UnsatisfiableError = PaddingError, UnsatisfiableError
  
  
  # work-around for python bug on Windows prior to python 3.2
  # https://bugs.python.org/issue10027
  # Adapted from the ntfsutils package, Copyright (c) 2012, the Mozilla Foundation
  class CrossPlatformStLink(object):
      _st_nlink = None
  
      def __call__(self, path):
          return self.st_nlink(path)
  
      @classmethod
      def st_nlink(cls, path):
          if cls._st_nlink is None:
              cls._initialize()
          return cls._st_nlink(path)
  
      @classmethod
      def _standard_st_nlink(cls, path):
          return lstat(path).st_nlink
  
      @classmethod
      def _windows_st_nlink(cls, path):
          st_nlink = cls._standard_st_nlink(path)
          if st_nlink != 0:
              return st_nlink
          else:
              # cannot trust python on Windows when st_nlink == 0
              # get value using windows libraries to be sure of its true value
              # Adapted from the ntfsutils package, Copyright (c) 2012, the Mozilla Foundation
              GENERIC_READ = 0x80000000
              FILE_SHARE_READ = 0x00000001
              OPEN_EXISTING = 3
              hfile = cls.CreateFile(path, GENERIC_READ, FILE_SHARE_READ, None,
                                     OPEN_EXISTING, 0, None)
              if hfile is None:
                  from ctypes import WinError
                  raise WinError(
                      "Could not determine determine number of hardlinks for %s" % path)
              info = cls.BY_HANDLE_FILE_INFORMATION()
              rv = cls.GetFileInformationByHandle(hfile, info)
              cls.CloseHandle(hfile)
              if rv == 0:
                  from ctypes import WinError
                  raise WinError("Could not determine file information for %s" % path)
              return info.nNumberOfLinks
  
      @classmethod
      def _initialize(cls):
          if os.name != 'nt':
              cls._st_nlink = cls._standard_st_nlink
          else:
              # http://msdn.microsoft.com/en-us/library/windows/desktop/aa363858
              import ctypes
              from ctypes import POINTER
              from ctypes.wintypes import DWORD, HANDLE, BOOL
  
              cls.CreateFile = ctypes.windll.kernel32.CreateFileW
              cls.CreateFile.argtypes = [ctypes.c_wchar_p, DWORD, DWORD, ctypes.c_void_p,
                                         DWORD, DWORD, HANDLE]
              cls.CreateFile.restype = HANDLE
  
              # http://msdn.microsoft.com/en-us/library/windows/desktop/ms724211
              cls.CloseHandle = ctypes.windll.kernel32.CloseHandle
              cls.CloseHandle.argtypes = [HANDLE]
              cls.CloseHandle.restype = BOOL
  
              class FILETIME(ctypes.Structure):
                  _fields_ = [("dwLowDateTime", DWORD),
                              ("dwHighDateTime", DWORD)]
  
              class BY_HANDLE_FILE_INFORMATION(ctypes.Structure):
                  _fields_ = [("dwFileAttributes", DWORD),
                              ("ftCreationTime", FILETIME),
                              ("ftLastAccessTime", FILETIME),
                              ("ftLastWriteTime", FILETIME),
                              ("dwVolumeSerialNumber", DWORD),
                              ("nFileSizeHigh", DWORD),
                              ("nFileSizeLow", DWORD),
                              ("nNumberOfLinks", DWORD),
                              ("nFileIndexHigh", DWORD),
                              ("nFileIndexLow", DWORD)]
  
              cls.BY_HANDLE_FILE_INFORMATION = BY_HANDLE_FILE_INFORMATION
  
              # http://msdn.microsoft.com/en-us/library/windows/desktop/aa364952
              cls.GetFileInformationByHandle = ctypes.windll.kernel32.GetFileInformationByHandle
              cls.GetFileInformationByHandle.argtypes = [HANDLE,
                                                         POINTER(BY_HANDLE_FILE_INFORMATION)]
              cls.GetFileInformationByHandle.restype = BOOL
  
              cls._st_nlink = cls._windows_st_nlink
  
  
  class SignatureError(Exception):
      pass
  
  
  def which_package(path):
      """
      given the path (of a (presumably) conda installed file) iterate over
      the conda packages the file came from.  Usually the iteration yields
      only one package.
      """
      from os.path import abspath, join
      path = abspath(path)
      prefix = which_prefix(path)
      if prefix is None:
          raise RuntimeError("could not determine conda prefix from: %s" % path)
      for dist in linked(prefix):
          meta = is_linked(prefix, dist)
          if any(abspath(join(prefix, f)) == path for f in meta['files']):
              yield dist
  
  
  def which_prefix(path):
      """
      given the path (to a (presumably) conda installed file) return the
      environment prefix in which the file in located
      """
      from os.path import abspath, join, isdir, dirname
      prefix = abspath(path)
      iteration = 0
      while iteration < 20:
          if isdir(join(prefix, 'conda-meta')):
              # we found the it, so let's return it
              break
          if prefix == dirname(prefix):
              # we cannot chop off any more directories, so we didn't find it
              prefix = None
              break
          prefix = dirname(prefix)
          iteration += 1
      return prefix
  
  
  def get_installed_version(prefix, pkgs):
      """Primarily used by conda-forge, but may be useful in general for checking when a package
      needs to be updated"""
      from conda_build.utils import ensure_list
      pkgs = ensure_list(pkgs)
      linked_pkgs = linked(prefix)
      versions = {}
      for pkg in pkgs:
          vers_inst = [dist.split('::', 1)[-1].rsplit('-', 2)[1] for dist in linked_pkgs
              if dist.split('::', 1)[-1].rsplit('-', 2)[0] == pkg]
          versions[pkg] = vers_inst[0] if len(vers_inst) == 1 else None
      return versions
  
  
  # when deactivating envs (e.g. switching from root to build/test) this env var is used,
  # except the PR that removed this has been reverted (for now) and Windows doesnt need it.
  env_path_backup_var_exists = os.environ.get('CONDA_PATH_BACKUP', None)
  