Adds a scheduled operation to the schedule.

        Args:
            scheduled_operation: The operation to add.

        Raises:
            ValueError:
                The operation collided with something already in the schedule.
961725
def include(self, scheduled_operation: ScheduledOperation):
        
        collisions = self.query(time=scheduled_operation.time,
                                duration=scheduled_operation.duration,
                                qubits=scheduled_operation.operation.qubits)
        if collisions:
            raise ValueError('Operation {} has collisions: {}'.format(
                scheduled_operation.operation, collisions))
        self.scheduled_operations.add(scheduled_operation)
        self._max_duration = max(self._max_duration,
                                 scheduled_operation.duration)
542177
def update_recurring(self, recurring_id, recurring_dict):
        
        return self._create_put_request(resource=RECURRINGS, billomat_id=recurring_id, send_data=recurring_dict)
1251681
def perform(task_params, scheduled_time)
      @task = Task.new(task_params)
      @scheduled_time = Time.at(scheduled_time).in_time_zone(@task.time_zone)
      raise Expired if expired?

      queue_task
    end
1144742
def create_task(self, *command_tokens, **command_env):
		
		return self.__scheduled_task_cls(self.basic_command(), *command_tokens, **command_env)
1110491
def run(self, scheduler_schedule_id, **kwargs):
        
        log = self.get_logger(**kwargs)

        self.scheduler.update_schedule(scheduler_schedule_id, {"active": False})
        log.info(
            "Deactivated schedule %s in the scheduler service", scheduler_schedule_id
        )
1117850
def call_operation(self, operation, **kwargs):
        
        data = {'operation': operation}
        data.update(kwargs)
        return self.invoke(data)
478672
@Reference(service = ScheduledEventService.class,
               cardinality = ReferenceCardinality.MANDATORY)
    protected void setScheduledEventService(ScheduledEventService ref) {
        this.scheduler = ref;
    }
1023169
def _wrap(self, meth, *args, **kwargs):
        
        if not self.connected:
            return self._connectSchedule(self._wrap, meth, *args, **kwargs)

        opres = meth(self, *args, **kwargs)
        return self.defer(opres)
1289767
def _expand_scheduledict(scheduledict):
    """"""
    result = []
    def f(d):
        nonlocal result
        #print(d)
        d2 = {}
        for k,v in d.items():
            if isinstance(v, str) and _cronslash(v, k) is not None:
                d[k] = _cronslash(v, k)

        for k,v in d.items():
            if isinstance(v, Iterable):
                continue
            else:
                d2[k] = v

        if len(d2.keys()) == len(d.keys()):
            result.append(d2)
            return

        for k,v in d.items():
            if isinstance(v, Iterable):
                for i in v:
                    dprime = dict(**d)
                    dprime[k] = i
                    f(dprime)
                break
    f(scheduledict)
    return result
1195639
def schedule(identifier, **kwargs):
    ''''''
    source = actions.schedule(identifier, **kwargs)
    msg = 'Scheduled {source.name} with the following crontab: {cron}'
    log.info(msg.format(source=source, cron=source.periodic_task.crontab))
1230578
def set_next_operation(self, next_operation_description, next_operations_weight):
        
        if not isinstance(next_operation_description, basestring):
            raise TypeError("next_operation_description can only be an instance of type basestring")
        if not isinstance(next_operations_weight, baseinteger):
            raise TypeError("next_operations_weight can only be an instance of type baseinteger")
        self._call("setNextOperation",
                     in_p=[next_operation_description, next_operations_weight])
752982
def add_cron(self, name, minute, hour, mday, month, wday, who, command, env=None):
        
        raise NotImplementedError
619697
def schedule_saved(sender, instance, **kwargs):
    
    from contentstore.tasks import sync_schedule

    sync_schedule.delay(str(instance.id))
521739
def advance_operation_time(self, operation_time):
        
        if not isinstance(operation_time, Timestamp):
            raise TypeError("operation_time must be an instance "
                            "of bson.timestamp.Timestamp")
        self._advance_operation_time(operation_time)
1079051
def add_service(self, service):
        
        if (self.service is None):
            self.service = service
        elif (isinstance(self.service, dict)):
            self.service = [self.service, service]
        else:
            self.service.append(service)
1409
def add_job(opts={})
      @jobs << Job.new( Parser::Schedule.new(opts[:schedule]), Parser::Command.new(opts[:command]))
    end
825535
def schedule(self, seconds: float):
        
        def wrap(func: Callable):
            self._schedules.append(Scheduler(self.app, seconds, func))
        return wrap