Property for accessing :class:`ElasticAgentProfileManager` instance,
        which is used to manage elastic agent profiles.

        :rtype: yagocd.resources.elastic_profile.ElasticAgentProfileManager
170763
def elastic_profiles(self):
        
        if self._elastic_agent_profile_manager is None:
            self._elastic_agent_profile_manager = ElasticAgentProfileManager(session=self._session)
        return self._elastic_agent_profile_manager
1187410
def get_profile_form():
    
    from yacms.conf import settings
    try:
        return import_dotted_path(settings.ACCOUNTS_PROFILE_FORM_CLASS)
    except ImportError:
        raise ImproperlyConfigured("Value for ACCOUNTS_PROFILE_FORM_CLASS "
                                   "could not be imported: %s" %
                                   settings.ACCOUNTS_PROFILE_FORM_CLASS)
118459
def load(self, context):
    
    try:
      # pylint: disable=g-import-not-at-top,unused-import
      import tensorflow
      # Available in TensorFlow 1.14 or later, so do import check
      # pylint: disable=g-import-not-at-top,unused-import
      from tensorflow.python.eager import profiler_client
    except ImportError:
      return
    # pylint: disable=g-import-not-at-top
    from tensorboard.plugins.profile.profile_plugin import ProfilePlugin
    return ProfilePlugin(context)
612981
function() {
    // the attributes for multi-profile itself
    this.attr = trait({
      path: {
        value: this.path,
        type: {
          readOnly: true,
          setup: function(value) {
            if (!fs.isDir(value)) {
              fs.mkdir(value);
            }

            var profiles = this.profiles_file = node_path.join(value, 'profiles');
            var current = this.current_file = node_path.join(value, 'current_profile');

            profile.touchFile(profiles);
            profile.touchFile(current);
          }
        }
      },

      // get or set the names of profiles
      profiles: {
        type: {
          getter: function() {
            return fs.read(this.profiles_file).split(/[\r\n]+/).filter(Boolean);
          },

          setter: function(profiles) {
            fs.write(this.profiles_file, profiles.join('\n'));

            return profiles;
          }
        }
      },

      // get or set the name of the current profile
      current: {
        type: {
          getter: function() {
            return fs.read(this.current_file).trim() || null;
          },

          setter: function(v) {
            fs.write(this.current_file, v);

            return v;
          }
        }
      }
    }, {
      host: this
    });
  }
85728
def get_profile(name=None, **kwargs):
    
    if isinstance(name, Profile):
        return name

    clazz = get_profile_class(name or 'default')
    return clazz(**kwargs)
66579
def access(self, name: str, rename: Optional[str] = None) -> 'ProxyAttr':
        
        self.getter(name, rename)
        self.setter(name, rename)
        return self
975814
def lookup(self, profile, setting):
        
        for path in profiles():
            cfg = SafeConfigParser()
            cfg.read(path)
            if profile not in cfg.sections():
                continue
            if not cfg.has_option(profile, setting):
                continue
            return cfg.get(profile, setting)
920852
def __profile_definition(self, pipeline_name):
        
        pipe = self.flsh.Operations[pipeline_name]
        x_st = pipe.GetUserVariable(PROFILE_LENGTH_ST).Variable()
        x_non_st = pipe.GetUserVariable(PROFILE_LENGTH_NON_ST).Variable()
        timesteps = pipe.GetUserVariable(PROFILE_TIME).Variable()
        self.pipes[pipeline_name] = {'grid': x_st,
                                     'non_st_grid': x_non_st,
                                     'timesteps': timesteps,
                                     'data': {}
                                    }
        return pipe
274645
def get_profile_model():
    
    auth_profile_module = getattr(settings, 'AUTH_PROFILE_MODULE', None)
    profile_model = None
    if auth_profile_module:
        # get the profile model. TODO: super flacky, refactor
        app_label, model = auth_profile_module.split('.')
        profile_model = getattr(__import__("%s.models" % app_label, \
                globals(), locals(), [model, ], -1), model, None)

    return profile_model
1057121
def driver(self):
        

        if not self._driver:
            raise AttributeError("`driver` is not bound on this agent implementation({}). "
                                 "Do you forget to call `super().on_bind_driver` when you override the method "
                                 "`on_bind_driver` in your sub class?"
                                 .format(repr(self)))
        return self._driver
1292406
public ProfileManager createProfileManager(@NonNull Context context) {
        return new ProfileManager(context, client, new ObservableExecutor() {

            @Override
            public <T> void execute(final Observable<T> obs) {
                obs.subscribe(new Subscriber<T>() {
                            @Override
                            public void onCompleted() {
                                // Completed, will unsubscribe automatically
                            }

                            @Override
                            public void onError(Throwable e) {
                                // Report errors in doOnError
                            }

                            @Override
                            public void onNext(T t) {
                                // Ignore result
                            }
                        });
            }
        });
    }
196104
public CasServerProfile getProfile() {
        val profile = new CasServerProfile();
        profile.setRegisteredServiceTypesSupported(locateRegisteredServiceTypesSupported());
        profile.setRegisteredServiceTypes(locateRegisteredServiceTypesActive());
        profile.setMultifactorAuthenticationProviderTypesSupported(locateMultifactorAuthenticationProviderTypesSupported());
        profile.setMultifactorAuthenticationProviderTypes(locateMultifactorAuthenticationProviderTypesActive());
        profile.setDelegatedClientTypesSupported(locateDelegatedClientTypesSupported());
        profile.setDelegatedClientTypes(locateDelegatedClientTypes());
        profile.setAvailableAttributes(this.availableAttributes);
        return profile;
    }
518995
def find_agent(self, desc):
        ''''''
        agent_id = (desc.doc_id
                    if IDocument.providedBy(desc)
                    else desc)
        self.log("I'm trying to find the agent with id: %s", agent_id)
        result = first(x for x in self._agents
                       if x._descriptor.doc_id == agent_id)
        return defer.succeed(result)
154289
def manager(self, model):
        ''''''
        try:
            return self.router[model]
        except KeyError:
            meta = getattr(model, '_meta', model)
            if meta.type == 'structure':
                # this is a structure
                if hasattr(model, 'model'):
                    structure_model = model.model
                    if structure_model:
                        return self.manager(structure_model)
                    else:
                        manager = self.router.structure(model)
                        if manager:
                            return manager
            raise InvalidTransaction('"%s" not valid in this session' % meta)
682638
def profile(self, new_profile):
        
        if not isinstance(new_profile, FirefoxProfile):
            new_profile = FirefoxProfile(new_profile)
        self._profile = new_profile
578776
function () {
        var protocolProfileBehavior = extractProtocolProfileBehavior(this);

        // inherit protocolProfileBehavior from ItemGroup(s)
        this.forEachParent({ withRoot: true }, function (entity) {
            protocolProfileBehavior = Object.assign(extractProtocolProfileBehavior(entity), protocolProfileBehavior);
        });

        return protocolProfileBehavior;
    }
104533
def update_metadata_queue(self, agent: BaseAgent):
        
        pids = {os.getpid(), *agent.get_extra_pids()}

        helper_process_request = agent.get_helper_process_request()

        self.agent_metadata_queue.put(AgentMetadata(self.index, self.name, self.team, pids, helper_process_request))