Python payload.Payload类代码示例

class ManifestEntries(FingerprintedMixin):
  """Describes additional items to add to the app manifest."""

  class ExpectedDictionaryError(Exception):
    pass

  def __init__(self, entries=None):
    """
    :param entries: Additional headers, value pairs to add to the MANIFEST.MF.
      You can just add fixed string header / value pairs.
    :type entries: dictionary of string : string
    """
    self.payload = Payload()
    if entries:
      if not isinstance(entries, dict):
        raise self.ExpectedDictionaryError("entries must be a dictionary of strings.")
      for key in entries.keys():
        if not isinstance(key, string_types):
          raise self.ExpectedDictionaryError(
            "entries must be dictionary of strings, got key {} type {}"
            .format(key, type(key).__name__))
    self.payload.add_fields({
      'entries' : PrimitiveField(entries or {}),
      })

  def fingerprint(self):
    return self.payload.fingerprint()

  @property
  def entries(self):
    return self.payload.entries

 def __init__(self, sources, address=None, exports=None, **kwargs):
   payload = Payload()
   payload.add_field('sources', self.create_sources_field(sources,
                                                          sources_rel_path=address.spec_path,
                                                          key_arg='sources'))
   payload.add_field('exports', PrimitivesSetField(exports or []))
   super(SourcesTarget, self).__init__(address=address, payload=payload, **kwargs)

 def __init__(self, zip_url, rev='', **kwargs):
   """
   :param str zip_url:
     - Any URL from which a zipfile can be downloaded containing the source code of the
       remote library.
     - Can be a template string using variables {host}, {id}, {rev}.
       Example: "{host}/{id}/{rev}.zip"
         - {host} The host address to download zip files from. Specified by an option to
                  GoFetch, '--remote-lib-host'.
         - {id} The global import identifier of the library, which is specified by the path to
                the BUILD file relative to the source root of all 3rd party Go libraries.
                For example, If the 3rd party source root is "3rdparty/go", a target at
                "3rdparty/go/github.com/user/lib" would have an {id} of "github.com/user/lib".
         - {rev} See :param rev:
     - The zip file is expected to have zipped the library directory itself, and NOT the
       direct contents of the library.
         Expected: `zip -r mylib.zip mylib/`
              Not: `zip -r mylib.zip mylib/*`
   :param str rev: Identifies which version of the remote library to download.
                   This could be a commit SHA (git), node id (hg), etc.
   """
   payload = Payload()
   payload.add_fields({
     'rev': PrimitiveField(rev),
     'zip_url': PrimitiveField(zip_url)
   })
   super(GoRemoteLibrary, self).__init__(payload=payload, **kwargs)

 def __init__(self, prefixes=None, provides=None, *args, **kwargs):
   payload = Payload()
   payload.add_fields({
     'prefixes': prefixes,
     'provides': provides,
   })
   super(PomTarget, self).__init__(payload=payload, *args, **kwargs)

 def __init__(self, address, sources, copied=None, **kwargs):
   self.copied = copied
   payload = Payload()
   payload.add_fields({
     'sources': self.create_sources_field(sources, address.spec_path, key_arg='sources'),
   })
   super(DummyTargetBase, self).__init__(address=address, payload=payload, **kwargs)

 def __init__(self, distribution_fingerprint=None, *args, **kwargs):
  """Synthetic target that represents a resolved webpack distribution."""
  # Creating the synthetic target lets us avoid any special casing in regards to build order or cache invalidation.
  payload = Payload()
  payload.add_fields({
    'distribution_fingerprint': PrimitiveField(distribution_fingerprint),
  })
  super(WebPackDistribution, self).__init__(payload=payload, *args, **kwargs)

  def __init__(self, resolver, **kwargs):
    """
    :param str resolver: The `stack` resolver (i.e. "lts-3.1" or "nightly-2015-08-29")
    """

    self.resolver = resolver

    payload = Payload()
    payload.add_fields({
      'resolver': PrimitiveField(self.resolver),
    })
    super(HaskellProject, self).__init__(payload = payload, **kwargs)

    def __init__(self, apply_pattern, action):
        """Creates a rule for handling duplicate jar entries.

    :param string apply_pattern: A regular expression that matches duplicate jar entries this rule
      applies to.
    :param action: An action to take to handle one or more duplicate entries.  Must be one of:
      ``Duplicate.SKIP``, ``Duplicate.REPLACE``, ``Duplicate.CONCAT``, ``Duplicate.CONCAT_TEXT``,
      or ``Duplicate.FAIL``.
    """
        payload = Payload()
        payload.add_fields({"action": PrimitiveField(self.validate_action(action))})
        super(Duplicate, self).__init__(apply_pattern, payload=payload)

  def __init__(self, package=None, **kwargs):
    """
    :param str package: Optional name of the package (i.e. "network" or "containers").  Defaults to `name` if omitted
    """

    self.package  = package or kwargs['name']

    payload = Payload()
    payload.add_fields({
      'package': PrimitiveField(self.package),
    })
    super(HaskellStackagePackage, self).__init__(payload = payload, **kwargs)

  def __init__(self, version, package=None, **kwargs):
    """
    :param str version: The package version string (i.e. "0.4.3.0" or "1.0.0")
    :param str package: Optional name of the package (i.e. "network" or "containers").  Defaults to `name` if omitted
    """
    self.version = version
    self.package  = package or kwargs['name']

    payload = Payload()
    payload.add_fields({
      'version': PrimitiveField(self.version),
      'package': PrimitiveField(self.package),
    })
    super(HaskellHackagePackage, self).__init__(**kwargs)

 def __init__(self,
              libraries=None,
              *args,
              **kwargs):
   """
   :param libraries: Libraries that this target depends on that are not pants targets.
   For example, 'm' or 'rt' that are expected to be installed on the local system.
   :type libraries: List of libraries to link against.
   """
   payload = Payload()
   payload.add_fields({
     'libraries': PrimitiveField(libraries)
   })
   super(CppBinary, self).__init__(payload=payload, **kwargs)

 def __init__(self,
              binary=None,
              handler=None,
              **kwargs):
   """
   :param string binary: Target spec of the ``python_binary`` that contains the handler.
   :param string handler: Lambda handler entrypoint (module.dotted.name:handler_func).
   """
   payload = Payload()
   payload.add_fields({
     'binary': PrimitiveField(binary),
     'handler': PrimitiveField(handler),
   })
   super(PythonAWSLambda, self).__init__(payload=payload, **kwargs)

  def __init__(self, package=None, path=None, **kwargs):
    """
    :param str package: Optional name of the package (i.e. "network" or "containers").  Defaults to `name` if omitted
    :param str path: Optional path to a remote source archive in TAR or ZIP format.
    """

    self.package = package or kwargs['name']
    self.path = path

    payload = Payload()
    payload.add_fields({
      'package': PrimitiveField(self.package),
      'path': PrimitiveField(self.path),
    })
    super(HaskellSourcePackage, self).__init__(payload = payload, **kwargs)

 def payload_for_scope(self, scope):
   """Returns a payload representing the options for the given scope."""
   payload = Payload()
   for (name, _, kwargs) in self.registration_args_iter_for_scope(scope):
     if not kwargs.get('fingerprint', False):
       continue
     val = self.for_scope(scope)[name]
     val_type = kwargs.get('type', '')
     if val_type == Options.file:
       field = FileField(val)
     elif val_type == Options.target_list:
       field = TargetListField(val)
     else:
       field = PrimitiveField(val)
     payload.add_field(name, field)
   payload.freeze()
   return payload

  def __init__(self, address, payload=None, sources=None, ctypes_native_library=None,
               strict_deps=None, fatal_warnings=None, **kwargs):

    if not payload:
      payload = Payload()
    sources_field = self.create_sources_field(sources, address.spec_path, key_arg='sources')
    payload.add_fields({
      'sources': sources_field,
      'ctypes_native_library': ctypes_native_library,
      'strict_deps': PrimitiveField(strict_deps),
      'fatal_warnings': PrimitiveField(fatal_warnings),
    })

    if ctypes_native_library and not isinstance(ctypes_native_library, NativeArtifact):
      raise TargetDefinitionException(
        "Target must provide a valid pants '{}' object. Received an object with type '{}' "
        "and value: {}."
        .format(NativeArtifact.alias(), type(ctypes_native_library).__name__, ctypes_native_library))

    super(NativeLibrary, self).__init__(address=address, payload=payload, **kwargs)