def unknown_future_import_is_parser_error():
source = """#!/usr/bin/env python
from __future__ import blah
"""
try:
parser.parse(source)
assert False
except SyntaxError as error:
assert_equal("Unknown __future__ import: 'blah'", error.msg)
def test_error_if_signature_is_not_consumed():
source = """
#:: int -> int
"""
try:
parser.parse(source)
assert False, "Expected SyntaxError"
except SyntaxError as error:
assert_equal("explicit type is not valid here", error.msg)
assert_equal(2, error.lineno)
assert_equal(0, error.offset)
def custom_syntax_errors_have_position():
source = """
class(**bases):
pass
"""
try:
parser.parse(source, filename="breathing-underwater.py")
assert False, "Expected SyntaxError"
except SyntaxError as error:
assert_equal("breathing-underwater.py", error.filename)
assert_equal(2, error.lineno)
assert_equal(6, error.offset)
def module_is_executable_if_it_has_shebang():
source = """#!/usr/bin/env python
print(1)
"""
module_node = parser.parse(source)
assert module_node.is_executable
def can_parse_import_from_in_current_package_and_one_name():
source = """
from . import message
"""
module_node = parser.parse(source)
expected_node = nodes.import_from(["."], [nodes.import_alias("message", None)])
assert_equal(expected_node, module_node.body[0])
def can_parse_import_package():
source = """
import messages
"""
module_node = parser.parse(source)
expected_node = nodes.Import([nodes.import_alias("messages", None)])
assert_equal(expected_node, module_node.body[0])
def known_future_import_is_ignored():
# As of Python 3.4, all valid future imports are mandatory
source = """#!/usr/bin/env python
from __future__ import unicode_literals
"""
module_node = parser.parse(source)
assert_equal([], module_node.body)
def can_parse_import_alias():
source = """
from . import message as m
"""
module_node = parser.parse(source)
expected_node = nodes.import_from(["."], [nodes.import_alias("message", "m")])
assert_equal(expected_node, module_node.body[0])
def _parse_expression(source, filename=None):
module = parser.parse(source, filename=filename)
assert isinstance(module, nodes.Module)
expression_statement = module.body[0]
assert isinstance(expression_statement, nodes.ExpressionStatement)
return expression_statement.value
def function_can_have_no_signature_if_it_takes_no_args():
source = """
def f():
pass
"""
module_node = parser.parse(source)
expected = nodes.func("f", nodes.args([]), [], type=None)
assert_equal(expected, module_node.body[0])
def module_is_treated_as_empty_if_empty_directive_is_at_top():
source = """#:nope treat-as-empty
x = 1
"""
module_node = parser.parse(source)
assert not module_node.is_executable
assert_equal([], module_node.body)
def optional_arg_can_have_default_value_of_none(self):
source = """
#:: ?str -> str
def f(x=None):
pass
"""
module_node = parser.parse(source)
expected = nodes.args([nodes.arg("x", optional=True)])
assert_equal(expected, module_node.body[0].args)
def can_parse_import_from_with_relative_import_of_child_module():
source = """
from .x.y import message
"""
module_node = parser.parse(source)
expected_node = nodes.import_from([".", "x", "y"], [
nodes.import_alias("message", None),
])
assert_equal(expected_node, module_node.body[0])
def can_parse_absolute_import_from():
source = """
from x.y import message
"""
module_node = parser.parse(source)
expected_node = nodes.import_from(["x", "y"], [
nodes.import_alias("message", None),
])
assert_equal(expected_node, module_node.body[0])
def test_type_definitions_can_appear_between_statements():
source = """
#:type Identifier = int | str
Identifier = None
"""
module_node = parser.parse(source)
expected_node = nodes.TypeDefinition(
"Identifier",
nodes.type_union([nodes.ref("int"), nodes.ref("str")])
)
assert_equal(expected_node, module_node.body[0])
assert_equal(1, len(module_node.body))
def can_parse_signature_comment_with_no_args_for_function_after_indent():
source = """
#:: -> str
def f():
#:: -> int
def g():
pass
"""
module_node = parser.parse(source)
signature = nodes.signature(returns=nodes.ref("int"))
expected = nodes.func("g", nodes.args([]), [], type=signature)
assert_equal(expected, module_node.body[0].body[0])
def can_have_required_arguments_before_optional_arguments(self):
source = """
#:: str, str, ?str, ?str -> str
def f(a, b, c=None, d=None):
pass
"""
module_node = parser.parse(source)
expected = nodes.args([
nodes.arg("a"),
nodes.arg("b"),
nodes.arg("c", optional=True),
nodes.arg("d", optional=True),
])
assert_equal(expected, module_node.body[0].args)
def _assert_syntax_error(description, source):
try:
parser.parse(source)
assert False, "Expected SyntaxError"
except SyntaxError as error:
assert_equal(description, error.msg)
def _assert_statement_parse(expected, source):
module = parser.parse(source)
assert isinstance(module, nodes.Module)
assert_equal(expected, module.body[0])
def module_is_not_executable_if_it_is_missing_shebang():
source = """print(1)
"""
module_node = parser.parse(source)
assert not module_node.is_executable
