Python cache_setup.CacheSetup类代码示例

 def mk_cache(spec):
   Subsystem.reset()
   self.set_options_for_scope(CacheSetup.subscope(DummyTask.options_scope),
                              read_from=spec, compression=1)
   self.context(for_task_types=[DummyTask])  # Force option initialization.
   cache_factory = CacheSetup.create_cache_factory_for_task(DummyTask)
   return cache_factory.get_read_cache()

  def __init__(self, context, workdir):
    """Subclass __init__ methods, if defined, *must* follow this idiom:

    class MyTask(Task):
      def __init__(self, *args, **kwargs):
        super(MyTask, self).__init__(*args, **kwargs)
        ...

    This allows us to change Task.__init__()'s arguments without
    changing every subclass. If the subclass does not need its own
    initialization, this method can (and should) be omitted entirely.

    :API: public
    """
    super(TaskBase, self).__init__()
    self.context = context
    self._workdir = workdir

    self._cache_key_errors = set()

    self._build_invalidator_dir = os.path.join(
      self.context.options.for_global_scope().pants_workdir,
      'build_invalidator',
      self.stable_name())

    self._cache_factory = CacheSetup.create_cache_factory_for_task(self)

    self._options_fingerprinter = OptionsFingerprinter(self.context.build_graph)

    def __init__(self, context, workdir):
        """Subclass __init__ methods, if defined, *must* follow this idiom:

    class MyTask(Task):
      def __init__(self, *args, **kwargs):
        super(MyTask, self).__init__(*args, **kwargs)
        ...

    This allows us to change Task.__init__()'s arguments without
    changing every subclass. If the subclass does not need its own
    initialization, this method can (and should) be omitted entirely.
    """
        super(TaskBase, self).__init__()
        self.context = context
        self._workdir = workdir
        # TODO: It would be nice to use self.get_options().cache_key_gen_version here, because then
        # we could have a separate value for each scope if we really wanted to. However we can't
        # access per-task options in Task.__init__ because GroupTask.__init__ calls it with the
        # group task's scope, which isn't currently in the known scopes we generate options for.
        self._cache_key_generator = CacheKeyGenerator(self.context.options.for_global_scope().cache_key_gen_version)

        self._cache_key_errors = set()

        self._build_invalidator_dir = os.path.join(
            self.context.options.for_global_scope().pants_workdir, "build_invalidator", self.stable_name()
        )

        self._cache_factory = CacheSetup.create_cache_factory_for_task(self)

 def subsystem_dependencies(cls):
   # NB: `Goal.Options` implements `SubsystemClientMixin` in order to allow v1 `Tasks` to
   # depend on v2 Goals, and for `Goals` to declare a deprecated dependency on a `CacheSetup`
   # instance for backwards compatibility purposes. But v2 Goals should _not_ have subsystem
   # dependencies: instead, the @rules participating (transitively) in a Goal should directly
   # declare their Subsystem deps.
   if outer_cls.deprecated_cache_setup_removal_version:
     dep = CacheSetup.scoped(
         cls,
         removal_version=outer_cls.deprecated_cache_setup_removal_version,
         removal_hint='Goal `{}` uses an independent caching implementation, and ignores `{}`.'.format(
           cls.options_scope,
           CacheSetup.subscope(cls.options_scope),
         )
       )
     return (dep,)
   return tuple()

  def __init__(self, context, workdir):
    """Subclass __init__ methods, if defined, *must* follow this idiom:

    class MyTask(Task):
      def __init__(self, *args, **kwargs):
        super(MyTask, self).__init__(*args, **kwargs)
        ...

    This allows us to change Task.__init__()'s arguments without
    changing every subclass. If the subclass does not need its own
    initialization, this method can (and should) be omitted entirely.

    :API: public
    """
    super(TaskBase, self).__init__()
    self.context = context
    self._workdir = workdir

    self._task_name = type(self).__name__
    self._cache_key_errors = set()
    self._cache_factory = CacheSetup.create_cache_factory_for_task(self)
    self._force_invalidated = False

 def subsystem_dependencies(cls):
   return super(TaskBase, cls).subsystem_dependencies() + (CacheSetup.scoped(cls),)

 def subsystem_dependencies(cls):
   return (super(TaskBase, cls).subsystem_dependencies() +
           (CacheSetup.scoped(cls), BuildInvalidator.Factory, SourceRootConfig) +
           ((TargetFilter.scoped(cls),) if cls.target_filtering_enabled else tuple()))

 def subsystem_dependencies(cls):
   return (super(TaskBase, cls).subsystem_dependencies() +
           (CacheSetup.scoped(cls), BuildInvalidator.Factory, SourceRootConfig))

 def subsystem_dependencies(cls):
   return super(TaskBase, cls).subsystem_dependencies() + (CacheSetup.scoped(cls),
                                                           BuildInvalidator.Factory)