Python: module clingo.ast

clingo.ast

The clingo.ast-5.1.0 module. The grammar below defines valid ASTs. For each upper case identifier there is a matching function in the module. Arguments follow in paranthesis: each having a type given on the right-hand side of the colon. The symbols ?, *, and + are used to denote optional arguments (None encodes abscence), list arguments, and non-empty list arguments. -- Terms term = Symbol ( location : Location , symbol : clingo.Symbol ) | Variable ( location : Location , name : str ) | UnaryOperation ( location : Location , operator : UnaryOperator , argument : term ) | BinaryOperation ( location : Location , operator : BinaryOperator , left : term , right : term ) | Interval ( location : Location , left : term , right : term ) | Function ( location : Location , name : str , arguments : term* , external : bool ) | Pool ( location : Location , arguments : term* ) csp_term = CSPSum ( location : Location , terms : CSPProduct ( location : Location , coefficient : term , variable : term? )* theory_term = Symbol ( location : Location , symbol : clingo.Symbol ) | Variable ( location : Location , name : str ) | TheoryTermSequence ( location : Location , sequence_type : TheorySequenceType , terms : theory_term* ) | TheoryFunction ( location : Location , name : str , arguments : theory_term* ) | TheoryUnparsedTerm ( location : Location , elements : TheoryUnparsedTermElement ( operators : str* , term : theory_term )+ ) -- Literals symbolic_atom = SymbolicAtom ( term : term ) literal = Literal ( location : Location , sign : Sign , atom : Comparison ( comparison : ComparisonOperator , left : term , right : term ) | BooleanConstant ( value : bool ) | symbolic_atom ) | CSPLiteral ( location : Location , term : csp_term , guards : CSPGuard ( comparison : ComparisonOperator , term : csp_term )+ -- Head and Body Literals aggregate_guard = AggregateGuard ( comparison : ComparisonOperator , term : term ) conditional_literal = ConditionalLiteral ( location : Location , literal : Literal , condition : Literal* ) aggregate = Aggregate ( location : Location , left_guard : aggregate_guard? , elements : conditional_literal* , right_guard : aggregate_guard? ) theory_atom = TheoryAtom ( location : Location , term : term , elements : TheoryAtomElement ( tuple : theory_term* , condition : literal* )* , guard : TheoryGuard ( operator_name : str , term : theory_term )? body_atom = aggregate | BodyAggregate ( location : Location , left_guard : aggregate_guard? , function : AggregateFunction , elements : BodyAggregateElement ( tuple : term* , condition : literal* )* , right_guard : aggregate_guard? ) | Disjoint ( location : Location , elements : DisjointElement ( location : Location , tuple : term* , term : csp_term , condition : literal* )* ) | theory_atom body_literal = literal | conditional_literal | Literal ( location : Location , sign : Sign , atom : body_atom ) head = literal | aggregate | HeadAggregate ( location : Location , left_guard : aggregate_guard? , function : AggregateFunction , elements : HeadAggregateElement ( tuple : term* , condition : conditional_literal )* , right_guard : aggregate_guard? ) | Disjunction ( location : Location , elements : conditional_literal* ) | theory_atom -- Theory Definitions theory = TheoryDefinition ( location : Location , name : str , terms : TheoryTermDefinition ( location : Location , name : str , operators : TheoryOperatorDefinition ( location : Location , name : str , priority : int , operator_type : TheoryOperatorType )* ) , atoms : TheoryAtomDefinition ( location : Location , atom_type : TheoryAtomType , name : str , arity : int , elements : str* , guard : TheoryGuardDefinition ( operators : str* , term : str )? ) ) -- Statements statement = Rule ( location : Location , head : head , body : body_literal* ) | Definition ( location : Location , name : str , value : term , is_default : bool | ShowSignature ( location : Location , name : str , arity : int , sign : bool , csp : bool ) | ShowTerm ( location : Location , term : term , body : body_literal* , csp : bool ) | Minimize ( location : Location , weight : term , priority : term , tuple : term* , body : body_literal* ) | Script ( location : Location , script_type : ScriptType , code : str ) | Program ( location : Location , name : str , parameters : Id ( location : Location , id : str )* ) | External ( location : Location , atom : symbolic_atom , body : body_literal* ) | Edge ( location : Location , u : term , v : term , body : body_literal* ) | Heuristic ( location : Location , atom : symbolic_atom , body : body_literal* , bias : term , priority : term , modifier : term ) | ProjectAtom ( location : Location , atom : symbolic_atom , body : body_literal* ) | ProjectSignature ( location : Location , name : str , arity : int , positive : bool )

Classes



object

AST
ASTType
AggregateFunction
BinaryOperator
ComparisonOperator
ScriptType
Sign
TheoryAtomType
TheoryOperatorType
TheorySequenceType
UnaryOperator

class AST(object)

    AST(type, **arguments) -> AST Node in the abstract syntax tree. Arguments: type -- value in the enumeration ASTType Additionally, the functions takes an arbitrary number of keyword arguments. These should contain the required fields of the node but can also be set later. AST nodes can be structually compared ignoring the location. Note that it is also possible to create AST nodes using one of the functions provided in this module.

Methods defined here:

__contains__(...)
x.__contains__(y) <==> y in x

__delattr__(...)
x.__delattr__('name') <==> del x.name

__delitem__(...)
x.__delitem__(y) <==> del x[y]

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__getattribute__(...)
x.__getattribute__('name') <==> x.name

__getitem__(...)
x.__getitem__(y) <==> x[y]

__gt__(...)
x.__gt__(y) <==> x>y

__iter__(...)
x.__iter__() <==> iter(x)

__le__(...)
x.__le__(y) <==> x<=y

__len__(...)
x.__len__() <==> len(x)

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__setattr__(...)
x.__setattr__('name', value) <==> x.name = value

__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

__str__(...)
x.__str__() <==> str(x)

items(...)
items(self) -> list The list of items of the AST node.

keys(...)
keys(self) -> list The list of keys of the AST node.

values(...)
values(self) -> list The list of values of the AST node.

Data descriptors defined here:

child_keys

List of names of all AST child nodes.

type

The type of the node.

Data and other attributes defined here:

__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

class ASTType(object)

    Enumeration of ast node types.

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

Aggregate = Aggregate

AggregateGuard = AggregateGuard

BinaryOperation = BinaryOperation

BodyAggregate = BodyAggregate

BodyAggregateElement = BodyAggregateElement

BooleanConstant = BooleanConstant

CSPGuard = CSPGuard

CSPLiteral = CSPLiteral

CSPProduct = CSPProduct

CSPSum = CSPSum

Comparison = Comparison

ConditionalLiteral = ConditionalLiteral

Definition = Definition

Disjoint = Disjoint

DisjointElement = DisjointElement

Disjunction = Disjunction

Edge = Edge

External = External

Function = Function

HeadAggregate = HeadAggregate

HeadAggregateElement = HeadAggregateElement

Heuristic = Heuristic

Id = Id

Interval = Interval

Literal = Literal

Minimize = Minimize

Pool = Pool

Program = Program

ProjectAtom = ProjectAtom

ProjectSignature = ProjectSignature

Rule = Rule

Script = Script

ShowSignature = ShowSignature

ShowTerm = ShowTerm

Symbol = Symbol

SymbolicAtom = SymbolicAtom

TheoryAtom = TheoryAtom

TheoryAtomDefinition = TheoryAtomDefinition

TheoryAtomElement = TheoryAtomElement

TheoryDefinition = TheoryDefinition

TheoryFunction = TheoryFunction

TheoryGuard = TheoryGuard

TheoryGuardDefinition = TheoryGuardDefinition

TheoryOperatorDefinition = TheoryOperatorDefinition

TheorySequence = TheorySequence

TheoryTermDefinition = TheoryTermDefinition

TheoryUnparsedTerm = TheoryUnparsedTerm

TheoryUnparsedTermElement = TheoryUnparsedTermElement

UnaryOperation = UnaryOperation

Variable = Variable

class AggregateFunction(object)

    Enumeration of aggegate functions. AggregateFunction.Count   -- the #count function AggregateFunction.Sum     -- the #sum function AggregateFunction.SumPlus -- the #sum+ function AggregateFunction.Min     -- the #min function AggregateFunction.Max     -- the #max function

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

Count = #count

Max = #max

Min = #min

Sum = #sum

SumPlus = #sum+

class BinaryOperator(object)

    Enumeration of binary operators. BinaryOperator.XOr            -- bitwise exclusive or BinaryOperator.Or             -- bitwise or BinaryOperator.And            -- bitwise and BinaryOperator.Plus           -- arithmetic addition BinaryOperator.Minus          -- arithmetic substraction BinaryOperator.Multiplication -- arithmetic multipilcation BinaryOperator.Division       -- arithmetic division BinaryOperator.Modulo         -- arithmetic modulo

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

And = &

Division = /

Minus = -

Modulo = \

Multiplication = *

Or = ?

Plus = +

XOr = ^

class ComparisonOperator(object)

    Enumeration of comparison operators. ComparisonOperator.GreaterThan  -- the > operator ComparisonOperator.LessThan     -- the < operator ComparisonOperator.LessEqual    -- the <= operator ComparisonOperator.GreaterEqual -- the >= operator ComparisonOperator.NotEqual     -- the != operator ComparisonOperator.Equal        -- the = operator

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

Equal = =

GreaterEqual = >=

GreaterThan = >

LessEqual = <=

LessThan = <

NotEqual = !=

class ScriptType(object)

    Enumeration of theory atom types. ScriptType.Python -- python code ScriptType.Lua    -- lua code

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

Lua = lua

Python = python

class Sign(object)

    The available signs for literals. Sign.None           -- Sign.Negation       -- not Sign.DoubleNegation -- not not

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

DoubleNegation = not not

Negation = not

None =

class TheoryAtomType(object)

    Enumeration of theory atom types. TheoryAtomType.Any       -- atom can occur anywhere TheoryAtomType.Body      -- atom can only occur in rule bodies TheoryAtomType.Head      -- atom can only occur in rule heads TheoryAtomType.Directive -- atom can only occrur in facts

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

Any = any

Body = body

Directive = directive

Head = head

class TheoryOperatorType(object)

    Enumeration of operator types. TheoryOperatorType.Unary       -- unary operator TheoryOperatorType.BinaryLeft  -- binary left associative operator TheoryOperatorType.BinaryRight -- binary right associative operator

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:

BinaryLeft = binary, left

BinaryRight = binary, right

Unary = unary

class TheorySequenceType(object)

    Enumeration of theory term sequence types. TheorySequenceType.Tuple -- sequence enclosed in parenthesis TheorySequenceType.List  -- sequence enclosed in brackets TheorySequenceType.Set   -- sequence enclosed in braces

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

left_hand_side(...)
left_hand_side(self) -> str Left-hand side representation of the sequence.

right_hand_side(...)
right_hand_side(self) -> str Right-hand side representation of the sequence.

Data and other attributes defined here:

List = List

Set = Set

Tuple = Tuple

class UnaryOperator(object)

    Enumeration of unary operators. UnaryOperator.Negation -- bitwise negation UnaryOperator.Minus    -- unary minus and classical negation UnaryOperator.Absolute -- absolute value

Methods defined here:

__eq__(...)
x.__eq__(y) <==> x==y

__ge__(...)
x.__ge__(y) <==> x>=y

__gt__(...)
x.__gt__(y) <==> x>y

__hash__(...)
x.__hash__() <==> hash(x)

__le__(...)
x.__le__(y) <==> x<=y

__lt__(...)
x.__lt__(y) <==> x<y

__ne__(...)
x.__ne__(y) <==> x!=y

__repr__(...)
x.__repr__() <==> repr(x)

__str__(...)
x.__str__() <==> str(x)

left_hand_side(...)
left_hand_side(self) -> str Left-hand side representation of the operator.

right_hand_side(...)
right_hand_side(self) -> str Right-hand side representation of the operator.

Data and other attributes defined here:

Absolute = Absolute

Minus = Minus

Negation = Negation

Functions

Aggregate(...)

AggregateGuard(...)

BinaryOperation(...)

BodyAggregate(...)

BodyAggregateElement(...)

BooleanConstant(...)

CSPGuard(...)

CSPLiteral(...)

CSPProduct(...)

CSPSum(...)

Comparison(...)

ConditionalLiteral(...)

Definition(...)

Disjoint(...)

DisjointElement(...)

Disjunction(...)

Edge(...)

External(...)

Function(...)

HeadAggregate(...)

HeadAggregateElement(...)

Heuristic(...)

Id(...)

Interval(...)

Literal(...)

Minimize(...)

Pool(...)

Program(...)

ProjectAtom(...)

ProjectSignature(...)

Rule(...)

Script(...)

ShowSignature(...)

ShowTerm(...)

Symbol(...)

SymbolicAtom(...)

TheoryAtom(...)

TheoryAtomDefinition(...)

TheoryAtomElement(...)

TheoryDefinition(...)

TheoryFunction(...)

TheoryGuard(...)

TheoryGuardDefinition(...)

TheoryOperatorDefinition(...)

TheorySequence(...)

TheoryTermDefinition(...)

TheoryUnparsedTerm(...)

TheoryUnparsedTermElement(...)

UnaryOperation(...)

Variable(...)