Python OptionParser.parse_command_line方法代码示例

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
def load_config():
    options = OptionParser()
    options.define('port', default=8888, help='run on the given port', type=int)
    options.define('debug', default=False, help='run in debug mode')
    options.define('api_allowed_host', default='localhost', help='origin host that has access to API')
    options.define('history_size', default=50, help='number of tweets stored in memoty', type=int)
    options.define('config', type=str, help='path to config file',
                   callback=lambda path: options.parse_config_file(path, final=False))
    options.define('logging', default='error', help='logging level')
    options.parse_command_line()
    return options

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
 def test_help(self):
     options = OptionParser()
     try:
         orig_stderr = sys.stderr
         sys.stderr = StringIO()
         with self.assertRaises(SystemExit):
             options.parse_command_line(["main.py", "--help"])
         usage = sys.stderr.getvalue()
     finally:
         sys.stderr = orig_stderr
     self.assertIn("Usage:", usage)

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
 def test_dash_underscore_cli(self):
     # Dashes and underscores should be interchangeable.
     for defined_name in ['foo-bar', 'foo_bar']:
         for flag in ['--foo-bar=a', '--foo_bar=a']:
             options = OptionParser()
             options.define(defined_name)
             options.parse_command_line(['main.py', flag])
             # Attr-style access always uses underscores.
             self.assertEqual(options.foo_bar, 'a')
             # Dict-style access allows both.
             self.assertEqual(options['foo-bar'], 'a')
             self.assertEqual(options['foo_bar'], 'a')

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
    def test_mock_patch(self):
        # ensure that our setattr hooks don't interfere with mock.patch
        options = OptionParser()
        options.define('foo', default=1)
        options.parse_command_line(['main.py', '--foo=2'])
        self.assertEqual(options.foo, 2)

        with mock.patch.object(options.mockable(), 'foo', 3):
            self.assertEqual(options.foo, 3)
        self.assertEqual(options.foo, 2)

        # Try nested patches mixed with explicit sets
        with mock.patch.object(options.mockable(), 'foo', 4):
            self.assertEqual(options.foo, 4)
            options.foo = 5
            self.assertEqual(options.foo, 5)
            with mock.patch.object(options.mockable(), 'foo', 6):
                self.assertEqual(options.foo, 6)
            self.assertEqual(options.foo, 5)
        self.assertEqual(options.foo, 2)

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
    def test_subcommand(self):
        base_options = OptionParser()
        base_options.define("verbose", default=False)
        sub_options = OptionParser()
        sub_options.define("foo", type=str)
        rest = base_options.parse_command_line(
            ["main.py", "--verbose", "subcommand", "--foo=bar"])
        self.assertEqual(rest, ["subcommand", "--foo=bar"])
        self.assertTrue(base_options.verbose)
        rest2 = sub_options.parse_command_line(rest)
        self.assertEqual(rest2, [])
        self.assertEqual(sub_options.foo, "bar")

        # the two option sets are distinct
        try:
            orig_stderr = sys.stderr
            sys.stderr = StringIO()
            with self.assertRaises(Error):
                sub_options.parse_command_line(["subcommand", "--verbose"])
        finally:
            sys.stderr = orig_stderr

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
 def test_types(self):
     options = OptionParser()
     options.define('str', type=str)
     options.define('basestring', type=basestring_type)
     options.define('int', type=int)
     options.define('float', type=float)
     options.define('datetime', type=datetime.datetime)
     options.define('timedelta', type=datetime.timedelta)
     options.parse_command_line(['main.py',
                                 '--str=asdf',
                                 '--basestring=qwer',
                                 '--int=42',
                                 '--float=1.5',
                                 '--datetime=2013-04-28 05:16',
                                 '--timedelta=45s'])
     self.assertEqual(options.str, 'asdf')
     self.assertEqual(options.basestring, 'qwer')
     self.assertEqual(options.int, 42)
     self.assertEqual(options.float, 1.5)
     self.assertEqual(options.datetime,
                      datetime.datetime(2013, 4, 28, 5, 16))
     self.assertEqual(options.timedelta, datetime.timedelta(seconds=45))

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
    def test_parse_callbacks(self):
        options = OptionParser()
        self.called = False
        def callback():
            self.called = True
        options.add_parse_callback(callback)

        # non-final parse doesn't run callbacks
        options.parse_command_line(["main.py"], final=False)
        self.assertFalse(self.called)

        # final parse does
        options.parse_command_line(["main.py"])
        self.assertTrue(self.called)

        # callbacks can be run more than once on the same options
        # object if there are multiple final parses
        self.called = False
        options.parse_command_line(["main.py"])
        self.assertTrue(self.called)

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
 def test_parse_command_line(self):
     options = OptionParser()
     options.define("port", default=80)
     options.parse_command_line(["main.py", "--port=443"])
     self.assertEqual(options.port, 443)

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
 def test_multiple_int(self):
     options = OptionParser()
     options.define('foo', type=int, multiple=True)
     options.parse_command_line(['main.py', '--foo=1,3,5:7'])
     self.assertEqual(options.foo, [1, 3, 5, 6, 7])

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
 def test_multiple_string(self):
     options = OptionParser()
     options.define('foo', type=str, multiple=True)
     options.parse_command_line(['main.py', '--foo=a,b,c'])
     self.assertEqual(options.foo, ['a', 'b', 'c'])

# 需要导入模块: from tornado.options import OptionParser [as 别名]
# 或者: from tornado.options.OptionParser import parse_command_line [as 别名]
    handlers.extend(BodyRouter.urls)

    # Create multiplexer
    router = MultiplexConnection.get(objClass=HijackConnection)

    # Register multiplexer
    HijackRouter = SockJSRouter(router, '/hijack')
    handlers.extend(HijackRouter.urls)

    options = OptionParser()
    options.define("port", default=8002, help="run on the given port", type=int)
    options.define("proxyport", default=8989, help="port the proxy is running on", type=int)
    options.define("proxyhost", default=None, help="host the proxy is running on", type=str)
    options.define("mongourl", default="localhost:27017", help="mongodb url", type=str)

    options.parse_command_line()

    db = motor.MotorClient('mongodb://'+options.mongourl, tz_aware=True)
    
    db.proxyservice['origins'].create_index("origin", background=True)

    ui_methods={'nice_headers': BaseRequestHandler.nice_headers}
    settings = dict(
        handlers=handlers,
        static_path=os.path.join(os.path.dirname(__file__), 'static'),
        db=db,
        template_path=os.path.join(os.path.dirname(__file__), "templates"),
        proxyhost=options.proxyhost,
        proxyport=options.proxyport,
        debug=True,
        ui_methods=ui_methods