text: from __future__ import absolute_import
  from __future__ import unicode_literals
  
  from functools import reduce
  
  import six
  
  from .const import LABEL_CONTAINER_NUMBER
  from .const import LABEL_PROJECT
  from .const import LABEL_SERVICE
  
  
  class Container(object):
      """
      Represents a Docker container, constructed from the output of
      GET /containers/:id:/json.
      """
      def __init__(self, client, dictionary, has_been_inspected=False):
          self.client = client
          self.dictionary = dictionary
          self.has_been_inspected = has_been_inspected
          self.log_stream = None
  
      @classmethod
      def from_ps(cls, client, dictionary, **kwargs):
          """
          Construct a container object from the output of GET /containers/json.
          """
          name = get_container_name(dictionary)
          if name is None:
              return None
  
          new_dictionary = {
              'Id': dictionary['Id'],
              'Image': dictionary['Image'],
              'Name': '/' + name,
          }
          return cls(client, new_dictionary, **kwargs)
  
      @classmethod
      def from_id(cls, client, id):
          return cls(client, client.inspect_container(id), has_been_inspected=True)
  
      @classmethod
      def create(cls, client, **options):
          response = client.create_container(**options)
          return cls.from_id(client, response['Id'])
  
      @property
      def id(self):
          return self.dictionary['Id']
  
      @property
      def image(self):
          return self.dictionary['Image']
  
      @property
      def image_config(self):
          return self.client.inspect_image(self.image)
  
      @property
      def short_id(self):
          return self.id[:12]
  
      @property
      def name(self):
          return self.dictionary['Name'][1:]
  
      @property
      def service(self):
          return self.labels.get(LABEL_SERVICE)
  
      @property
      def name_without_project(self):
          project = self.labels.get(LABEL_PROJECT)
  
          if self.name.startswith('{0}_{1}'.format(project, self.service)):
              return '{0}_{1}'.format(self.service, self.number)
          else:
              return self.name
  
      @property
      def number(self):
          number = self.labels.get(LABEL_CONTAINER_NUMBER)
          if not number:
              raise ValueError("Container {0} does not have a {1} label".format(
                  self.short_id, LABEL_CONTAINER_NUMBER))
          return int(number)
  
      @property
      def ports(self):
          self.inspect_if_not_inspected()
          return self.get('NetworkSettings.Ports') or {}
  
      @property
      def human_readable_ports(self):
          def format_port(private, public):
              if not public:
                  return private
              return '{HostIp}:{HostPort}->{private}'.format(
                  private=private, **public[0])
  
          return ', '.join(format_port(*item)
                           for item in sorted(six.iteritems(self.ports)))
  
      @property
      def labels(self):
          return self.get('Config.Labels') or {}
  
      @property
      def stop_signal(self):
          return self.get('Config.StopSignal')
  
      @property
      def log_config(self):
          return self.get('HostConfig.LogConfig') or None
  
      @property
      def human_readable_state(self):
          if self.is_paused:
              return 'Paused'
          if self.is_restarting:
              return 'Restarting'
          if self.is_running:
              return 'Ghost' if self.get('State.Ghost') else 'Up'
          else:
              return 'Exit %s' % self.get('State.ExitCode')
  
      @property
      def human_readable_command(self):
          entrypoint = self.get('Config.Entrypoint') or []
          cmd = self.get('Config.Cmd') or []
          return ' '.join(entrypoint + cmd)
  
      @property
      def environment(self):
          def parse_env(var):
              if '=' in var:
                  return var.split("=", 1)
              return var, None
          return dict(parse_env(var) for var in self.get('Config.Env') or [])
  
      @property
      def exit_code(self):
          return self.get('State.ExitCode')
  
      @property
      def is_running(self):
          return self.get('State.Running')
  
      @property
      def is_restarting(self):
          return self.get('State.Restarting')
  
      @property
      def is_paused(self):
          return self.get('State.Paused')
  
      @property
      def log_driver(self):
          return self.get('HostConfig.LogConfig.Type')
  
      @property
      def has_api_logs(self):
          log_type = self.log_driver
          return not log_type or log_type != 'none'
  
      def attach_log_stream(self):
          """A log stream can only be attached if the container uses a json-file
          log driver.
          """
          if self.has_api_logs:
              self.log_stream = self.attach(stdout=True, stderr=True, stream=True)
  
      def get(self, key):
          """Return a value from the container or None if the value is not set.
  
          :param key: a string using dotted notation for nested dictionary
                      lookups
          """
          self.inspect_if_not_inspected()
  
          def get_value(dictionary, key):
              return (dictionary or {}).get(key)
  
          return reduce(get_value, key.split('.'), self.dictionary)
  
      def get_local_port(self, port, protocol='tcp'):
          port = self.ports.get("%s/%s" % (port, protocol))
          return "{HostIp}:{HostPort}".format(**port[0]) if port else None
  
      def get_mount(self, mount_dest):
          for mount in self.get('Mounts'):
              if mount['Destination'] == mount_dest:
                  return mount
          return None
  
      def start(self, **options):
          return self.client.start(self.id, **options)
  
      def stop(self, **options):
          return self.client.stop(self.id, **options)
  
      def pause(self, **options):
          return self.client.pause(self.id, **options)
  
      def unpause(self, **options):
          return self.client.unpause(self.id, **options)
  
      def kill(self, **options):
          return self.client.kill(self.id, **options)
  
      def restart(self, **options):
          return self.client.restart(self.id, **options)
  
      def remove(self, **options):
          return self.client.remove_container(self.id, **options)
  
      def create_exec(self, command, **options):
          return self.client.exec_create(self.id, command, **options)
  
      def start_exec(self, exec_id, **options):
          return self.client.exec_start(exec_id, **options)
  
      def rename_to_tmp_name(self):
          """Rename the container to a hopefully unique temporary container name
          by prepending the short id.
          """
          self.client.rename(
              self.id,
              '%s_%s' % (self.short_id, self.name)
          )
  
      def inspect_if_not_inspected(self):
          if not self.has_been_inspected:
              self.inspect()
  
      def wait(self):
          return self.client.wait(self.id)
  
      def logs(self, *args, **kwargs):
          return self.client.logs(self.id, *args, **kwargs)
  
      def inspect(self):
          self.dictionary = self.client.inspect_container(self.id)
          self.has_been_inspected = True
          return self.dictionary
  
      def attach(self, *args, **kwargs):
          return self.client.attach(self.id, *args, **kwargs)
  
      def __repr__(self):
          return '<Container: %s (%s)>' % (self.name, self.id[:6])
  
      def __eq__(self, other):
          if type(self) != type(other):
              return False
          return self.id == other.id
  
      def __hash__(self):
          return self.id.__hash__()
  
  
  def get_container_name(container):
      if not container.get('Name') and not container.get('Names'):
          return None
      # inspect
      if 'Name' in container:
          return container['Name']
      # ps
      shortest_name = min(container['Names'], key=lambda n: len(n.split('/')))
      return shortest_name.split('/')[-1]
  