# feature classes have a 'transition' method, which, given a rule and its
# antecedents, computes a feature cost and possibly a new state.
from ngram import NgramEnumerator
from logprob import elog, elog10
from rule import get_num_edges
from rule import isvar
import logger
import sys
import gflags
FLAGS = gflags.FLAGS
from mymonitor import human, memory
gflags.DEFINE_boolean(
'use_python_lm',
False,
'Use the python lm module in place of the swig srilm wrapper.')
class Feature(object):
def __init__(self):
"""features should do only trivial jobs in __init__. more serious
jobs should be postponed to 'initialize' method"""
# a feature is stateless if it can be computed from the rule alone
self.stateless = True
# if a feature is not stateless, this index is set by add_feature so
# that feature knows the index of its state in an item's state list
self.i = None
# feature name is used for printing information, weight matching, etc
self.name = self.__class__.__name__
import gflags as flags
from . import errorrecord
from . import runner
from .common import erroraccumulator
from .common import simplefileflags as fileflags
# Attempt import of multiprocessing (should be available in Python 2.6 and up).
try:
# pylint: disable=g-import-not-at-top
import multiprocessing
except ImportError:
multiprocessing = None
FLAGS = flags.FLAGS
flags.DEFINE_boolean('unix_mode', False,
'Whether to emit warnings in standard unix format.')
flags.DEFINE_boolean('beep', True, 'Whether to beep when errors are found.')
flags.DEFINE_boolean('time', False, 'Whether to emit timing statistics.')
flags.DEFINE_boolean('check_html', False,
'Whether to check javascript in html files.')
flags.DEFINE_boolean('summary', False,
'Whether to show an error count summary.')
flags.DEFINE_list(
'additional_extensions', None, 'List of additional file '
'extensions (not js) that should be treated as '
'JavaScript files.')
flags.DEFINE_boolean(
'multiprocess',
platform.system() is 'Linux' and bool(multiprocessing),
'Whether to attempt parallelized linting using the '
'multiprocessing module. Enabled by default on Linux '
def height(self, level=0):
if self.is_terminal():
return 1
return max([sub.height() for sub in self.subs]) + 1
###########################################
## attached code does empty node removal ##
###########################################
if __name__ == "__main__":
flags.DEFINE_integer("max_len", 400, "maximum sentence length")
flags.DEFINE_boolean("pp", False, "pretty print")
flags.DEFINE_boolean("height", False, "output the height of each tree")
# flags.DEFINE_boolean("wordtags", False, "output word/tag sequence")
# flags.DEFINE_boolean("words", False, "output word sequence")
flags.DEFINE_boolean("clean", False,
"clean up functional tags and empty nodes")
argv = FLAGS(sys.argv)
for i, line in enumerate(sys.stdin):
t = Tree.parse(line.strip(), trunc=FLAGS.clean)
if len(t) <= FLAGS.max_len:
if FLAGS.pp:
t.pp()
elif FLAGS.height:
print("%d\t%d" % (len(t), t.height()))
from modules.canbus.proto import chassis_pb2
from modules.localization.proto import localization_pb2
from modules.map.relative_map.proto import navigation_pb2
from path_decider import PathDecider
from speed_decider import SpeedDecider
from trajectory_generator import TrajectoryGenerator
from provider_mobileye import MobileyeProvider
from provider_chassis import ChassisProvider
from provider_localization import LocalizationProvider
from provider_routing import RoutingProvider
from obstacle_decider import ObstacleDecider
from ad_vehicle import ADVehicle
gflags.DEFINE_integer('max_cruise_speed', 20,
'max speed for cruising in meter per second')
gflags.DEFINE_boolean('enable_follow', False, 'enable follow function.')
gflags.DEFINE_boolean('enable_nudge', True, 'enable nudge function.')
gflags.DEFINE_boolean('enable_change_lane', False,
'enable change lane function.')
gflags.DEFINE_boolean('enable_routing_aid', True,
'enable planning leveraging routing information.')
gflags.DEFINE_string('navigation_planning_node_name', 'navigation_planning',
'node name for navigation planning.')
gflags.DEFINE_string('navigation_planning_topic', '/apollo/planning',
'navigation planning publish topic.')
planning_pub = None
log_file = None
path_decider = None
speed_decider = None
traj_generator = None
from pygaga.helpers.ratelimit import waitlimit
from pygaga.helpers.dbutils import get_db_engine
from guang_crawler.taobao_api import get_report, get_top
gflags.DEFINE_string(
'sessionid', "6101a2091623b5bc1ec813739d8d158539f719c08ef9a96814424732",
"taobao session id")
gflags.DEFINE_string('start', "",
"get report start from yyyymmdd, default today")
gflags.DEFINE_string('end', "", "get report end to yyyymmdd, default today")
gflags.DEFINE_integer('interval', 0,
"if not 0, ignore start params, start=end-interval")
gflags.DEFINE_integer('limit', 30, "how many api calls per minutes")
gflags.DEFINE_boolean('dryrun', False, "not commit to database")
gflags.DEFINE_boolean('csv', False, "output to csv")
gflags.DEFINE_string('csv_encoding', 'gb18030', "csv encoding, gbk or utf8")
gflags.DEFINE_string('csv_split', ';', "csv splitter")
gflags.DEFINE_string('csv_quote', '"', "csv quote")
gflags.DEFINE_string('csv_filename', 'output.csv', "csv filename")
logger = logging.getLogger('TaobaoLogger')
FLAGS = gflags.FLAGS
def dates():
end = datetime.now()
interval = 1
solutions being generated using a cheapest addition heuristic.
Optionally one can randomly forbid a set of random connections between nodes
(forbidden arcs).
"""
import random
from google.apputils import app
import gflags
from ortools.constraint_solver import pywrapcp
FLAGS = gflags.FLAGS
gflags.DEFINE_integer('tsp_size', 4,
'Size of Traveling Salesman Problem instance.')
gflags.DEFINE_boolean('tsp_use_random_matrix', True, 'Use random cost matrix.')
gflags.DEFINE_integer('tsp_random_forbidden_connections', 0,
'Number of random forbidden connections.')
gflags.DEFINE_integer('tsp_random_seed', 0, 'Random seed.')
gflags.DEFINE_boolean('light_propagation', False, 'Use light propagation')
# Cost/distance functions.
def Distance(i, j):
"""Sample function."""
# Put your distance code here.
return i + j
class RandomMatrix(object):
'Encoding used in runtime string processing')
gflags.DEFINE_string('entities_path', '', 'Path to the entities file')
gflags.DEFINE_string(
'user_agent',
'Mozilla/5.0 (Windows NT 6.0) AppleWebKit/537.11 (KHTML, like Gecko) '
'Chrome/23.0.1271.97 Safari/537.11', 'User Agent used to crawl pages')
gflags.DEFINE_float('min_absolute_score', 1e-10,
'Minimal absolute score for a candidate to be accepted')
gflags.DEFINE_float(
'min_relative_score', 0.2,
'Minimal score relative to that of the top candidate for a '
'candidate to be accepted')
gflags.DEFINE_integer('max_candidates', 10,
'Maximal number of candidates to pick for each page')
gflags.DEFINE_boolean(
'match_partial_image_url', True,
'If set to true, only match the filename part of the image url')
gflags.DEFINE_boolean(
'must_match_image_url', False,
'If set to true, only pick candidates if the page being analyzed '
'matches the provided image url')
gflags.DEFINE_boolean('display_surtext', False,
'If set to true, surrounding text will be displayed')
gflags.DEFINE_integer(
'header_length', 1000,
'Presumed length of the header section that includes title and meta tags')
gflags.DEFINE_integer(
'header_equivalent_distance', 200,
'If an entity is found in the header section, use this equivalent distance'
)
gflags.DEFINE_integer('min_distance', 200,
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS-IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Helper script used by app_unittest.sh"""
import sys
import gflags as flags
from google.apputils import app
FLAGS = flags.FLAGS
flags.DEFINE_boolean("raise_exception", False, "throw MyException from main")
class MyException(Exception):
pass
def main(args):
if FLAGS.raise_exception:
raise MyException
if __name__ == '__main__':
app.run()
#!/usr/bin/env python3
from heapq import heapify, heappush, heappop
import os
import gflags
FLAGS = gflags.FLAGS
import logger
from rule import Rule, isvar, nocat
from logprob import elog
from percent_counter import PercentCounter
import decoding_flags
gflags.DEFINE_boolean('merge_rules_with_same_f', False,
'Share rules with the same f to save memory.')
class RuleBin(object):
def __init__(self, K):
self.K = K # size limit
self.rules = []
if FLAGS.merge_rules_with_same_f:
self.f = None
self.sorted = False
def add(self, rule):
# experiments show this has little effect
if FLAGS.merge_rules_with_same_f:
if self.f:
rule.f = self.f # all rules in bin share f
else:
"""Flags for calling BigQuery."""
import os
import gflags as flags
FLAGS = flags.FLAGS
flags.DEFINE_string(
'apilog', None,
'Turn on logging of all server requests and responses. If no string is '
'provided, log to stdout; if a string is provided, instead log to that '
'file.')
flags.DEFINE_string('api', 'https://www.googleapis.com',
'API endpoint to talk to.')
flags.DEFINE_string('api_version', 'v2', 'API version to use.')
flags.DEFINE_boolean('debug_mode', False,
'Show tracebacks on Python exceptions.')
flags.DEFINE_string(
'trace', None, 'A tracing token of the form "token:<token>" '
'to include in api requests.')
flags.DEFINE_string(
'bigqueryrc', os.path.join(os.path.expanduser('~'), '.bigqueryrc'),
'Path to configuration file. The configuration file specifies '
'new defaults for any flags, and can be overrridden by specifying the '
'flag on the command line. If the --bigqueryrc flag is not specified, the '
'BIGQUERYRC environment variable is used. If that is not specified, the '
'path "~/.bigqueryrc" is used.')
flags.DEFINE_string(
'credential_file',
os.path.join(os.path.expanduser('~'), '.bigquery.v2.token'),
'Filename used for storing the BigQuery OAuth token.')
import sys
import datetime
import gflags
FLAGS = gflags.FLAGS
gflags.DEFINE_boolean('time_stamp', False, 'Print time stamps.')
level = 1
file = sys.stderr
def writeln(s=""):
if FLAGS.time_stamp:
file.write('[%s] %s\n' % (datetime.datetime.utcnow(), s))
else:
file.write("%s\n" % s)
file.flush()
def write(s):
file.write(s)
file.flush()
FLAGS = gflags.FLAGS
BAILOUT_FILE = os.path.join(os.path.dirname(__file__), os.pardir, 'BAILOUT')
gflags.DEFINE_string('alice_solver', None, 'Path to alice solver binary.')
gflags.MarkFlagAsRequired('alice_solver')
gflags.DEFINE_integer('initial_arguments', 3,
'Number of arguments initially given to cardinal.')
gflags.DEFINE_string(
'detail_log_dir', None,
'Problem details for post-mortem are logged to this directory.')
gflags.MarkFlagAsRequired('detail_log_dir')
gflags.DEFINE_boolean('keep_going', False, 'Keep going even on expiration')
gflags.DEFINE_integer('time_limit_sec', 300, 'Time limit in seconds')
class Alice(object):
def __init__(self):
self.proc = subprocess.Popen([FLAGS.alice_solver],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
self._WaitReady()
def _WaitReady(self):
logging.info(
'Alice is booting. This can take a while and consumes a lot of RAM.'
)
dct[k] = max(v, dct[k]) if k in dct else v
steps, val = zip(*sorted(dct.iteritems()))
plt.plot(steps, val, label="Log%d:%s-%d" % (log_ind, attr, index))
plt.xlabel("No. of training iteration")
plt.ylabel(FLAGS.ylabel)
if FLAGS.legend:
plt.legend()
plt.show()
if __name__ == '__main__':
gflags.DEFINE_string("path", None, "Path to log file")
gflags.DEFINE_string("index", "1", "csv list of corpus indices. 0 for train, 1 for eval set 1 etc.")
gflags.DEFINE_boolean("pred_acc", True, "Prediction accuracy")
gflags.DEFINE_boolean("parse_acc", False, "Parsing accuracy")
gflags.DEFINE_boolean("total_cost", False, "Total cost, valid only if index == 0")
gflags.DEFINE_boolean("xent_cost", False, "Cross entropy cost, valid only if index == 0")
gflags.DEFINE_boolean("l2_cost", False, "L2 regularization cost, valid only if index == 0")
gflags.DEFINE_boolean("action_cost", False, "Action cost, valid only if index == 0")
gflags.DEFINE_boolean("legend", False, "Show legend in plot")
gflags.DEFINE_boolean("subplot", False, "Separate plots for each log")
gflags.DEFINE_string("ylabel", "", "Label for y-axis of plot")
gflags.DEFINE_integer("iters", 10000, "Iters to limit plot to")
FLAGS(sys.argv)
assert FLAGS.path is not None, "Must provide a log path"
ShowPlots(FLAGS.subplot)
import gflags
from makani.analysis.aero import load_database
from makani.control import system_types
from makani.lib.python import flag_types
from makani.sim.physics import physics
from matplotlib import pyplot
import numpy as np
FLAGS = gflags.FLAGS
flag_types.DEFINE_linspace('alphas_deg', '-10.0, 10.0, 20',
'Linspace range of angle-of-attack values [deg].')
flag_types.DEFINE_linspace('betas_deg', '-15.0, 15.0, 20',
'Linspace range of sideslip angles [deg].')
gflags.DEFINE_boolean('plot_sim', False,
'Whether to display the sim aero model.')
gflags.DEFINE_list('flaps_deg', [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
'Flap deflections [deg].')
gflags.RegisterValidator('flaps_deg',
lambda x: len(x) == system_types.kNumFlaps,
'Wrong number of flaps in input.')
gflags.DEFINE_float('reynolds_number', 1e6,
'Reynolds number for the simulator.')
gflags.DEFINE_float('p_hat', 0.0, 'Normalized roll rate.')
gflags.DEFINE_float('q_hat', 0.0, 'Normalized pitch rate.')
gflags.DEFINE_float('r_hat', 0.0, 'Normalized yaw rate.')
gflags.DEFINE_float('thrust_coeff', 0.0, 'Total thrust coefficient.')
def _SwigVec3ToArray(v):
"""Converts a Swig Vec3 data structure to an array."""
_GLOBS = find_devices()
if _GLOBS:
_DEFAULT_PORT = _GLOBS[0]
else:
_DEFAULT_PORT = '/dev/ttyUSB0'
FLAGS = gflags.FLAGS
gflags.DEFINE_integer('kegboard_speed', 115200,
'Baud rate of device at --kegboard_device')
gflags.DEFINE_boolean('verbose',
os.environ.get('VERBOSE') is not None,
'Generate extra logging information.',
allow_override=True)
def get_kegboard(glob_paths=None):
"""Immediately returns a Kegboard if available, None otherwise.
Args:
glob_paths: Paths to test for a valid kegboard.
"""
return wait_for_kegboard(timeout=0, glob_paths=glob_paths)
def wait_for_kegboard(interval=0.1, timeout=None, glob_paths=None):
if not glob_paths:
glob_paths = DEFAULT_GLOB_PATHS
import time import gflags from collections import OrderedDict from apiclient.discovery import build from oauth2client.client import OAuth2WebServerFlow from oauth2client.file import Storage from oauth2client.tools import run FLAGS = gflags.FLAGS # Flags related to operations on task lists. gflags.DEFINE_boolean( 'add', False, 'Add operation', short_name='a') gflags.DEFINE_boolean( 'clear', False, 'Clear operation', short_name='c') gflags.DEFINE_boolean( 'delete', False, 'Delete operation', short_name='d') gflags.DEFINE_boolean( 'edit', False, 'Edit operation', short_name='e') gflags.DEFINE_boolean( 'list', False, 'List operation', short_name='l') gflags.DEFINE_boolean( 'move', False, 'Move operation', short_name='m') gflags.DEFINE_boolean( 'new', False, 'New operation', short_name='n') gflags.DEFINE_boolean( 'remove', False, 'Remove operation', short_name='r') gflags.DEFINE_boolean(
for index, sentence in enumerate(ptb):
if index == FLAGS.print_latex:
break
print(to_latex(ptb[sentence]))
print(to_latex(report[sentence]))
print()
print(str(corpus_stats(report, ptb)) + '\t' + str(corpus_average_depth(report)))
set_correct, set_total = corpus_stats_labeled(report, ptb_labeled)
correct.update(set_correct)
total.update(set_total)
for key in sorted(total):
print(key + '\t' + str(correct[key] * 1. / total[key]))
if __name__ == '__main__':
gflags.DEFINE_string("main_report_path_template", "./checkpoints/*.report", "A template (with wildcards input as \*) for the paths to the main reports.")
gflags.DEFINE_string("main_data_path", "./snli_1.0/snli_1.0_dev.jsonl", "A template (with wildcards input as \*) for the paths to the main reports.")
gflags.DEFINE_string("ptb_report_path_template", "_", "A template (with wildcards input as \*) for the paths to the PTB reports, or '_' if not available.")
gflags.DEFINE_string("ptb_data_path", "_", "The path to the PTB data in SNLI format, or '_' if not available.")
gflags.DEFINE_boolean("compute_self_f1", True, "Compute self F1 over all reports matching main_report_path_template.")
gflags.DEFINE_boolean("use_random_parses", False, "Replace all report trees with randomly generated trees. Report path template flags are not used when this is set.")
gflags.DEFINE_boolean("use_balanced_parses", False, "Replace all report trees with roughly-balanced binary trees. Report path template flags are not used when this is set.")
gflags.DEFINE_boolean("first_two", False, "Show 'first two' and 'last two' metrics.")
gflags.DEFINE_boolean("neg_pair", False, "Show 'neg_pair' metric.")
gflags.DEFINE_integer("print_latex", 0, "Print this many trees in LaTeX format for each report.")
FLAGS(sys.argv)
run()
import socket
import sys
import webbrowser
import gflags
from six.moves import input
from oauth2client import client
from oauth2client import util
from oauth2client.tools import ClientRedirectHandler
from oauth2client.tools import ClientRedirectServer
FLAGS = gflags.FLAGS
gflags.DEFINE_boolean('auth_local_webserver', True,
('Run a local web server to handle redirects during '
'OAuth authorization.'))
gflags.DEFINE_string('auth_host_name', 'localhost',
('Host name to use when running a local web server to '
'handle redirects during OAuth authorization.'))
gflags.DEFINE_multi_int('auth_host_port', [8080, 8090],
('Port to use when running a local web server to '
'handle redirects during OAuth authorization.'))
@util.positional(2)
def run(flow, storage, http=None):
"""Core code for a command-line application.
"""GFlags for lstm."""
import gflags
gflags.DEFINE_integer("lstm_input_dim", 64, "Input feature dimensions.")
gflags.DEFINE_integer("lstm_hidden_dim", 64, "LSTM hidden dimensions.")
gflags.DEFINE_integer("lstm_num_layers", 2, "Number of lstm layers.")
gflags.DEFINE_boolean("lstm_bias", True, "Extra bias values for the lstm.")
gflags.DEFINE_float("lstm_dropout", 0.0, "LSTM dropout.")
gflags.DEFINE_boolean("lstm_bidirectional", False, "Bidirectional LSTM.")
from lib import windows_advfirewall
import gflags as flags
import logging
FLAGS = flags.FLAGS
flags.DEFINE_string(
'base_directory', '.', 'The base directory to look for acls; '
'typically where you\'d find ./corp and ./prod')
flags.DEFINE_string('definitions_directory', './def',
'Directory where the definitions can be found.')
flags.DEFINE_string('policy_file', None, 'Individual policy file to generate.')
flags.DEFINE_string('output_directory', './',
'Directory to output the rendered acls.')
flags.DEFINE_boolean('optimize',
False,
'Turn on optimization.',
short_name='o')
flags.DEFINE_boolean(
'recursive', True,
'Descend recursively from the base directory rendering acls')
flags.DEFINE_boolean('debug', False, 'Debug messages')
flags.DEFINE_boolean('verbose', False, 'Verbose messages')
flags.DEFINE_list('ignore_directories', 'DEPRECATED, def',
"Don't descend into directories that look like this string")
flags.DEFINE_integer('max_renderers', 10,
'Max number of rendering processes to use.')
flags.DEFINE_boolean(
'shade_check', False,
'Raise an error when a term is completely shaded by a prior term.')
flags.DEFINE_integer(
'exp_info', 2,
with information from the APIs Console <https://code.google.com/apis/console>.
""" % os.path.join(os.path.dirname(__file__), CLIENT_SECRETS)
# Set up a Flow object to be used if we need to authenticate.
FLOW = flow_from_clientsecrets(CLIENT_SECRETS,
scope='https://www.googleapis.com/auth/drive',
message=MISSING_CLIENT_SECRETS_MESSAGE)
gflags.DEFINE_enum('logging_level', 'ERROR',
['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
'Set the level of logging detail.')
gflags.DEFINE_string('destination',
'downloaded/',
'Destination folder location',
short_name='d')
gflags.DEFINE_boolean('debug', False, 'Log folder contents as being fetched')
gflags.DEFINE_string('logfile', 'drive.log',
'Location of file to write the log')
gflags.DEFINE_string('drive_id', 'root',
'ID of the folder whose contents are to be fetched')
def open_logfile():
if not re.match('^/', FLAGS.logfile):
FLAGS.logfile = FLAGS.destination + FLAGS.logfile
global LOG_FILE
LOG_FILE = open(FLAGS.logfile, 'w+')
def log(str):
LOG_FILE.write((str + '\n').encode('utf8'))
#!/usr/bin/env python3
import os
import gflags
FLAGS = gflags.FLAGS
from common import INF
from logprob import logsum, logprod, LOGZERO
from cube import Cube
import logger
gflags.DEFINE_boolean(
'minimize_path_cost',
False,
'This fix the bug that path with cost closest to 0 is considered best.')
def escape_quote(s):
return s.replace('"', r'\"')
class Node(object):
def __init__(self):
self.incoming = []
self.nout = 0 # number of outgoing edges
self.hg = None # hypergraph this node belongs to
self.best_paths_list = None
def add_incoming(self, edge):
self.incoming.append(edge)
edge.head = self
def best_paths(self):
import sys
logs = sys.stderr
import model
from collections import defaultdict
import gflags as flags
FLAGS = flags.FLAGS
from deptree import DepTree, DepVal
flags.DEFINE_boolean("use_gold_tags", False,
"simulate training with gold_tags")
flags.DEFINE_boolean(
"limit_unk_tags", False,
"limit the possible tags for unk words depending on its chars (only for Chinese)"
)
flags.DEFINE_boolean(
"presuf", False,
"prefix and suffix of the words (for both Chinese and English)")
import copy
class NewState(object):
'''stack is a list of DepTrees.
status=0/1/2=SH/LR/RR.
score is forward (accumulative) cost.
step is the number of steps.
[i,j] span boundaries (next word is sent[j]).
feats is features before concatenation with LEFT/RIGHT/SHIFT.
short_name='t')
gflags.DEFINE_string('batchfile',
None, 'A file containing a description of '
'packages to be downloaded.',
short_name='b')
gflags.DEFINE_string('nfshost',
None,
'The path to an NFS share on the host.',
short_name='h')
gflags.DEFINE_string('nfsguest',
None,
'The path to an NFS share on the guest.',
short_name='g')
gflags.DEFINE_boolean(
'textout',
False, 'Activate text output for analysis '
'results. By default, the results are output to a binary '
'protocol buffer.',
short_name='a')
gflags.DEFINE_integer('processes',
1,
'Number of concurrent analysis processes.',
short_name='p')
gflags.DEFINE_boolean('snapshot',
True, 'Activate snapshot mode, which avoids '
'writing modifications to the VM image.',
short_name='s')
gflags.DEFINE_boolean('updatebroker',
False, 'Update the broker package on the '
'VM image before proceeding with the analysis.',
short_name='u')
import gflags
import makani
from makani.lib.log_synchronizer import auto_upload
from makani.lib.python.batch_sim import gcloud_util
gflags.DEFINE_string('config_path',
os.path.join(makani.HOME,
'lib/log_synchronizer/logsync_config.json'),
'The configuration file on the cloud or local.')
gflags.DEFINE_list('collections', None,
'Collections to synchronize (default is all).')
gflags.DEFINE_list('systems', None,
'Systems to synchronize (default is all).')
gflags.DEFINE_boolean('debug', False, 'Produces debugging output.')
FLAGS = gflags.FLAGS
class SynchronizerError(RuntimeError):
"""Error raised to signal failures during synchronizing the logs."""
class Synchronizer(object):
"""The log synchronizer that automatically checks and uploads new logs."""
def __init__(self, config_file):
"""Initialize the synchronizer.
Args:
from modules.drivers.proto import mobileye_pb2
from modules.planning.proto import planning_pb2
from modules.canbus.proto import chassis_pb2
from modules.localization.proto import localization_pb2
from path_decider import PathDecider
from speed_decider import SpeedDecider
from trajectory_generator import TrajectoryGenerator
from provider_mobileye import MobileyeProvider
from provider_chassis import ChassisProvider
from provider_localization import LocalizationProvider
from provider_routing import RoutingProvider
gflags.DEFINE_integer('max_cruise_speed', 20,
'max speed for cruising in meter per second')
gflags.DEFINE_boolean('enable_follow', False, 'enable follow function.')
gflags.DEFINE_boolean('enable_routing_aid', True,
'enable planning leveraging routing information.')
gflags.DEFINE_string('navigation_planning_node_name', 'navigation_planning',
'node name for navigation planning.')
gflags.DEFINE_string('navigation_planning_topic', '/apollo/planning',
'navigation planning publish topic.')
planning_pub = None
log_file = None
path_decider = None
speed_decider = None
traj_generator = None
mobileye_provider = None
chassis_provider = None
localization_provider = None
#! /usr/bin/env python
# coding: utf-8
import gflags
import logging
import traceback
import re
from pygaga.helpers.logger import log_init
from pygaga.helpers.dbutils import get_db_engine
from pygaga.helpers.urlutils import download, parse_html
from loan import Loan
logger = logging.getLogger('CrawlLogger')
FLAGS = gflags.FLAGS
gflags.DEFINE_boolean('debug_parser', False, 'is debug?')
DEFAULT_UA = "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/4.0)"
REFEREE = "https://www.tzydb.com"
ID_RE = re.compile("\(([^)]*)\)")
def download_page(url, headers, max_retry_count=5):
return download(url, headers, max_retry=max_retry_count, throw_on_banned=True)
def crawl():
company_id = 11
url = "https://www.tzydb.com"
request_headers = {'User-Agent': DEFAULT_UA}
offset -= native_hz
emitted += 1 # adjust for emitting 1 output sample
chan_buffers = tuple(c[need:] for c in chan_buffers)
now = time.time()
if now - last_flush >= 0.99: # flush every second
sys.stdout.flush()
last_flush = now
except KeyboardInterrupt:
print >>sys.stderr, "interrupted"
mon.StopDataCollection()
if __name__ == '__main__':
# Define flags here to avoid conflicts with people who use us as a library
flags.DEFINE_boolean("status", None, "Print power meter status")
flags.DEFINE_integer("avg", None,
"Also report average over last n data points")
flags.DEFINE_float("voltage", None, "Set output voltage (0 for off)")
flags.DEFINE_float("current", None, "Set max output current")
flags.DEFINE_string("usbpassthrough", None, "USB control (on, off, auto)")
flags.DEFINE_integer("samples", None,
"Collect and print this many samples. "
"-1 means collect indefinitely.")
flags.DEFINE_integer("hz", 5000, "Print this many samples/sec")
flags.DEFINE_string("device", None,
"Path to the device in /dev/... (ex:/dev/ttyACM1)")
flags.DEFINE_integer("serialno", None, "Look for a device with this serial number")
flags.DEFINE_boolean("timestamp", None,
"Also print integer (seconds) timestamp on each line")
flags.DEFINE_boolean("ramp", True, "Gradually increase voltage")
USER = os.environ['USER']
HOME_DIR = '/home/%s/trunk/src' % USER
SCRIPTS_DIR = HOME_DIR + '/scripts'
DEVSERVER_DIR = HOME_DIR + '/platform/dev'
# Paths to image signing directory and dev key.
VBOOT_REF_DIR = HOME_DIR + '/platform/vboot_reference'
IMG_SIGN_DIR = VBOOT_REF_DIR + '/scripts/image_signing'
DEVKEYS = VBOOT_REF_DIR + '/tests/devkeys'
FLAGS = gflags.FLAGS
gflags.DEFINE_string('board', None, 'Platform to build.')
gflags.DEFINE_string('base_image', None, 'Path to base image.')
gflags.DEFINE_string('firmware_updater', None, 'Path to firmware updater.')
gflags.DEFINE_boolean('start_devserver', False, 'Start devserver.')
class KillableProcess():
"""A killable process.
"""
running_process = None
def __init__(self, cmd, timeout=60, cwd=CWD):
"""Initialize process
Args:
cmd: command to run.
"""
self.cmd = shlex.split(cmd)
self.cmd_timeout = timeout
if not gflags.FLAGS.is_parsed():
gflags.FLAGS(sys.argv)
cluster = util.cluster_from_json(gflags.FLAGS.cluster_config_path)
cluster.update_metadata(False)
CleanUp(Scenario(cluster=cluster))()
if __name__ == "__main__":
gflags.DEFINE_string("path", None, "Test file pattern.", short_name="p")
gflags.DEFINE_integer("num_procs", 6,
"Number of parallel test processes to run")
gflags.DEFINE_string("cluster_config_path", None,
"Path to the cluster configuration file.")
gflags.DEFINE_string("curie_vmdk_goldimages_dir", None,
"Path to the Curie worker goldimages")
gflags.DEFINE_boolean("debug", True, "If True, enable DEBUG log messages.")
gflags.FLAGS(sys.argv)
curie_log.initialize(logtostderr=True, debug=gflags.FLAGS.debug)
proto_patch_encryption_support(curie_server_state_pb2.CurieSettings)
proto_patch_encryption_support(curie_test_pb2.CurieTestConfiguration)
proto_patch_encryption_support(curie_types_pb2.ConnectionParams)
cluster_cleanup()
try:
# Replace tags inside parentheses with an empty string, e.g.
# 'integration/steps/test_meta.py (AHV)' becomes
# 'integration/steps/test_meta.py'.
path = re.sub(r'\s+\(.*\)\s*', r'', gflags.FLAGS.path)
success = nose.run(argv=[
