Process set literals.
972072
def set_letter_literal_handle(self, tokens):
        """"""
        if len(tokens) == 1:
            set_type = tokens[0]
            if set_type == "s":
                return "_coconut.set()"
            elif set_type == "f":
                return "_coconut.frozenset()"
            else:
                raise CoconutInternalException("invalid set type", set_type)
        elif len(tokens) == 2:
            set_type, set_items = tokens
            internal_assert(len(set_items) == 1, "invalid set literal item", tokens[0])
            if set_type == "s":
                return self.set_literal_handle([set_items])
            elif set_type == "f":
                return "_coconut.frozenset(" + set_to_tuple(set_items) + ")"
            else:
                raise CoconutInternalException("invalid set type", set_type)
        else:
            raise CoconutInternalException("invalid set literal tokens", tokens)
1308732
def perform_templating(args):
    """"""
    engine = engines.engines[args.engine]

    if args.vary:
        it = variable_outfile_iterator(args.outfiles,
                                       args.infiles,
                                       args.args,
                                       engine)
    else:
        it = constant_outfile_iterator(args.outfiles,
                                       args.infiles,
                                       args.args)

    process_combinations(it, engine,
                         tolerant=args.tolerant,
                         read_old=args.read_old,
                         delete_empty=args.delete_empty,
                         )
437414
def process_tokens(self, tokens):
        
        """
        for (tok_type, token, (start_row, _), _, _) in tokens:
            if tok_type == tokenize.STRING:
                self._check_string(token, start_row)
1322641
function set (dictionary) {
  for (var key in dictionary) {
    if (missing(key)) process.env[key] = dictionary[key]
  }
}
622563
def bool_set(operation,*sets):
    ''''''
    if len(sets)<=1:
        return sets
    if operation=='and':
        return and_sets(*sets)
    if operation=='or':
        return or_sets(*sets)
    if operation=='not':
        return not_sets(*sets)
434946
private void processTypeVariables(TypeVariable<?>[] variables, Type[] values) {
        for (int i = 0; i < variables.length; i++) {
            processTypeVariable(variables[i], values[i]);
        }
    }
97190
def parse_set(string):
    """"""
    string = string.strip()
    if string:
        return set(string.split(","))
    else:
        return set()
677146
def generate_setter(value):
    """"""
    @wraps(set_)
    def setter(self):
        self.set_(value)

    return setter
596543
def lset(self, name, index, value):
        ""
        return self.execute_command('LSET', name, index, value)
1045177
def set(self, key, val, time=0, min_compress_len=0):
        """"""
        if not self.servers:
            return

        key = self._qualified_key(key)
        hashed_key = self.key_hasher(key)
        val = (key, val)

        self.client.set(key=hashed_key,
                        val=val,
                        time=time,
                        min_compress_len=min_compress_len)
        self.logger("SET: %s", key)
249995
def set_in(self, que_in, num_senders):
        """"""
        for p in self.processes:
            p.set_in(que_in, num_senders)
383618
function(set, clause, result, useSet) {
		if(result && typeof result === "object" && useSet !== false) {
			if( this.translators[clause] ) {
				set = this.translators.where.toSet(set, result);
			} else {
				set = assign(set, result);
			}
			return true;
		}
		else if(result) {
			return useSet === undefined ? undefined : false;
		}
		else {
			return false;
		}
	}
303462
def prepare_value(value):
        """"""
        if isinstance(value, (list, tuple, set)):
            return ",".join(value)

        if isinstance(value, bool):
            return "y" if value else "n"

        return str(value)
1209781
def lpop(self, key, *, encoding=_NOTSET):
        """"""
        return self.execute(b'LPOP', key, encoding=encoding)
283936
def sets(self):
        """"""
        sets = {}
        for x in self._parents:
            sets.setdefault(self[x], set()).add(x)
        return frozenset(frozenset(v) for v in six.viewvalues(sets))
96324
def issuperset(self, other):
        """"""
        self._binary_sanity_check(other)
        return set.issuperset(self, other)
340042
def fromints(cls, ints):
        """"""
        return cls.frombitsets(map(cls.BitSet.fromint, ints))