This message informs about the currently active SCRIPT.

                seq                       : Active Sequence (uint16_t)
321817
def script_current_send(self, seq, force_mavlink1=False):
                '''
                

                '''
                return self.send(self.script_current_encode(seq), force_mavlink1=force_mavlink1)
91127
def detect_right_script(st, script)
      Log.debug  "[#{Chimp.get_job_uuid}] Looking for rightscript"
      executable = nil
      # In the event that chimpd find @op_scripts as nil, set it as an array.
      if @op_scripts.nil?
        @op_scripts = []
      end
      if st.nil?
        return executable
      end

      # Take the sts and extract all operational scripts
      @op_scripts = extract_operational_scripts(st)

      # if script is empty, we will list all common scripts
      # if not empty, we will list the first matching one
      if @script == "" and @script != nil
        # list all operational scripts
        reduce_to_common_scripts(st.size)

        script_id = list_and_select_op_script

        # Provide the name + href
        s = Executable.new
        s.params['right_script']['href'] = @op_scripts[script_id][1].right_script.href
        s.params['right_script']['name'] = @op_scripts[script_id][0]
        @script_to_run = s
      else
        # Try to find the rightscript in our list of common operational scripts
        @op_scripts.each  do |rb|
          script_name = rb[0]
          if script_name.downcase.include?(script.downcase)
            # We only need the name and the href
            s = Executable.new
            s.params['right_script']['href'] = rb[1].right_script.href
            s.params['right_script']['name'] = script_name
            @script_to_run = s

            Log.debug "[#{Chimp.get_job_uuid}] Found rightscript"
            return @script_to_run
          end
        end
        #
        # If we reach here it means we didnt find the script in the operationals
        #
        if @script_to_run == nil
          # Search outside common op scripts
          search_for_script_in_sts(script, st)
          if @script_to_run.nil?
            if @interactive
              puts "ERROR: Sorry, didnt find that ( "+script+" ), provide an URI instead"
              puts "I searched in:"
              st.each { |s|
                puts "   *  "+s[1]['name']+"  [Rev"+s[1]['version'].to_s+"]"
              }
              if not @ignore_errors
                exit 1
              end
            else
              Log.error "["+self.job_uuid+"] Sorry, didnt find the script: ( "+script+" )!"
              return nil
            end
          else
            if self.job_uuid.nil?
              self.job_uuid = ""
            end
            Log.warn "["+self.job_uuid+"] \"#{@script_to_run.params['right_script']['name']}\" is not a common operational script!"
            return @script_to_run
          end
        end
      end
    end
394493
def sequence_type(seq):
    '''

    '''
    if isinstance(seq, coral.DNA):
        material = 'dna'
    elif isinstance(seq, coral.RNA):
        material = 'rna'
    elif isinstance(seq, coral.Peptide):
        material = 'peptide'
    else:
        raise ValueError('Input was not a recognized coral.sequence object.')
    return material
145356
def publish_active_scene(self, scene_id):
        """"""
        self.sequence_number += 1
        self.publisher.send_multipart(msgs.MessageBuilder.scene_active(self.sequence_number, scene_id))
        return self.sequence_number
916698
private int uint16FromData(int offset) {
        return twoBytesToInt(
                Arrays.copyOfRange(data(), offset, offset + 2),
                Constants.CC2540_BYTE_ORDER
        );
    }
775770
function readNotifyMpnSubscriptionActivation(message, tokens) {
	message.userName = protocol.decodeString(tokens[1]);
	message.sessionId = protocol.decodeString(tokens[3]);
	message.tableInfo = readTableInfo(tokens.slice(4), true);
	var base = 16;

	message.mpnSubscription = {};
	message.mpnSubscription.device = {};

	message.mpnSubscription.device.mpnPlatformType = protocol.decodeString(tokens[base + 1]);
	message.mpnSubscription.device.applicationId = protocol.decodeString(tokens[base + 3]);
	message.mpnSubscription.device.deviceToken = protocol.decodeString(tokens[base + 5]);
	message.mpnSubscription.trigger = protocol.decodeString(tokens[base + 7]);
	message.mpnSubscription.notificationFormat = protocol.decodeString(tokens[base + 9]);
}
1166321
def _not16(ins):
    ''' 
    '''
    output = _16bit_oper(ins.quad[2])
    output.append('ld a, h')
    output.append('or l')
    output.append('sub 1')
    output.append('sbc a, a')
    output.append('push af')
    return output
167544
def get_active_title():
    ''''''
    if os.name == 'posix':
        cmd = ['xdotool','getactivewindow','getwindowname']
        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        title = proc.communicate()[0].decode('utf-8')
    else:
        raise NotImplementedError
    return title
1292129
def seq(self):
        """"""

        if self.sequence_file:
            file_to_load = copy(self.sequence_path)
            log.debug('{}: reading sequence from sequence file {}'.format(self.id, file_to_load))
            tmp_sr = SeqIO.read(file_to_load, 'fasta')
            return tmp_sr.seq

        else:
            if not self._seq:
                log.debug('{}: no sequence stored in memory'.format(self.id))
            else:
                log.debug('{}: reading sequence from memory'.format(self.id))

            return self._seq
530459
def current_line_num(self):
        '''
        '''
        if self.is_optimized_out():
            return None
        f_trace = self.field('f_trace')
        if long(f_trace) != 0:
            # we have a non-NULL f_trace:
            return self.f_lineno
        else:
            #try:
            return self.co.addr2line(self.f_lasti)
1061797
def sequence_type(self):
        ''''''
        if self.known_sequence_type is not None:
            return self.known_sequence_type
        else:
            # If its Gzipped and fastq make a small sample of the sequence to be
            # read
            cmd='%s | head -n 2' % (self.command_line())
            first_seq = subprocess.check_output(
                                                cmd,
                                                shell=True,
                                                preexec_fn=lambda:signal(SIGPIPE, SIG_DFL)
                                                )
            _, seq = tuple(first_seq.strip().split('\n'))
            self.type = self._guess_sequence_type_from_string(seq)
            logging.debug("Detected sequence type as %s" % self.type)
            return self.type
574237
function(db) {
		var libs_uuid = uuid();
		debug.assert(libs_uuid).is('uuid');
		return db.query('CREATE SEQUENCE libs_seq'
			).query([
				"CREATE TABLE IF NOT EXISTS libs (",
				"	id uuid PRIMARY KEY NOT NULL default uuid_generate_v5('" + libs_uuid +"', nextval('libs_seq'::regclass)::text),",
				"	name text UNIQUE NOT NULL,",
				"	content text NOT NULL,",
				"	meta json,",
				"	created timestamptz NOT NULL default now(),",
				"	modified timestamptz NOT NULL default now(),",
				"	CHECK (check_javascript(content))",
				")"].join('\n')
			).query("ALTER SEQUENCE libs_seq OWNED BY libs.id"
			).query("CREATE TRIGGER libs_modified BEFORE UPDATE ON libs FOR EACH ROW EXECUTE PROCEDURE moddatetime (modified)");
	}
1254471
function GenID2012($seq='adodbseq',$start=1)
	{

		/*
		 * First time in create an array of sequence names that we
		 * can use in later requests to see if the sequence exists
		 * the overhead is creating a list of sequences every time
		 * we need access to at least 1. If we really care about
		 * performance, we could maybe flag a 'nocheck' class variable
		 */
		if (!$this->sequences){
			$sql = "SELECT name FROM sys.sequences";
			$this->sequences = $this->GetCol($sql);
		}
		if (!is_array($this->sequences)
		|| is_array($this->sequences) && !in_array($seq,$this->sequences)){
			$this->CreateSequence2012($seq, $start);

		}
		$num = $this->GetOne("SELECT NEXT VALUE FOR $seq");
		return $num;
	}
273502
def unsigned_input(outpoint, redeem_script=None, sequence=None):
    '''
    
    '''
    if redeem_script is not None and sequence is None:
        sequence = guess_sequence(redeem_script)
    if sequence is None:
        sequence = 0xFFFFFFFE
    return tb.make_legacy_input(
        outpoint=outpoint,
        stack_script=b'',
        redeem_script=b'',
        sequence=sequence)
453510
function SEQ() {
        var parsers = [];
        for (var _i = 0; _i < (arguments.length - 0); _i++) {
            parsers[_i] = arguments[_i + 0];
        }
        var _func = 'SEQ';
        var _parsers = [];

        for (var i = 0; i < parsers.length; ++i) {
            _parsers.push(_wrap(parsers[i]));
        }

        return function (buffer, index, depth) {
            if (typeof depth === "undefined") { depth = 0; }
            _trace(_func, depth, true);
            var idx = index;
            var children = [];

            for (var i = 0; i < _parsers.length; ++i) {
                var r = _parsers[i](buffer, idx, depth + 1);

                children.push(r);

                if (paka.S.OK == r.status) {
                    idx += r.length;
                } else {
                    r = R.error(paka.P.SEQ, idx, children, r.err);
                    _update_last_error(r);
                    _trace(_func, depth, false, paka.S.ERROR);
                    return r;
                }
            }

            _trace(_func, depth, false, paka.S.OK);
            return R.ok(paka.P.SEQ, index, idx - index, children);
        };
    }
992989
private void setSeq() {
		char tempseq[] = new char[seqLength];
		for (int x = 0; x <= seqLength - 1; ++x) {
			tempseq[x] = (char) traceData[PBAS2 + x];
		}
		sequence = new String(tempseq);
	}
317107
def nonpadding(self):
    """"""
    if self.sequence_id is None:
      return None
    if self.sequence_id == 1:
      return 1
    else:
      return mtf.cast(
          mtf.not_equal(self.sequence_id, 0), self.activation_dtype)