Called to kick off the episode - should be no need for subclasses to override.
545791
public void start() {
        this.isLive = true; // This episode is now active.
        try {
            execute();
        } catch (Exception e) {
            System.out.println("State start - exception: " + e);
            e.printStackTrace();
            // TODO... what?
        }
    }
288367
def on_episode_end(self, episode, logs):
         
        duration = timeit.default_timer() - self.starts[episode]

        metrics = self.metrics[episode]
        if np.isnan(metrics).all():
            mean_metrics = np.array([np.nan for _ in self.metrics_names])
        else:
            mean_metrics = np.nanmean(metrics, axis=0)
        assert len(mean_metrics) == len(self.metrics_names)

        data = list(zip(self.metrics_names, mean_metrics))
        data += list(logs.items())
        data += [('episode', episode), ('duration', duration)]
        for key, value in data:
            if key not in self.data:
                self.data[key] = []
            self.data[key].append(value)

        if self.interval is not None and episode % self.interval == 0:
            self.save_data()

        # Clean up.
        del self.metrics[episode]
        del self.starts[episode]
1034124
def _run_atstart():
    ''''''
    global _atstart
    for callback, args, kwargs in _atstart:
        callback(*args, **kwargs)
    del _atstart[:]
636996
def start(self, *args, **kwargs):#pylint:disable=unused-argument
        
        restart = kwargs.get('restart', True)
        return self.run(restart)
560058
def init_and_start(self, taskParent, override={}):
        
        tag = self.initialize(taskParent, override=override)
        self.start()

        return tag
46951
private void startAnimation() {
        initAnimation();
        sAnimations.get().add(this);
        if (mStartDelay > 0 && mListeners != null) {
            // Listeners were already notified in start() if startDelay is 0; this is
            // just for delayed animations
            ArrayList<AnimatorListener> tmpListeners =
                    (ArrayList<AnimatorListener>) mListeners.clone();
            int numListeners = tmpListeners.size();
            for (int i = 0; i < numListeners; ++i) {
                tmpListeners.get(i).onAnimationStart(this);
            }
        }
    }
1357627
def on_episode_begin(self, episode, logs={}):
        
        for callback in self.callbacks:
            # Check if callback supports the more appropriate `on_episode_begin` callback.
            # If not, fall back to `on_epoch_begin` to be compatible with built-in Keras callbacks.
            if callable(getattr(callback, 'on_episode_begin', None)):
                callback.on_episode_begin(episode, logs=logs)
            else:
                callback.on_epoch_begin(episode, logs=logs)
1057530
def start(self, initial_delay=0):
        
        if self.listener is None:
            raise exceptions.NoAsyncListenerError
        elif self._enabled:
            return

        self._enabled = True
595102
def start(self):
        
        self.thread = threading.Thread(target=self._animate)
        self.thread.start()
        return
500968
void removeSuperToast(final SuperToast superToast) {
        // If the SuperToast is a SuperActivityToast, remove it from the supplied ViewGroup
        if (superToast instanceof SuperActivityToast) {
            // If SuperActivityToast has already been dismissed, do not attempt to dismiss it again
            if (!superToast.isShowing()) {
                this.superToastPriorityQueue.remove(superToast);
                return;
            }

            final Animator animator = AnimationUtils.getHideAnimation(
                    (SuperActivityToast) superToast);
            animator.addListener(new Animator.AnimatorListener() {

                @Override
                public void onAnimationStart(Animator animation) {
                    // Do nothing
                }

                @Override
                public void onAnimationEnd(Animator animation) {
                    if (superToast.getOnDismissListener() != null) {
                        superToast.getOnDismissListener().onDismiss(superToast.getView(),
                                superToast.getStyle().dismissToken);
                    }

                    ((SuperActivityToast) superToast).getViewGroup().removeView(superToast.getView());

                    // Show the next SuperToast if any exist
                    Toaster.this.showNextSuperToast();
                }

                @Override
                public void onAnimationCancel(Animator animation) {
                    // Do nothing
                }

                @Override
                public void onAnimationRepeat(Animator animation) {
                    // Do nothing
                }
            });
            animator.start();

        // If the SuperToast is NOT a SuperActivityToast, remove it from the WindowManager
        } else {
            final WindowManager windowManager = (WindowManager) superToast.getContext()
                    .getSystemService(Context.WINDOW_SERVICE);

            // If the WindowManager is null, the SuperToast will linger indefinitely
            if (windowManager == null) throw new IllegalStateException(ERROR_ST_WINDOWMANAGER_NULL);

            try {
                windowManager.removeView(superToast.getView());
            } catch (IllegalArgumentException illegalArgumentException) {
                Log.e(getClass().getName(), illegalArgumentException.toString());
            }

            if (superToast.getOnDismissListener() != null) {
                superToast.getOnDismissListener().onDismiss(superToast.getView(),
                        superToast.getStyle().dismissToken);
            }

            // Show the next SuperToast in the queue if any exist after the hide duration
            this.sendDelayedMessage(superToast, Messages.SHOW_NEXT, AnimationUtils.HIDE_DURATION);
        }

        superToastPriorityQueue.poll();
    }
328033
void endIfStarted(CodeAttribute b, ClassMethod method) {
        b.aload(getLocalVariableIndex(0));
        b.dup();
        final BranchEnd ifnotnull = b.ifnull();
        b.checkcast(Stack.class);
        b.invokevirtual(Stack.class.getName(), END_INTERCEPTOR_CONTEXT_METHOD_NAME, EMPTY_PARENTHESES + VOID_CLASS_DESCRIPTOR);
        BranchEnd ifnull = b.gotoInstruction();
        b.branchEnd(ifnotnull);
        b.pop(); // remove null Stack
        b.branchEnd(ifnull);
    }
654056
public OmdbBuilder setTypeEpisode() {
        if (!ResultType.isDefault(ResultType.EPISODE)) {
            params.add(Param.RESULT, ResultType.EPISODE);
        }
        return this;
    }
496280
def start(self, duration=None):
        
        if duration is None:
            duration = self.duration

        self.set(duration)
579626
def run(self) -> None:
        ''''''

        with self.context.assertRaises(self.error.__class__) as error:
            super().run()

        self.exception = error.exception
1251581
def cancel(self):
        """"""
        if self.channel_open:
            try:
                self.backend.cancel(self.consumer_tag)
            except KeyError:
                pass
194539
function() {
        if (!(this instanceof clazz)) {
          throw new Error("Use new keyword to create a new instance or call/apply class with right scope");
        }
        Class.onBeforeInstantiation && Class.onBeforeInstantiation(this);
        
        // remember the current super property
        var temp = this.__super__;
        // set the right super class prototype
        this.__super__ = superClass;

        // call the right constructor
        if (constructor) {
          constructor.apply(this, arguments);
        } else if (superClass) {
          superClass.apply(this, arguments);
        }
        // reset the current super property
        this.__super__ = temp;
        Class.onAfterInstantiation && Class.onAfterInstantiation(this);
      }
914264
def cancel(self):
        """"""
        if self.started and not self.connected and not self.timedout:
            self.connect_watcher.stop()
            self.timeout_watcher.stop()