language
stringclasses 2
values | func_code_string
stringlengths 63
466k
|
|---|---|
python | def create_training_example(self,
environment_id,
collection_id,
query_id,
document_id=None,
cross_reference=None,
relevance=None,
**kwargs):
"""
Add example to training data query.
Adds a example to this training data query.
:param str environment_id: The ID of the environment.
:param str collection_id: The ID of the collection.
:param str query_id: The ID of the query used for training.
:param str document_id: The document ID associated with this training example.
:param str cross_reference: The cross reference associated with this training
example.
:param int relevance: The relevance of the training example.
:param dict headers: A `dict` containing the request headers
:return: A `DetailedResponse` containing the result, headers and HTTP status code.
:rtype: DetailedResponse
"""
if environment_id is None:
raise ValueError('environment_id must be provided')
if collection_id is None:
raise ValueError('collection_id must be provided')
if query_id is None:
raise ValueError('query_id must be provided')
headers = {}
if 'headers' in kwargs:
headers.update(kwargs.get('headers'))
sdk_headers = get_sdk_headers('discovery', 'V1',
'create_training_example')
headers.update(sdk_headers)
params = {'version': self.version}
data = {
'document_id': document_id,
'cross_reference': cross_reference,
'relevance': relevance
}
url = '/v1/environments/{0}/collections/{1}/training_data/{2}/examples'.format(
*self._encode_path_vars(environment_id, collection_id, query_id))
response = self.request(
method='POST',
url=url,
headers=headers,
params=params,
json=data,
accept_json=True)
return response |
java | @Override
public Map<String, List<String>> get(URI uri, Map<String, List<String>> requestHeaders) throws IOException {
clearExpired(new Date());
ArrayList<String> cookies = new ArrayList<String>();
for (Cookie cookie : getCookies(uri)) {
cookies.add(cookie.getName() + "=" + cookie.getValue());
}
return singletonMap(SM.COOKIE, singletonList(join(cookies, SEP)));
} |
java | public String[][] getPopupMap()
{
String string[][] = {
{RunProcessInField.LOCAL, "Run locally"},
{RunProcessInField.LOCAL_PROCESS, "Local process"},
{RunProcessInField.REMOTE_PROCESS, "Remote process"},
};
return string;
} |
java | @Indexable(type = IndexableType.REINDEX)
@Override
public CommerceNotificationTemplate addCommerceNotificationTemplate(
CommerceNotificationTemplate commerceNotificationTemplate) {
commerceNotificationTemplate.setNew(true);
return commerceNotificationTemplatePersistence.update(commerceNotificationTemplate);
} |
java | @Override
public Object proceed() throws Exception {
Object rc = null;
//if there are more interceptors left in the chain, call the next one
if (nextInterceptor < interceptors.size()) {
rc = invokeNextInterceptor();
}
else {
//otherwise call proceed on the delegate InvocationContext
rc = delegateInvocationContext.proceed();
}
return rc;
} |
python | def convex_conj(self):
"""The convex conjugate functional of the group L1-norm."""
conj_exp = conj_exponent(self.pointwise_norm.exponent)
return IndicatorGroupL1UnitBall(self.domain, exponent=conj_exp) |
java | public TLSARecord getTLSARecord(URL url) {
String recordValue;
int port = url.getPort();
if (port == -1) {
port = url.getDefaultPort();
}
String tlsaRecordName = String.format("_%s._tcp.%s", port, DNSUtil.ensureDot(url.getHost()));
try {
recordValue = this.dnssecResolver.resolve(tlsaRecordName, Type.TLSA);
} catch (DNSSECException e) {
return null;
}
if (recordValue.equals("")) return null;
// Process TLSA Record
String[] tlsaValues = recordValue.split(" ");
if (tlsaValues.length != 4) return null;
try {
return new TLSARecord(
new Name(tlsaRecordName),
DClass.IN,
0,
Integer.parseInt(tlsaValues[0]),
Integer.parseInt(tlsaValues[1]),
Integer.parseInt(tlsaValues[2]),
BaseEncoding.base16().decode(tlsaValues[3])
);
} catch (TextParseException e) {
return null;
}
} |
java | private boolean isAnomaly(Instance instance, ActiveRule rule) {
//AMRUles is equipped with anomaly detection. If on, compute the anomaly value.
boolean isAnomaly = false;
if (this.noAnomalyDetection == false){
if (rule.getInstancesSeen() >= this.anomalyNumInstThreshold) {
isAnomaly = rule.isAnomaly(instance,
this.univariateAnomalyprobabilityThreshold,
this.multivariateAnomalyProbabilityThreshold,
this.anomalyNumInstThreshold);
}
}
return isAnomaly;
} |
java | @Nullable
private static File _getResourceSource (final String resource, final ClassLoader loader)
{
if (resource != null)
{
URL url;
if (loader != null)
{
url = loader.getResource (resource);
}
else
{
url = ClassLoader.getSystemResource (resource);
}
return UrlUtils.getResourceRoot (url, resource);
}
return null;
} |
java | public Observable<VirtualNetworkRuleInner> createOrUpdateAsync(String resourceGroupName, String accountName, String virtualNetworkRuleName, CreateOrUpdateVirtualNetworkRuleParameters parameters) {
return createOrUpdateWithServiceResponseAsync(resourceGroupName, accountName, virtualNetworkRuleName, parameters).map(new Func1<ServiceResponse<VirtualNetworkRuleInner>, VirtualNetworkRuleInner>() {
@Override
public VirtualNetworkRuleInner call(ServiceResponse<VirtualNetworkRuleInner> response) {
return response.body();
}
});
} |
python | def getOSDesc(interface, ext_list):
"""
Return an OS description header.
interface (int)
Related interface number.
ext_list (list of OSExtCompatDesc or OSExtPropDesc)
List of instances of extended descriptors.
"""
try:
ext_type, = {type(x) for x in ext_list}
except ValueError:
raise TypeError('Extensions of a single type are required.')
if issubclass(ext_type, OSExtCompatDesc):
wIndex = 4
kw = {
'b': OSDescHeaderBCount(
bCount=len(ext_list),
Reserved=0,
),
}
elif issubclass(ext_type, OSExtPropDescHead):
wIndex = 5
kw = {
'wCount': len(ext_list),
}
else:
raise TypeError('Extensions of unexpected type')
ext_list_type = ext_type * len(ext_list)
klass = type(
'OSDesc',
(OSDescHeader, ),
{
'_fields_': [
('ext_list', ext_list_type),
],
},
)
return klass(
interface=interface,
dwLength=ctypes.sizeof(klass),
bcdVersion=1,
wIndex=wIndex,
ext_list=ext_list_type(*ext_list),
**kw
) |
python | def _process_phenstatement(self, limit):
"""
The phenstatements are the genotype-to-phenotype associations,
in the context of an environment.
These are also curated to a publication. So we make oban associations,
adding the pubs as a source. We additionally add the internal key as
a comment for tracking purposes.
:param limit:
:return:
"""
if self.test_mode:
graph = self.testgraph
else:
graph = self.graph
model = Model(graph)
raw = '/'.join((self.rawdir, 'phenstatement'))
LOG.info("processing phenstatement")
line_counter = 0
with open(raw, 'r') as f:
filereader = csv.reader(f, delimiter='\t', quotechar='\"')
f.readline() # read the header row; skip
for line in filereader:
(phenstatement_id, genotype_id, environment_id, phenotype_id,
type_id, pub_id) = line
# 168549 166695 1 8507 60468 151256
# 168550 166695 1 8508 60468 151256
# 168551 166696 1 8509 60468 151256
# 168552 166696 1 8510 60468 151256
line_counter += 1
phenstatement_key = phenstatement_id
phenstatement_id = self._makeInternalIdentifier(
'phenstatement', phenstatement_key)
genotype_key = genotype_id
if self.test_mode and \
int(genotype_key) not in self.test_keys['genotype']:
continue
genotype_id = self.idhash['genotype'][genotype_key]
environment_key = environment_id
environment_id = self.idhash['environment'][environment_key]
phenotype_key = phenotype_id
phenotype_internal_id = self._makeInternalIdentifier(
'phenotype', phenotype_key) # TEMP
phenotype_internal_label = self.label_hash[
phenotype_internal_id]
phenotype_id = self.idhash['phenotype'][phenotype_key]
pub_key = pub_id
pub_id = self.idhash['publication'][pub_key]
# figure out if there is a relevant stage
assoc = G2PAssoc(graph, self.name, genotype_id, phenotype_id)
if phenotype_id in self.phenocv:
stages = set(
s for s in
self.phenocv[phenotype_id] if re.match(r'FBdv', s))
if len(stages) == 1:
s = stages.pop()
assoc.set_stage(s, s)
elif len(stages) > 1:
LOG.warning(
"There's more than one stage specified per "
"phenotype. I don't know what to do. %s",
str(stages))
non_stage_ids = self.phenocv[phenotype_id] - stages
LOG.debug('Other non-stage bits: %s', str(non_stage_ids))
# TODO do something with the other parts
# of a pheno-cv relationship
assoc.set_environment(environment_id)
# TODO check remove unspecified environments?
assoc.add_source(pub_id)
assoc.add_association_to_graph()
assoc_id = assoc.get_association_id()
model.addComment(assoc_id, phenstatement_id)
model.addDescription(assoc_id, phenotype_internal_label)
if not self.test_mode and limit is not None and line_counter > limit:
break
return |
java | public static Integer[] createAndInitializeArray(int size, Integer start) {
Integer[] result = new Integer[size];
for (int i = 0; i < result.length; i++) {
result[i] = start++;
}
return result;
} |
python | def sample_bitstrings(self, n_samples):
"""
Sample bitstrings from the distribution defined by the wavefunction.
:param n_samples: The number of bitstrings to sample
:return: An array of shape (n_samples, n_qubits)
"""
possible_bitstrings = np.array(list(itertools.product((0, 1), repeat=len(self))))
inds = np.random.choice(2 ** len(self), n_samples, p=self.probabilities())
bitstrings = possible_bitstrings[inds, :]
return bitstrings |
java | public <X extends Exception> boolean replaceAllIf(Try.Predicate<? super K, X> predicate, Collection<?> oldValues, E newValue) throws X {
boolean modified = false;
for (Map.Entry<K, V> entry : this.valueMap.entrySet()) {
if (predicate.test(entry.getKey())) {
if (entry.getValue().removeAll(oldValues)) {
entry.getValue().add(newValue);
modified = true;
}
}
}
return modified;
} |
java | @Override
public int compare(JTAResource o1, JTAResource o2) {
if (tc.isEntryEnabled())
Tr.entry(tc, "compare", new Object[] { o1, o2, this });
int result = 0;
int p1 = o1.getPriority();
int p2 = o2.getPriority();
if (p1 < p2)
result = 1;
else if (p1 > p2)
result = -1;
if (tc.isEntryEnabled())
Tr.exit(tc, "compare", result);
return result;
} |
java | public BlockMeta getBlockMeta(long blockId) throws BlockDoesNotExistException {
BlockMeta blockMeta = mBlockIdToBlockMap.get(blockId);
if (blockMeta == null) {
throw new BlockDoesNotExistException(ExceptionMessage.BLOCK_META_NOT_FOUND, blockId);
}
return blockMeta;
} |
java | protected void arrangePreparedAccessContext(LaJobRuntime runtime) {
if (accessContextArranger == null) {
return;
}
final AccessContextResource resource = createAccessContextResource(runtime);
final AccessContext context = accessContextArranger.arrangePreparedAccessContext(resource);
if (context == null) {
String msg = "Cannot return null from access context arranger: " + accessContextArranger + " runtime=" + runtime;
throw new IllegalStateException(msg);
}
PreparedAccessContext.setAccessContextOnThread(context);
} |
java | public void copyCategories(CmsObject cms, CmsResource fromResource, String toResourceSitePath) throws CmsException {
List<CmsCategory> categories = readResourceCategories(cms, fromResource);
for (CmsCategory category : categories) {
addResourceToCategory(cms, toResourceSitePath, category);
}
} |
java | @Override
public String asString() {
ByteArrayOutputStream result = new ByteArrayOutputStream(getIntContentLength(this.response));
saveTo(result);
return result.toString();
} |
java | public static Map createHeaderMap(PageContext pContext)
{
final HttpServletRequest request =
(HttpServletRequest) pContext.getRequest();
return new EnumeratedMap()
{
public Enumeration enumerateKeys()
{
return request.getHeaderNames();
}
public Object getValue(Object pKey)
{
if (pKey instanceof String) {
return request.getHeader((String) pKey);
} else {
return null;
}
}
public boolean isMutable()
{
return false;
}
};
} |
python | def edges(self, source=None, relation=None, target=None):
"""
Return edges filtered by their *source*, *relation*, or *target*.
Edges don't include terminal triples (node types or attributes).
"""
edgematch = lambda e: (
(source is None or source == e.source) and
(relation is None or relation == e.relation) and
(target is None or target == e.target)
)
variables = self.variables()
edges = [t for t in self._triples if t.target in variables]
return list(filter(edgematch, edges)) |
java | public void setOutputFile (final File value)
{
if (value != null && !value.isAbsolute ())
{
throw new IllegalArgumentException ("path is not absolute: " + value);
}
this.outputFile = value;
} |
java | public void serviceName_account_userPrincipalName_PUT(String serviceName, String userPrincipalName, OvhAccount body) throws IOException {
String qPath = "/msServices/{serviceName}/account/{userPrincipalName}";
StringBuilder sb = path(qPath, serviceName, userPrincipalName);
exec(qPath, "PUT", sb.toString(), body);
} |
java | public boolean marketplace_removeListing(Long listingId, CharSequence status)
throws FacebookException, IOException {
assert MARKETPLACE_STATUS_DEFAULT.equals(status) || MARKETPLACE_STATUS_SUCCESS.equals(status) ||
MARKETPLACE_STATUS_NOT_SUCCESS.equals(status) : "Invalid status: " + status;
T result =
this.callMethod(FacebookMethod.MARKETPLACE_REMOVE_LISTING, new Pair<String, CharSequence>("listing_id",
listingId.toString()),
new Pair<String, CharSequence>("status", status));
return this.extractBoolean(result);
} |
python | def geometric_partitions(iterable, floor=1, ceiling=32768):
'''
Partition an iterable into chunks. Returns an iterator over partitions.
'''
partition_size = floor
run_length = multiprocessing.cpu_count()
run_count = 0
try:
while True:
#print("partition_size =", partition_size)
# Split the iterable and replace the original iterator to avoid
# advancing it
partition, iterable = itertools.tee(iterable)
# Yield the first partition, limited to the partition size
yield Queryable(partition).take(partition_size)
# Advance to the start of the next partition, this will raise
# StopIteration if the iterator is exhausted
for i in range(partition_size):
next(iterable)
# If we've reached the end of a run of this size, double the
# partition size
run_count += 1
if run_count >= run_length:
partition_size *= 2
run_count = 0
# Unless we have hit the ceiling
if partition_size > ceiling:
partition_size = ceiling
except StopIteration:
pass |
python | def stage_pywbem_args(self, method, **kwargs):
"""
Set requst method and all args.
Normally called before the cmd is executed to record request
parameters
"""
# pylint: disable=attribute-defined-outside-init
self._pywbem_method = method
self._pywbem_args = kwargs |
python | def star(self, login, repo):
"""Star to login/repo
:param str login: (required), owner of the repo
:param str repo: (required), name of the repo
:return: bool
"""
resp = False
if login and repo:
url = self._build_url('user', 'starred', login, repo)
resp = self._boolean(self._put(url), 204, 404)
return resp |
java | private static void weaveDNAStrands(LinkedList<DNASegment> segments, int firstJulianDay,
HashMap<Integer, DNAStrand> strands, int top, int bottom, int[] dayXs) {
// First, get rid of any colors that ended up with no segments
Iterator<DNAStrand> strandIterator = strands.values().iterator();
while (strandIterator.hasNext()) {
DNAStrand strand = strandIterator.next();
if (strand.count < 1 && strand.allDays == null) {
strandIterator.remove();
continue;
}
strand.points = new float[strand.count * 4];
strand.position = 0;
}
// Go through each segment and compute its points
for (DNASegment segment : segments) {
// Add the points to the strand of that color
DNAStrand strand = strands.get(segment.color);
int dayIndex = segment.day - firstJulianDay;
int dayStartMinute = segment.startMinute % DAY_IN_MINUTES;
int dayEndMinute = segment.endMinute % DAY_IN_MINUTES;
int height = bottom - top;
int workDayHeight = height * 3 / 4;
int remainderHeight = (height - workDayHeight) / 2;
int x = dayXs[dayIndex];
int y0 = 0;
int y1 = 0;
y0 = top + getPixelOffsetFromMinutes(dayStartMinute, workDayHeight, remainderHeight);
y1 = top + getPixelOffsetFromMinutes(dayEndMinute, workDayHeight, remainderHeight);
if (DEBUG) {
Log.d(TAG, "Adding " + Integer.toHexString(segment.color) + " at x,y0,y1: " + x
+ " " + y0 + " " + y1 + " for " + dayStartMinute + " " + dayEndMinute);
}
strand.points[strand.position++] = x;
strand.points[strand.position++] = y0;
strand.points[strand.position++] = x;
strand.points[strand.position++] = y1;
}
} |
python | def geoid(self):
""""Return first child of the column, or self that is marked as a geographic identifier"""
if self.valuetype_class.is_geoid():
return self
for c in self.table.columns:
if c.parent == self.name and c.valuetype_class.is_geoid():
return c |
java | List<PartitionInstance> getAbsent() {
List<PartitionInstance> absentPartitions = new ArrayList<>();
for (Map.Entry<Integer, List<PartitionInstance>> e : nodeIndexToHostedPartitions.entrySet()) {
if (e.getKey() < 0) {
absentPartitions.addAll(e.getValue());
}
}
return absentPartitions;
} |
java | public static void parseLongestText(String text, AhoCorasickDoubleArrayTrie.IHit<CoreDictionary.Attribute> processor)
{
if (trie != null)
{
final int[] lengthArray = new int[text.length()];
final CoreDictionary.Attribute[] attributeArray = new CoreDictionary.Attribute[text.length()];
char[] charArray = text.toCharArray();
DoubleArrayTrie<CoreDictionary.Attribute>.Searcher searcher = dat.getSearcher(charArray, 0);
while (searcher.next())
{
lengthArray[searcher.begin] = searcher.length;
attributeArray[searcher.begin] = searcher.value;
}
trie.parseText(charArray, new AhoCorasickDoubleArrayTrie.IHit<CoreDictionary.Attribute>()
{
@Override
public void hit(int begin, int end, CoreDictionary.Attribute value)
{
int length = end - begin;
if (length > lengthArray[begin])
{
lengthArray[begin] = length;
attributeArray[begin] = value;
}
}
});
for (int i = 0; i < charArray.length;)
{
if (lengthArray[i] == 0)
{
++i;
}
else
{
processor.hit(i, i + lengthArray[i], attributeArray[i]);
i += lengthArray[i];
}
}
}
else
dat.parseLongestText(text, processor);
} |
python | def interpoled_resampling(W, x):
"""Resampling based on an interpolated CDF, as described in Malik and Pitt.
Parameters
----------
W: (N,) array
weights
x: (N,) array
particles
Returns
-------
xrs: (N,) array
the resampled particles
"""
N = W.shape[0]
idx = np.argsort(x)
xs = x[idx]
ws = W[idx]
cs = np.cumsum(avg_n_nplusone(ws))
u = random.rand(N)
xrs = np.empty(N)
where = np.searchsorted(cs, u)
# costs O(N log(N)) but algorithm has O(N log(N)) complexity anyway
for n in range(N):
m = where[n]
if m==0:
xrs[n] = xs[0]
elif m==N:
xrs[n] = xs[-1]
else:
xrs[n] = interpol(cs[m-1], cs[m], xs[m-1], xs[m], u[n])
return xrs |
python | def _construct_sharded(self):
"""Construct command line strings for a sharded cluster."""
current_version = self.getMongoDVersion()
num_mongos = self.args['mongos'] if self.args['mongos'] > 0 else 1
shard_names = self._get_shard_names(self.args)
# create shards as stand-alones or replica sets
nextport = self.args['port'] + num_mongos
for shard in shard_names:
if (self.args['single'] and
LooseVersion(current_version) >= LooseVersion("3.6.0")):
errmsg = " \n * In MongoDB 3.6 and above a Shard must be " \
"made up of a replica set. Please use --replicaset " \
"option when starting a sharded cluster.*"
raise SystemExit(errmsg)
elif (self.args['single'] and
LooseVersion(current_version) < LooseVersion("3.6.0")):
self.shard_connection_str.append(
self._construct_single(
self.dir, nextport, name=shard, extra='--shardsvr'))
nextport += 1
elif self.args['replicaset']:
self.shard_connection_str.append(
self._construct_replset(
self.dir, nextport, shard,
num_nodes=list(range(self.args['nodes'])),
arbiter=self.args['arbiter'], extra='--shardsvr'))
nextport += self.args['nodes']
if self.args['arbiter']:
nextport += 1
# start up config server(s)
config_string = []
# SCCC config servers (MongoDB <3.3.0)
if not self.args['csrs'] and self.args['config'] >= 3:
config_names = ['config1', 'config2', 'config3']
else:
config_names = ['config']
# CSRS config servers (MongoDB >=3.1.0)
if self.args['csrs']:
config_string.append(self._construct_config(self.dir, nextport,
"configRepl", True))
else:
for name in config_names:
self._construct_config(self.dir, nextport, name)
config_string.append('%s:%i' % (self.args['hostname'],
nextport))
nextport += 1
# multiple mongos use <datadir>/mongos/ as subdir for log files
if num_mongos > 1:
mongosdir = os.path.join(self.dir, 'mongos')
if not os.path.exists(mongosdir):
if self.args['verbose']:
print("creating directory: %s" % mongosdir)
os.makedirs(mongosdir)
# start up mongos, but put them to the front of the port range
nextport = self.args['port']
for i in range(num_mongos):
if num_mongos > 1:
mongos_logfile = 'mongos/mongos_%i.log' % nextport
else:
mongos_logfile = 'mongos.log'
self._construct_mongos(os.path.join(self.dir, mongos_logfile),
nextport, ','.join(config_string))
nextport += 1 |
python | def are_worth_chaining(parser, to_type: Type[S], converter: Converter[S, T]) -> bool:
"""
Utility method to check if it makes sense to chain this parser with the given destination type, and the given
converter to create a parsing chain. Returns True if it brings value to chain them.
To bring value,
* the converter's output should not be a parent class of the parser's output. Otherwise
the chain does not even make any progress :)
* The parser has to allow chaining (with converter.can_chain=True)
:param parser:
:param to_type:
:param converter:
:return:
"""
if not parser.can_chain:
# The base parser prevents chaining
return False
elif not is_any_type(to_type) and is_any_type(converter.to_type):
# we gain the capability to generate any type. So it is interesting.
return True
elif issubclass(to_type, converter.to_type):
# Not interesting : the outcome of the chain would be not better than one of the parser alone
return False
# Note: we dont say that chaining a generic parser with a converter is useless. Indeed it might unlock some
# capabilities for the user (new file extensions, etc.) that would not be available with the generic parser
# targetting to_type alone. For example parsing object A from its constructor then converting A to B might
# sometimes be interesting, rather than parsing B from its constructor
else:
# Interesting
return True |
java | private String[] superTypes( ObjectType cmisType ) {
if (cmisType.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) {
return new String[] {JcrConstants.NT_FOLDER};
}
if (cmisType.getBaseTypeId() == BaseTypeId.CMIS_DOCUMENT) {
return new String[] {JcrConstants.NT_FILE};
}
return new String[] {cmisType.getParentType().getId()};
} |
java | public static Version parse(String version) {
Assert.hasText(version, "Version must not be null o empty!");
String[] parts = version.trim().split("\\.");
int[] intParts = new int[parts.length];
for (int i = 0; i < parts.length; i++) {
String input = i == parts.length - 1 ? parts[i].replaceAll("\\D.*", "") : parts[i];
if (StringUtils.hasText(input)) {
try {
intParts[i] = Integer.parseInt(input);
} catch (IllegalArgumentException o_O) {
throw new IllegalArgumentException(String.format(VERSION_PARSE_ERROR, input, version), o_O);
}
}
}
return new Version(intParts);
} |
java | public static String jsonNameVal(final String indent,
final String name,
final String val) {
StringBuilder sb = new StringBuilder();
sb.append(indent);
sb.append("\"");
sb.append(name);
sb.append("\": ");
if (val != null) {
sb.append(jsonEncode(val));
}
return sb.toString();
} |
java | public static <T> QBean<T> fields(Path<? extends T> type, Map<String, ? extends Expression<?>> bindings) {
return new QBean<T>(type.getType(), true, bindings);
} |
python | def parse_value(self, text: str) -> Optional[bool]:
"""Parse boolean value.
Args:
text: String representation of the value.
"""
if text == "true":
return True
if text == "false":
return False |
java | public static boolean isPublicStatic(Field f) {
final int modifiers = f.getModifiers();
return Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers);
} |
java | @Override
@LogarithmicTime(amortized = true)
public Handle<K, V> insert(K key) {
return insert(key, null);
} |
java | public static File create(FileCreateParams params, RequestOptions options)
throws StripeException {
checkNullTypedParams(classUrl(File.class, Stripe.getUploadBase()), params);
return create(params.toMap(), options);
} |
java | protected void doExecuteCommand() {
if (this.commandExecutor instanceof ParameterizableActionCommandExecutor) {
((ParameterizableActionCommandExecutor) this.commandExecutor).execute(getParameters());
}
else {
if (this.commandExecutor != null) {
this.commandExecutor.execute();
}
}
} |
python | def tf(cluster):
"""
Computes the term frequency and stores it as a dictionary
:param cluster: the cluster that contains the metadata
:return: tf dictionary
"""
counts = dict()
words = cluster.split(' ')
for word in words:
counts[word] = counts.get(word, 0) + 1
return counts |
python | def _get_value(self, var):
"""Return value of variable in solution."""
return self._problem._p.get_value(self._problem._variables[var]) |
java | int numNodes(Block b) {
BlockInfo info = blocks.get(b);
return info == null ? 0 : info.numNodes();
} |
java | public Response put(Session session, String path, InputStream inputStream, String fileNodeType,
String contentNodeType, List<String> mixins, List<String> tokens, MultivaluedMap<String, String> allowedAutoVersionPath)
{
try
{
Node node = null;
boolean isVersioned;
try
{
node = (Node)session.getItem(path);
}
catch (PathNotFoundException pexc)
{
nullResourceLocks.checkLock(session, path, tokens);
}
if (node == null)
{
node = session.getRootNode().addNode(TextUtil.relativizePath(path, false), fileNodeType);
// We set the new path
path = node.getPath();
node.addNode("jcr:content", contentNodeType);
updateContent(node, inputStream, mixins);
isVersioned = isVersionSupported(node.getPath(), session.getWorkspace().getName(), allowedAutoVersionPath);
if (isVersioned && node.canAddMixin(VersionHistoryUtils.MIX_VERSIONABLE))
{
node.addMixin(VersionHistoryUtils.MIX_VERSIONABLE);
}
node.getSession().save();
}
else
{
isVersioned = isVersionSupported(node.getPath(), session.getWorkspace().getName(), allowedAutoVersionPath);
if (isVersioned)
{
VersionHistoryUtils.createVersion(node);
updateContent(node, inputStream, mixins);
}
else
{
updateContent(node, inputStream, mixins);
}
}
session.save();
}
catch (LockException exc)
{
if(log.isDebugEnabled())
{
log.debug(exc.getMessage(), exc);
}
return Response.status(HTTPStatus.LOCKED).entity(exc.getMessage()).build();
}
catch (AccessDeniedException exc)
{
if(log.isDebugEnabled())
{
log.debug(exc.getMessage(), exc);
}
return Response.status(HTTPStatus.FORBIDDEN).entity(exc.getMessage()).build();
}
catch (RepositoryException exc)
{
if(log.isDebugEnabled())
{
log.debug(exc.getMessage(), exc);
}
return Response.status(HTTPStatus.CONFLICT).entity(exc.getMessage()).build();
}
catch (Exception exc)
{
if(log.isDebugEnabled())
{
log.debug(exc.getMessage(), exc);
}
return Response.status(HTTPStatus.CONFLICT).entity(exc.getMessage()).build();
}
if (uriBuilder != null)
{
return Response.created(uriBuilder.path(session.getWorkspace().getName()).path(path).build()).build();
}
// to save compatibility if uriBuilder is not provided
return Response.status(HTTPStatus.CREATED).build();
} |
java | public ListZonesResponse listZones(AbstractBceRequest request) {
InternalRequest internalRequest = this.createRequest(request, HttpMethodName.GET, ZONE);
return invokeHttpClient(internalRequest, ListZonesResponse.class);
} |
python | def outputWord(self):
"""Output report to word docx
"""
import docx
from docx.enum.text import WD_ALIGN_PARAGRAPH
doc = docx.Document()
doc.styles['Normal'].paragraph_format.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
doc.add_heading(self.title, level=0)
if self.addTime:
from time import localtime, strftime
doc.add_heading(strftime("%Y-%m-%d %H:%M:%S", localtime()), level=1)
# Append introduction
if self.p:
doc.add_heading('Introduction',level=1)
for p in renewliner(self.p).split('\n'):
doc.add_paragraph(p)
# Sections
c = count(1)
#Prepare fig and table numbers
self.listFigures(tuple())
self.listTables(tuple())
for section in self.sections:
section.sectionsWord((next(c),),doc=doc)
# Append conclusion
if self.conclusion:
doc.add_heading('Conclusion', level=1)
for p in renewliner(self.conclusion).split('\n'):
doc.add_paragraph(p)
# Generate Word document
doc.save(self.outfile+'.docx') |
java | public void sendWithBulkProcessor(IndexRequest indexRequest) {
Optional.ofNullable(this.bulkProcessor)
.orElseGet(() -> setAndReturnBulkProcessor(BulkProcessor
.builder(jmESClient, bulkProcessorListener).build()))
.add(indexRequest);
} |
java | public void writeHeadersTo(final CacheResponse pResponse) {
String[] headers = getHeaderNames();
for (String header : headers) {
// HACK...
// Strip away internal headers
if (HTTPCache.HEADER_CACHED_TIME.equals(header)) {
continue;
}
// TODO: Replace Last-Modified with X-Cached-At? See CachedEntityImpl
String[] headerValues = getHeaderValues(header);
for (int i = 0; i < headerValues.length; i++) {
String headerValue = headerValues[i];
if (i == 0) {
pResponse.setHeader(header, headerValue);
}
else {
pResponse.addHeader(header, headerValue);
}
}
}
} |
python | def Address(self):
"""
Get the wallet address associated with the token.
Returns:
str: base58 encoded string representing the wallet address.
"""
if self._address is None:
self._address = Crypto.ToAddress(self.ScriptHash)
return self._address |
java | public synchronized void removeObserver(final String notification, final ApptentiveNotificationObserver observer) {
final ApptentiveNotificationObserverList list = findObserverList(notification);
if (list != null) {
list.removeObserver(observer);
}
} |
java | protected static Variable findTargetVariable(VariableExpression ve) {
final Variable accessedVariable = ve.getAccessedVariable() != null ? ve.getAccessedVariable() : ve;
if (accessedVariable != ve) {
if (accessedVariable instanceof VariableExpression)
return findTargetVariable((VariableExpression) accessedVariable);
}
return accessedVariable;
} |
java | public static DiscreteLogLinearFactor fromFeatureGeneratorSparse(DiscreteFactor factor,
FeatureGenerator<Assignment, String> featureGen) {
Iterator<Outcome> iter = factor.outcomeIterator();
Set<String> featureNames = Sets.newHashSet();
while (iter.hasNext()) {
Outcome o = iter.next();
for (Map.Entry<String, Double> f : featureGen.generateFeatures(o.getAssignment()).entrySet()) {
featureNames.add(f.getKey());
}
}
List<String> featureNamesSorted = Lists.newArrayList(featureNames);
Collections.sort(featureNamesSorted);
DiscreteVariable featureType = new DiscreteVariable(FEATURE_VAR_NAME, featureNamesSorted);
VariableNumMap featureVar = VariableNumMap.singleton(
Ints.max(factor.getVars().getVariableNumsArray()) + 1, FEATURE_VAR_NAME, featureType);
TableFactorBuilder builder = new TableFactorBuilder(
factor.getVars().union(featureVar), SparseTensorBuilder.getFactory());
iter = factor.outcomeIterator();
while (iter.hasNext()) {
Outcome o = iter.next();
for (Map.Entry<String, Double> f : featureGen.generateFeatures(o.getAssignment()).entrySet()) {
Assignment featureAssignment = featureVar.outcomeArrayToAssignment(f.getKey());
builder.setWeight(o.getAssignment().union(featureAssignment), f.getValue());
}
}
DiscreteFactor featureFactor = builder.build();
return new DiscreteLogLinearFactor(factor.getVars(), featureVar, featureFactor, factor);
} |
python | def id(self, peer=None, **kwargs):
"""Shows IPFS Node ID info.
Returns the PublicKey, ProtocolVersion, ID, AgentVersion and
Addresses of the connected daemon or some other node.
.. code-block:: python
>>> c.id()
{'ID': 'QmVgNoP89mzpgEAAqK8owYoDEyB97MkcGvoWZir8otE9Uc',
'PublicKey': 'CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggE … BAAE=',
'AgentVersion': 'go-libp2p/3.3.4',
'ProtocolVersion': 'ipfs/0.1.0',
'Addresses': [
'/ip4/127.0.0.1/tcp/4001/ipfs/QmVgNoP89mzpgEAAqK8owYo … E9Uc',
'/ip4/10.1.0.172/tcp/4001/ipfs/QmVgNoP89mzpgEAAqK8owY … E9Uc',
'/ip4/172.18.0.1/tcp/4001/ipfs/QmVgNoP89mzpgEAAqK8owY … E9Uc',
'/ip6/::1/tcp/4001/ipfs/QmVgNoP89mzpgEAAqK8owYoDEyB97 … E9Uc',
'/ip6/fccc:7904:b05b:a579:957b:deef:f066:cad9/tcp/400 … E9Uc',
'/ip6/fd56:1966:efd8::212/tcp/4001/ipfs/QmVgNoP89mzpg … E9Uc',
'/ip6/fd56:1966:efd8:0:def1:34d0:773:48f/tcp/4001/ipf … E9Uc',
'/ip6/2001:db8:1::1/tcp/4001/ipfs/QmVgNoP89mzpgEAAqK8 … E9Uc',
'/ip4/77.116.233.54/tcp/4001/ipfs/QmVgNoP89mzpgEAAqK8 … E9Uc',
'/ip4/77.116.233.54/tcp/10842/ipfs/QmVgNoP89mzpgEAAqK … E9Uc']}
Parameters
----------
peer : str
Peer.ID of the node to look up (local node if ``None``)
Returns
-------
dict : Information about the IPFS node
"""
args = (peer,) if peer is not None else ()
return self._client.request('/id', args, decoder='json', **kwargs) |
python | def peakdelta(v, delta, x=None):
"""
Returns two arrays
function [maxtab, mintab]=peakdelta(v, delta, x)
%PEAKDET Detect peaks in a vector
% [MAXTAB, MINTAB] = peakdelta(V, DELTA) finds the local
% maxima and minima ("peaks") in the vector V.
% MAXTAB and MINTAB consists of two columns. Column 1
% contains indices in V, and column 2 the found values.
%
% With [MAXTAB, MINTAB] = peakdelta(V, DELTA, X) the indices
% in MAXTAB and MINTAB are replaced with the corresponding
% X-values.
%
% A point is considered a maximum peak if it has the maximal
% value, and was preceded (to the left) by a value lower by
% DELTA.
% Eli Billauer, 3.4.05 (Explicitly not copyrighted).
% This function is released to the public domain; Any use is allowed.
"""
maxtab = []
mintab = []
if x is None:
x = arange(len(v))
v = asarray(v)
if len(v) != len(x):
sys.exit('Input vectors v and x must have same length')
if not isscalar(delta):
sys.exit('Input argument delta must be a scalar')
if delta <= 0:
sys.exit('Input argument delta must be positive')
mn, mx = Inf, -Inf
mnpos, mxpos = NaN, NaN
lookformax = True
for i in arange(len(v)):
this = v[i]
if this > mx:
mx = this
mxpos = x[i]
if this < mn:
mn = this
mnpos = x[i]
if lookformax:
if this < mx - delta:
maxtab.append((mxpos, mx))
mn = this
mnpos = x[i]
lookformax = False
else:
if this > mn + delta:
mintab.append((mnpos, mn))
mx = this
mxpos = x[i]
lookformax = True
return array(maxtab), array(mintab) |
python | def table(self):
"""Return a large string of the entire table ready to be printed to the terminal."""
dimensions = max_dimensions(self.table_data, self.padding_left, self.padding_right)[:3]
return flatten(self.gen_table(*dimensions)) |
java | public void setSearchableInfo(SearchableInfo searchable) {
mSearchable = searchable;
if (mSearchable != null) {
updateSearchAutoComplete();
updateQueryHint();
}
// Cache the voice search capability
mVoiceButtonEnabled = hasVoiceSearch();
if (mVoiceButtonEnabled) {
// Disable the microphone on the keyboard, as a mic is displayed near the text box
// TODO: use imeOptions to disable voice input when the new API will be available
mQueryTextView.setPrivateImeOptions(IME_OPTION_NO_MICROPHONE);
}
updateViewsVisibility(isIconified());
} |
java | protected PrintJob createJob(final PrintJobEntry entry) {
//CHECKSTYLE:ON
PrintJob job = this.context.getBean(PrintJob.class);
job.setEntry(entry);
job.setSecurityContext(SecurityContextHolder.getContext());
return job;
} |
python | def _xpathDict(xml, xpath, cls, parent, **kwargs):
""" Returns a default Dict given certain information
:param xml: An xml tree
:type xml: etree
:param xpath: XPath to find children
:type xpath: str
:param cls: Class identifying children
:type cls: inventory.Resource
:param parent: Parent of object
:type parent: CtsCollection
:rtype: collections.defaultdict.<basestring, inventory.Resource>
:returns: Dictionary of children
"""
children = []
for child in xml.xpath(xpath, namespaces=XPATH_NAMESPACES):
children.append(cls.parse(
resource=child,
parent=parent,
**kwargs
))
return children |
python | def delete_asset_content(self, asset_content_id):
"""Deletes content from an ``Asset``.
arg: asset_content_id (osid.id.Id): the ``Id`` of the
``AssetContent``
raise: NotFound - ``asset_content_id`` is not found
raise: NullArgument - ``asset_content_id`` is ``null``
raise: OperationFailed - unable to complete request
raise: PermissionDenied - authorization failure
*compliance: mandatory -- This method must be implemented.*
"""
# Implemented from template for
# osid.repository.AssetAdminSession.delete_asset_content_template
from dlkit.abstract_osid.id.primitives import Id as ABCId
from .objects import AssetContent
collection = JSONClientValidated('repository',
collection='Asset',
runtime=self._runtime)
if not isinstance(asset_content_id, ABCId):
raise errors.InvalidArgument('the argument is not a valid OSID Id')
asset = collection.find_one({'assetContents._id': ObjectId(asset_content_id.get_identifier())})
index = 0
found = False
for i in asset['assetContents']:
if i['_id'] == ObjectId(asset_content_id.get_identifier()):
asset_content_map = asset['assetContents'].pop(index)
index += 1
found = True
if not found:
raise errors.OperationFailed()
AssetContent(
osid_object_map=asset_content_map,
runtime=self._runtime,
proxy=self._proxy)._delete()
collection.save(asset) |
java | private String[] splitSeqName(String sequenceName) {
String[] result = new String[3];
String[] barSplit = sequenceName.split("/");
if (barSplit.length == 2) {
result[0] = barSplit[0];
String[] positions = barSplit[1].split("-");
if (positions.length == 2) {
result[1] = positions[0];
result[2] = positions[1];
}
} else {
result[0] = sequenceName;
result[1] = null;
result[2] = null;
}
return result;
} |
python | def formatted(self):
"""str: The BIC separated in the blocks bank-, country- and location-code."""
formatted = ' '.join([self.bank_code, self.country_code, self.location_code])
if self.branch_code:
formatted += ' ' + self.branch_code
return formatted |
python | def run(self, context=None, stdout=None, stderr=None):
"Like execute, but records a skip if the should_skip method returns True."
if self.should_skip():
self._record_skipped_example(self.formatter)
self.num_skipped += 1
else:
self.execute(context, stdout, stderr)
return self.num_successes, self.num_failures, self.num_skipped |
python | def buy_open_order_quantity(self):
"""
[int] 买方向挂单量
"""
return sum(order.unfilled_quantity for order in self.open_orders if
order.side == SIDE.BUY and order.position_effect == POSITION_EFFECT.OPEN) |
python | def write_single_coil(self, starting_address, value):
"""
Write single Coil to Master device (Function code 5)
starting_address: Coil to be written
value: Coil Value to be written
"""
self.__transactionIdentifier+=1
if (self.__ser is not None):
if (self.__ser.closed):
raise Exception.SerialPortNotOpenedException("serial port not opened")
function_code = 5
length = 6;
transaction_identifier_lsb = self.__transactionIdentifier&0xFF
transaction_identifier_msb = ((self.__transactionIdentifier&0xFF00) >> 8)
length_lsb = length&0xFF
length_msb = (length&0xFF00) >> 8
starting_address_lsb = starting_address&0xFF
starting_address_msb = (starting_address&0xFF00) >> 8
if value:
valueLSB = 0x00
valueMSB = (0xFF00) >> 8
else:
valueLSB = 0x00
valueMSB = (0x00) >> 8
if (self.__ser is not None):
data = bytearray([self.__unitIdentifier, function_code, starting_address_msb, starting_address_lsb, valueMSB, valueLSB, 0, 0])
crc = self.__calculateCRC(data, len(data)-2, 0)
crcLSB = crc&0xFF
crcMSB = (crc&0xFF00) >> 8
data[6] = crcLSB
data[7] = crcMSB
self.__ser.write(data)
bytes_to_read = 8
data = self.__ser.read(bytes_to_read)
b=bytearray(data)
data = b
if (len(data) < bytes_to_read):
raise Exceptions.TimeoutError('Read timeout Exception')
if ((data[1] == 0x85) & (data[2] == 0x01)):
raise Exceptions.function_codeNotSupportedException("Function code not supported by master");
if ((data[1] == 0x85) & (data[2] == 0x02)):
raise Exceptions.starting_addressInvalidException("Address invalid");
if ((data[1] == 0x85) & (data[2] == 0x03)):
raise Exceptions.QuantityInvalidException("Value invalid");
if ((data[1] == 0x85) & (data[2] == 0x04)):
raise Exceptions.ModbusException("error reading");
crc = self.__calculateCRC(data, len(data) - 2, 0)
crcLSB = crc&0xFF
crcMSB = (crc&0xFF00) >> 8
if ((crcLSB != data[len(data)-2]) & (crcMSB != data[len(data)-1])):
raise Exceptions.CRCCheckFailedException("CRC check failed");
if data[1] == self.__unitIdentifier:
return True
else:
return False
else:
protocolIdentifierLSB = 0x00;
protocolIdentifierMSB = 0x00;
length_lsb = 0x06;
length_msb = 0x00;
data = bytearray([transaction_identifier_msb, transaction_identifier_lsb, protocolIdentifierMSB, protocolIdentifierLSB, length_msb, length_lsb, self.__unitIdentifier, function_code, starting_address_msb, starting_address_lsb, valueMSB, valueLSB])
self.__tcpClientSocket.send(data)
bytes_to_read = 12
self.__receivedata = bytearray()
try:
while (len(self.__receivedata) == 0):
pass
except Exception:
raise Exception('Read Timeout')
data = bytearray(self.__receivedata)
if ((data[1+6] == 0x85) & (data[2+6] == 0x01)):
raise Exceptions.function_codeNotSupportedException("Function code not supported by master");
if ((data[1+6] == 0x85) & (data[2+6] == 0x02)):
raise Exceptions.starting_addressInvalidException("Address invalid");
if ((data[1+6] == 0x85) & (data[2+6] == 0x03)):
raise Exceptions.QuantityInvalidException("Value invalid");
if ((data[1+6] == 0x85) & (data[2+6] == 0x04)):
raise Exceptions.ModbusException("error reading");
return True |
java | public static byte[] encryptAES2Base64(byte[] data, byte[] key) {
try {
return Base64.getEncoder().encode(encryptAES(data, key));
} catch (Exception e) {
return null;
}
} |
python | def parse_response(self, response):
"""
Parse the response and build a `scanboo_common.http_client.HttpResponse` object.
For successful responses, convert the json data into a dict.
:param response: the `requests` response
:return: [HttpResponse] response object
"""
status = response.status_code
if response.ok:
data = response.json()
return HttpResponse(ok=response.ok, status=status, errors=None, data=data)
else:
try:
errors = response.json()
except ValueError:
errors = response.content
return HttpResponse(ok=response.ok, status=status, errors=errors, data=None) |
java | private void processEnumJavadoc(Options.OptionInfo oi) {
Enum<?>[] constants = (Enum<?>[]) oi.baseType.getEnumConstants();
if (constants == null) {
return;
}
oi.enumJdoc = new LinkedHashMap<>();
for (Enum<?> constant : constants) {
assert oi.enumJdoc != null : "@AssumeAssertion(nullness): bug in flow?";
oi.enumJdoc.put(constant.name(), "");
}
ClassDoc enumDoc = root.classNamed(oi.baseType.getName());
if (enumDoc == null) {
return;
}
assert oi.enumJdoc != null : "@AssumeAssertion(nullness): bug in flow?";
for (String name : oi.enumJdoc.keySet()) {
for (FieldDoc fd : enumDoc.fields()) {
if (fd.name().equals(name)) {
if (formatJavadoc) {
oi.enumJdoc.put(name, fd.commentText());
} else {
oi.enumJdoc.put(name, javadocToHtml(fd));
}
break;
}
}
}
} |
python | def labelTextWidth(label):
""" Returns the width of label text of the label in pixels.
IMPORTANT: does not work when the labels are styled using style sheets.
Unfortunately it is possible to retrieve the settings (e.g. padding) that were set by the
style sheet without parsing the style sheet as text.
"""
# The Qt source shows that fontMetrics().size calls fontMetrics().boundingRect with
# the TextLongestVariant included in the flags. TextLongestVariant is an internal flag
# which is used to force selecting the longest string in a multi-length string.
# See: http://stackoverflow.com/a/8638114/625350
fontMetrics = label.fontMetrics()
#contentsWidth = label.fontMetrics().boundingRect(label.text()).width()
contentsWidth = fontMetrics.size(label.alignment(), label.text()).width()
# If indent is negative, or if no indent has been set, the label computes the effective indent
# as follows: If frameWidth() is 0, the effective indent becomes 0. If frameWidth() is greater
# than 0, the effective indent becomes half the width of the "x" character of the widget's
# current font().
# See http://doc.qt.io/qt-4.8/qlabel.html#indent-prop
if label.indent() < 0 and label.frameWidth(): # no indent, but we do have a frame
indent = fontMetrics.width('x') / 2 - label.margin()
indent *= 2 # the indent seems to be added to the other side as well
else:
indent = label.indent()
result = contentsWidth + indent + 2 * label.frameWidth() + 2 * label.margin()
if 1:
#print ("contentsMargins: {}".format(label.getContentsMargins()))
#print ("contentsRect: {}".format(label.contentsRect()))
#print ("frameRect: {}".format(label.frameRect()))
print ("contentsWidth: {}".format(contentsWidth))
print ("lineWidth: {}".format(label.lineWidth()))
print ("midLineWidth: {}".format(label.midLineWidth()))
print ("frameWidth: {}".format(label.frameWidth()))
print ("margin: {}".format(label.margin()))
print ("indent: {}".format(label.indent()))
print ("actual indent: {}".format(indent))
print ("RESULT: {}".format(result))
print ()
return result |
python | def list_external_jar_dependencies(self, binary):
"""Returns the external jar dependencies of the given binary.
:param binary: The jvm binary target to list transitive external dependencies for.
:type binary: :class:`pants.backend.jvm.targets.jvm_binary.JvmBinary`
:returns: A list of (jar path, coordinate) tuples.
:rtype: list of (string, :class:`pants.java.jar.M2Coordinate`)
"""
classpath_products = self.context.products.get_data('runtime_classpath')
classpath_entries = classpath_products.get_artifact_classpath_entries_for_targets(
binary.closure(bfs=True, include_scopes=Scopes.JVM_RUNTIME_SCOPES,
respect_intransitive=True))
external_jars = OrderedSet(jar_entry for conf, jar_entry in classpath_entries
if conf == 'default')
return [(entry.path, entry.coordinate) for entry in external_jars
if not entry.is_excluded_by(binary.deploy_excludes)] |
java | public void setViewEnabled(boolean enable) {
if (enable && mView == null) {
mView = makeView();
}
if (mView != null) {
mView.setViewEnabled(enable);
}
} |
python | def set_torrent_download_limit(self, infohash_list, limit):
"""
Set download speed limit of the supplied torrents.
:param infohash_list: Single or list() of infohashes.
:param limit: Speed limit in bytes.
"""
data = self._process_infohash_list(infohash_list)
data.update({'limit': limit})
return self._post('command/setTorrentsDlLimit', data=data) |
python | def _get_true_palette_entry(self, name, digits):
''' Compute truecolor entry, once on the fly.
values must become sequence of decimal int strings: ('1', '2', '3')
'''
values = None
type_digits = type(digits)
is_fbterm = (env.TERM == 'fbterm') # sigh
if 'truecolor' in self._palette_support: # build entry
values = [self._start_codes_true]
if type_digits is str: # convert hex string
if len(digits) == 3:
values.extend(str(int(ch + ch, 16)) for ch in digits)
else: # chunk 'BB00BB', to ints to 'R', 'G', 'B':
values.extend(str(int(digits[i:i+2], 16)) for i in (0, 2 ,4))
else: # tuple of str-digit or int, may not matter to bother:
values.extend(str(digit) for digit in digits)
# downgrade section
elif 'extended' in self._palette_support:
if type_digits is str:
nearest_idx = find_nearest_color_hexstr(digits,
method=self._dg_method)
else: # tuple
if type(digits[0]) is str: # convert to ints
digits = tuple(int(digit) for digit in digits)
nearest_idx = find_nearest_color_index(*digits,
method=self._dg_method)
start_codes = self._start_codes_extended
if is_fbterm:
start_codes = self._start_codes_extended_fbterm
values = [start_codes, str(nearest_idx)]
elif 'basic' in self._palette_support:
if type_digits is str:
nearest_idx = find_nearest_color_hexstr(digits, color_table4,
method=self._dg_method)
else: # tuple
if type(digits[0]) is str: # convert to ints
digits = tuple(int(digit) for digit in digits)
nearest_idx = find_nearest_color_index(*digits,
color_table=color_table4,
method=self._dg_method)
values = self._index_to_ansi_values(nearest_idx)
return (self._create_entry(name, values, fbterm=is_fbterm)
if values else empty) |
python | def retry(self, delay=0, group=None, message=None):
'''Retry this job in a little bit, in the same queue. This is meant
for the times when you detect a transient failure yourself'''
args = ['retry', self.jid, self.queue_name, self.worker_name, delay]
if group is not None and message is not None:
args.append(group)
args.append(message)
return self.client(*args) |
java | @Override
public String newId(final RootDocument rootDocument) {
return newId(mongoTemplate, FamilyDocumentMongo.class,
rootDocument.getFilename(), "F");
} |
java | private void generateEncode(TypeToken<?> outputType, Schema schema) {
TypeToken<?> callOutputType = getCallTypeToken(outputType, schema);
Method encodeMethod = getMethod(void.class, "encode", callOutputType.getRawType(), Encoder.class);
if (!Object.class.equals(callOutputType.getRawType())) {
// Generate the synthetic method for the bridging
Method method = getMethod(void.class, "encode", Object.class, Encoder.class);
GeneratorAdapter mg = new GeneratorAdapter(Opcodes.ACC_PUBLIC + Opcodes.ACC_BRIDGE + Opcodes.ACC_SYNTHETIC,
method, null, new Type[] {Type.getType(IOException.class)},
classWriter);
mg.loadThis();
mg.loadArg(0);
mg.checkCast(Type.getType(callOutputType.getRawType()));
mg.loadArg(1);
mg.invokeVirtual(classType, encodeMethod);
mg.returnValue();
mg.endMethod();
}
// Generate the top level public encode method
String methodSignature = null;
if (callOutputType.getType() instanceof ParameterizedType) {
methodSignature = Signatures.getMethodSignature(encodeMethod, new TypeToken[]{callOutputType, null});
}
GeneratorAdapter mg = new GeneratorAdapter(Opcodes.ACC_PUBLIC, encodeMethod, methodSignature,
new Type[] {Type.getType(IOException.class)}, classWriter);
// Delegate to the actual encode method(value, encoder, schema, Sets.newIdentityHashSet());
mg.loadThis();
mg.loadArg(0);
mg.loadArg(1);
mg.loadThis();
mg.getField(classType, "schema", Type.getType(Schema.class));
// seenRefs Set
mg.invokeStatic(Type.getType(Sets.class), getMethod(Set.class, "newIdentityHashSet"));
mg.invokeVirtual(classType, getEncodeMethod(outputType, schema));
mg.returnValue();
mg.endMethod();
} |
python | def send_mail(self, sender, subject, recipients, message, response_id=None, html_message=False):
"""Send an email using EBUio features. If response_id is set, replies will be send back to the PlugIt server."""
params = {
'sender': sender,
'subject': subject,
'dests': recipients,
'message': message,
'html_message': html_message,
}
if response_id:
params['response_id'] = response_id
return self._request('mail/', postParams=params, verb='POST') |
java | protected TokenList.Token createOp( TokenList.Token left , TokenList.Token op , TokenList.Token right ,
TokenList tokens , Sequence sequence )
{
Operation.Info info = functions.create(op.symbol, left.getVariable(), right.getVariable());
sequence.addOperation(info.op);
// replace the symbols with their output
TokenList.Token t = new TokenList.Token(info.output);
tokens.remove(left);
tokens.remove(right);
tokens.replace(op,t);
return t;
} |
python | def write_out(self, output):
"""Banana banana
"""
for page in self.walk():
ext = self.project.extensions[page.extension_name]
ext.write_out_page(output, page) |
python | def get_saved_search(self, id, **kwargs): # noqa: E501
"""Get a specific saved search # noqa: E501
# noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_saved_search(id, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str id: (required)
:return: ResponseContainerSavedSearch
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.get_saved_search_with_http_info(id, **kwargs) # noqa: E501
else:
(data) = self.get_saved_search_with_http_info(id, **kwargs) # noqa: E501
return data |
java | private static BigInteger bigTenToThe(int n) {
if (n < 0)
return BigInteger.ZERO;
if (n < BIG_TEN_POWERS_TABLE_MAX) {
BigInteger[] pows = BIG_TEN_POWERS_TABLE;
if (n < pows.length)
return pows[n];
else
return expandBigIntegerTenPowers(n);
}
return BigInteger.TEN.pow(n);
} |
java | public static java.util.List<com.liferay.commerce.price.list.model.CommercePriceList> getCommercePriceListsByUuidAndCompanyId(
String uuid, long companyId) {
return getService()
.getCommercePriceListsByUuidAndCompanyId(uuid, companyId);
} |
python | def get_activity_admin_session(self, proxy):
"""Gets the ``OsidSession`` associated with the activity administration service.
arg: proxy (osid.proxy.Proxy): a proxy
return: (osid.learning.ActivityAdminSession) - an
``ActivityAdminSession``
raise: NullArgument - ``proxy`` is ``null``
raise: OperationFailed - unable to complete request
raise: Unimplemented - ``supports_activity_admin()`` is
``false``
*compliance: optional -- This method must be implemented if
``supports_activity_admin()`` is ``true``.*
"""
if not self.supports_activity_admin():
raise errors.Unimplemented()
# pylint: disable=no-member
return sessions.ActivityAdminSession(proxy=proxy, runtime=self._runtime) |
python | def auto_stratify(scores, **kwargs):
"""Generate Strata instance automatically
Parameters
----------
scores : array-like, shape=(n_items,)
ordered array of scores which quantify the classifier confidence for
the items in the pool. High scores indicate a high confidence that
the true label is a "1" (and vice versa for label "0").
**kwargs :
optional keyword arguments. May include 'stratification_method',
'stratification_n_strata', 'stratification_n_bins'.
Returns
-------
Strata instance
"""
if 'stratification_method' in kwargs:
method = kwargs['stratification_method']
else:
method = 'cum_sqrt_F'
if 'stratification_n_strata' in kwargs:
n_strata = kwargs['stratification_n_strata']
else:
n_strata = 'auto'
if 'stratification_n_bins' in kwargs:
n_bins = kwargs['stratification_n_bins']
strata = stratify_by_scores(scores, n_strata, method = method, \
n_bins = n_bins)
else:
strata = stratify_by_scores(scores, n_strata, method = method)
return strata |
java | public static boolean isRegisteredOnServer(Context context) {
final SharedPreferences prefs = getGCMPreferences(context);
boolean isRegistered = prefs.getBoolean(PROPERTY_ON_SERVER, false);
Log.v(TAG, "Is registered on server: " + isRegistered);
if (isRegistered) {
// checks if the information is not stale
long expirationTime =
prefs.getLong(PROPERTY_ON_SERVER_EXPIRATION_TIME, -1);
if (System.currentTimeMillis() > expirationTime) {
Log.v(TAG, "flag expired on: " + new Timestamp(expirationTime));
return false;
}
}
return isRegistered;
} |
python | def add_multiple(self, *users):
"""Add multiple users to the group at once.
Each given user must be a dictionary containing a nickname and either
an email, phone number, or user_id.
:param args users: the users to add
:return: a membership request
:rtype: :class:`MembershipRequest`
"""
guid = uuid.uuid4()
for i, user_ in enumerate(users):
user_['guid'] = '{}-{}'.format(guid, i)
payload = {'members': users}
url = utils.urljoin(self.url, 'add')
response = self.session.post(url, json=payload)
return MembershipRequest(self, *users, group_id=self.group_id,
**response.data) |
java | public void matchSet(Hashtable elements, int combine_op,
int compare_op) throws DBException
{
// Delete the old search criteria
criteria = new Criteria();
// If compare_op is not a binary operator, throw an exception
if ((compare_op & BINARY_OPER_MASK) == 0)
{
throw new DBException();
}
if (combine_op == AND)
{
// combine all value pairs by an AND
// For each of the elements in the hashtable, create a comparison node for the match
for (Enumeration e = elements.keys(); e.hasMoreElements();)
{
// Get the element name from the enumerator
// and its value
String elementName = (String) e.nextElement();
String elementValue = (String) elements.get(elementName);
switch (compare_op)
{
case LIKE:
{
criteria.addLike(elementName, elementValue);
break;
}
case EQUAL:
{
criteria.addEqualTo(elementName, elementValue);
break;
}
case NOT_EQUAL:
{
criteria.addNotEqualTo(elementName, elementValue);
break;
}
case LESS_THAN:
{
criteria.addLessThan(elementName, elementValue);
break;
}
case GREATER_THAN:
{
criteria.addGreaterThan(elementName, elementValue);
break;
}
case GREATER_EQUAL:
{
criteria.addGreaterOrEqualThan(elementName, elementValue);
break;
}
case LESS_EQUAL:
{
criteria.addLessOrEqualThan(elementName, elementValue);
break;
}
default:
{
throw new DBException("Unsupported binary operation in OJBSearchFilter!");
}
} // end of switch
} // end of for
}
else if (combine_op == OR)
{
// combine all value pairs by an OR
// For each of the elements in the hashtable, create a comparison node for the match
for (Enumeration e = elements.keys(); e.hasMoreElements();)
{
// Get the element name from the enumerator
// and its value
String elementName = (String) e.nextElement();
String elementValue = (String) elements.get(elementName);
switch (compare_op)
{
case LIKE:
{
Criteria tempCrit = new Criteria();
tempCrit.addLike(elementName, elementValue);
criteria.addOrCriteria(tempCrit);
break;
}
case EQUAL:
{
Criteria tempCrit = new Criteria();
tempCrit.addEqualTo(elementName, elementValue);
criteria.addOrCriteria(tempCrit);
break;
}
case NOT_EQUAL:
{
Criteria tempCrit = new Criteria();
tempCrit.addNotEqualTo(elementName, elementValue);
criteria.addOrCriteria(tempCrit);
break;
}
case LESS_THAN:
{
Criteria tempCrit = new Criteria();
tempCrit.addLessThan(elementName, elementValue);
criteria.addOrCriteria(tempCrit);
break;
}
case GREATER_THAN:
{
Criteria tempCrit = new Criteria();
tempCrit.addGreaterThan(elementName, elementValue);
criteria.addOrCriteria(tempCrit);
break;
}
case GREATER_EQUAL:
{
Criteria tempCrit = new Criteria();
tempCrit.addGreaterOrEqualThan(elementName, elementValue);
criteria.addOrCriteria(tempCrit);
break;
}
case LESS_EQUAL:
{
Criteria tempCrit = new Criteria();
tempCrit.addLessOrEqualThan(elementName, elementValue);
criteria.addOrCriteria(tempCrit);
break;
}
default:
{
throw new DBException("Unsupported binary operation in OJBSearchFilter!");
}
} // end of switch
} // end of for
}
else
{
// combine_op is not a logical operator, throw an exception
throw new DBException();
}
} |
java | @Nonnull
public final LBiByteFunctionBuilder<R> withHandling(@Nonnull HandlingInstructions<RuntimeException, RuntimeException> handling) {
Null.nonNullArg(handling, "handling");
if (this.handling != null) {
throw new UnsupportedOperationException("Handling is already set for this builder.");
}
this.handling = handling;
return self();
} |
python | def ecef2geodetic(x: float, y: float, z: float,
ell: Ellipsoid = None, deg: bool = True) -> Tuple[float, float, float]:
"""
convert ECEF (meters) to geodetic coordinates
Parameters
----------
x : float or numpy.ndarray of float
target x ECEF coordinate (meters)
y : float or numpy.ndarray of float
target y ECEF coordinate (meters)
z : float or numpy.ndarray of float
target z ECEF coordinate (meters)
ell : Ellipsoid, optional
reference ellipsoid
deg : bool, optional
degrees input/output (False: radians in/out)
Returns
-------
lat : float or numpy.ndarray of float
target geodetic latitude
lon : float or numpy.ndarray of float
target geodetic longitude
h : float or numpy.ndarray of float
target altitude above geodetic ellipsoid (meters)
based on:
You, Rey-Jer. (2000). Transformation of Cartesian to Geodetic Coordinates without Iterations.
Journal of Surveying Engineering. doi: 10.1061/(ASCE)0733-9453
"""
if ell is None:
ell = Ellipsoid()
x = np.asarray(x)
y = np.asarray(y)
z = np.asarray(z)
r = sqrt(x**2 + y**2 + z**2)
E = sqrt(ell.a**2 - ell.b**2)
# eqn. 4a
u = sqrt(0.5 * (r**2 - E**2) + 0.5 * sqrt((r**2 - E**2)**2 + 4 * E**2 * z**2))
Q = hypot(x, y)
huE = hypot(u, E)
# eqn. 4b
with np.errstate(divide='ignore'):
Beta = arctan(huE / u * z / hypot(x, y))
# eqn. 13
eps = ((ell.b * u - ell.a * huE + E**2) * sin(Beta)) / (ell.a * huE * 1 / cos(Beta) - E**2 * cos(Beta))
Beta += eps
# %% final output
lat = arctan(ell.a / ell.b * tan(Beta))
lon = arctan2(y, x)
# eqn. 7
alt = hypot(z - ell.b * sin(Beta),
Q - ell.a * cos(Beta))
# inside ellipsoid?
with np.errstate(invalid='ignore'):
inside = x**2 / ell.a**2 + y**2 / ell.a**2 + z**2 / ell.b**2 < 1
if isinstance(inside, np.ndarray):
alt[inside] = -alt[inside]
elif inside:
alt = -alt
if deg:
lat = degrees(lat)
lon = degrees(lon)
return lat, lon, alt |
python | def info(request, message, extra_tags='', fail_silently=False):
"""Adds a message with the ``INFO`` level."""
add_message(request, constants.INFO, message, extra_tags=extra_tags,
fail_silently=fail_silently) |
java | @Override
public void visit(NodeVisitor v) {
if (v.visit(this)) {
for (AstNode var : variables) {
var.visit(v);
}
}
} |
java | @SuppressWarnings("unchecked")
public static Map<String, Object> normaliseAndValidateQuery(Map<String, Object> query) throws QueryException{
boolean isWildCard = false;
if (query.isEmpty()) {
isWildCard = true;
}
// First expand the query to include a leading compound predicate
// if there isn't one already.
query = addImplicitAnd(query);
// At this point we will have a single entry map, key AND or OR,
// forming the compound predicate.
String compoundOperator = (String) query.keySet().toArray()[0];
List<Object> predicates = new ArrayList<Object>();
if (query.get(compoundOperator) instanceof List) {
// Next make sure all the predicates have an operator -- the EQ
// operator is implicit and we need to add it if there isn't one.
// Take
// [ {"field1": "mike"}, ... ]
// and make
// [ {"field1": { "$eq": "mike"} }, ... ]
predicates = addImplicitEq((List<Object>) query.get(compoundOperator));
// Then all shorthand operators like $ne, if present, need to be converted
// to their logical longhand equivalent.
// Take
// [ { "field1": { "$ne": "mike"} }, ... ]
// and make
// [ { "field1": { "$not" : { "$eq": "mike"} } }, ... ]
predicates = handleShortHandOperators(predicates);
// Now in the event that extraneous $not operators exist in the query,
// these operators must be compressed down to the their logical equivalent.
// Take
// [ { "field1": { "$not" : { $"not" : { "$eq": "mike"} } } }, ... ]
// and make
// [ { "field1": { "$eq": "mike"} }, ... ]
predicates = compressMultipleNotOperators(predicates);
// Here we ensure that all non-whole number arguments included in a $mod
// clause are truncated. This provides for consistent behavior between
// the SQL engine and the unindexed matcher.
// Take
// [ { "field1": { "$mod" : [ 2.6, 1.7] } }, ... ]
// and make
// [ { "field1": { "$mod" : [ 2, 1 ] } }, ... ]
predicates = truncateModArguments(predicates);
}
Map<String, Object> selector = new HashMap<String, Object>();
selector.put(compoundOperator, predicates);
if (!isWildCard) {
validateSelector(selector);
}
return selector;
} |
java | @Override
public MessageRepresentation getMessage(int commandCode, long applicationId, boolean isRequest) {
if (!this.configured) {
return null;
}
MessageRepresentation key = new MessageRepresentationImpl(commandCode, applicationId, isRequest);
return this.commandMap.get(key);
} |
java | double refine_clusters(List<Cluster<K>> clusters)
{
double[] norms = new double[clusters.size()];
int offset = 0;
for (Cluster cluster : clusters)
{
norms[offset++] = cluster.composite_vector().norm();
}
double eval_cluster = 0.0;
int loop_count = 0;
while (loop_count++ < NUM_REFINE_LOOP)
{
List<int[]> items = new ArrayList<int[]>(documents_.size());
for (int i = 0; i < clusters.size(); i++)
{
for (int j = 0; j < clusters.get(i).documents().size(); j++)
{
items.add(new int[]{i, j});
}
}
Collections.shuffle(items);
boolean changed = false;
for (int[] item : items)
{
int cluster_id = item[0];
int item_id = item[1];
Cluster<K> cluster = clusters.get(cluster_id);
Document<K> doc = cluster.documents().get(item_id);
double value_base = refined_vector_value(cluster.composite_vector(), doc.feature(), -1);
double norm_base_moved = Math.pow(norms[cluster_id], 2) + value_base;
norm_base_moved = norm_base_moved > 0 ? Math.sqrt(norm_base_moved) : 0.0;
double eval_max = -1.0;
double norm_max = 0.0;
int max_index = 0;
for (int j = 0; j < clusters.size(); j++)
{
if (cluster_id == j)
continue;
Cluster<K> other = clusters.get(j);
double value_target = refined_vector_value(other.composite_vector(), doc.feature(), 1);
double norm_target_moved = Math.pow(norms[j], 2) + value_target;
norm_target_moved = norm_target_moved > 0 ? Math.sqrt(norm_target_moved) : 0.0;
double eval_moved = norm_base_moved + norm_target_moved - norms[cluster_id] - norms[j];
if (eval_max < eval_moved)
{
eval_max = eval_moved;
norm_max = norm_target_moved;
max_index = j;
}
}
if (eval_max > 0)
{
eval_cluster += eval_max;
clusters.get(max_index).add_document(doc);
clusters.get(cluster_id).remove_document(item_id);
norms[cluster_id] = norm_base_moved;
norms[max_index] = norm_max;
changed = true;
}
}
if (!changed)
break;
for (Cluster<K> cluster : clusters)
{
cluster.refresh();
}
}
return eval_cluster;
} |
java | private static String[] getAllowedMethods(String[] existingMethods) {
int listCapacity = existingMethods.length + 1;
List<String> allowedMethods = new ArrayList<>(listCapacity);
allowedMethods.addAll(Arrays.asList(existingMethods));
allowedMethods.add(METHOD_PATCH);
return allowedMethods.toArray(new String[0]);
} |
java | @Override
public <A, B, C, D> P4<A, B, C, D> asProc4() {
return new P4<>(this, args);
} |
java | public int layerSize(String layerName) {
Layer l = getLayer(layerName);
if(l == null){
throw new IllegalArgumentException("No layer with name \"" + layerName + "\" exists");
}
org.deeplearning4j.nn.conf.layers.Layer conf = l.conf().getLayer();
if (conf == null || !(conf instanceof FeedForwardLayer)) {
return 0;
}
FeedForwardLayer ffl = (FeedForwardLayer) conf;
// FIXME: int cast
return (int) ffl.getNOut();
} |
Subsets and Splits