Module clingo.ast

Module to work with clingo's non-ground program representation.

Grammar

The grammar below defines valid ASTs. For each upper case identifier there is a matching function in the module. Arguments follow in parenthesis: 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 = SymbolicTerm
        ( location : Location
        , symbol   : clingo.Symbol
        )
     | Variable
        ( location : Location
        , name     : str
        )
     | UnaryOperation
        ( location      : Location
        , operator_type : UnaryOperator
        , argument      : term
        )
     | BinaryOperation
        ( location      : Location
        , operator_type : 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 = SymbolicTerm
               ( location : Location
               , symbol   : clingo.Symbol
               )
            | Variable
               ( location : Location
               , name     : str
               )
            | TheorySequence
               ( 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
                 ( symbol : 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
                             ( terms     : 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
                              ( terms     : term*
                              , condition : literal*
                              )*
             , right_guard : aggregate_guard?
             )
          | Disjoint
             ( location : Location
             , elements : DisjointElement
                           ( location  : Location
                           , terms     : 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
                         ( terms     : term*
                         , condition : conditional_literal
                         )*
        , right_guard : aggregate_guard?
        )
     | Disjunction
        ( location : Location
        , elements : conditional_literal*
        )
     | theory_atom

# 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
             )
          | Defined
             ( location   : Location
             , name       : str
             , arity      : int
             , sign       : bool
             )
          | ShowTerm
             ( location : Location
             , term     : term
             , body     : body_literal*
             , csp      : bool
             )
          | Minimize
             ( location : Location
             , weight   : term
             , priority : term
             , terms    : term*
             , body     : body_literal*
             )
          | Script
             ( location : Location
             , name     : str
             , code     : str
             )
          | Program
             ( location   : Location
             , name       : str
             , parameters : Id
                             ( location : Location
                             , id       : str
                             )*
             )
          | External
             ( location : Location
             , atom     : symbolic_atom
             , body     : body_literal*
             , type     : term
             )
          | 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
             , sign     : bool
             )
          | 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
                           , term      : str
                           , guard     : TheoryGuardDefinition
                                          ( operators : str*
                                          , term      : str
                                          )?
                           )*
             )

Examples

The following example parses a program from a string and passes the resulting AST to the builder:

>>> from clingo import Control, ast
>>> from clingo.ast import Location, ProgramBuilder, Position, parse_string
>>>
>>> ctl = Control()
>>>
>>> with ProgramBuilder(ctl) as bld:
...     # parse from string
...     parse_string('a.', bld.add)
...     # build rule manually
...     pos = Position('<string>', 1, 1)
...     loc = Location(pos, pos)
...     fun = ast.Function(loc, 'b', [], False)
...     atm = ast.SymbolicAtom(fun)
...     lit = ast.Literal(loc, ast.Sign.NoSign, atm)
...     bld.add(ast.Rule(loc, lit, []))
...
>>> ctl.ground([('base', [])])
>>> print(ctl.solve(on_model=print))
a b
SAT

The next example shows how to transform ASTs using the Transformer class:

>>> from clingo.ast import Transformer, Variable, parse_string
>>>
>>> class VariableRenamer(Transformer):
...     def visit_Variable(self, node):
...         return node.update(name='_' + node.name)
...
>>> vrt = VariableRenamer()
>>> parse_string('p(X) :- q(X).', lambda stm: print(str(vrt(stm))))
#program base.
p(_X) :- q(_X).
Expand source code
'''
Module to work with clingo's non-ground program representation.

Grammar
-------
The grammar below defines valid ASTs. For each upper case identifier there is a
matching function in the module. Arguments follow in parenthesis: 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 = SymbolicTerm
        ( location : Location
        , symbol   : clingo.Symbol
        )
     | Variable
        ( location : Location
        , name     : str
        )
     | UnaryOperation
        ( location      : Location
        , operator_type : UnaryOperator
        , argument      : term
        )
     | BinaryOperation
        ( location      : Location
        , operator_type : 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 = SymbolicTerm
               ( location : Location
               , symbol   : clingo.Symbol
               )
            | Variable
               ( location : Location
               , name     : str
               )
            | TheorySequence
               ( 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
                 ( symbol : 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
                             ( terms     : 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
                              ( terms     : term*
                              , condition : literal*
                              )*
             , right_guard : aggregate_guard?
             )
          | Disjoint
             ( location : Location
             , elements : DisjointElement
                           ( location  : Location
                           , terms     : 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
                         ( terms     : term*
                         , condition : conditional_literal
                         )*
        , right_guard : aggregate_guard?
        )
     | Disjunction
        ( location : Location
        , elements : conditional_literal*
        )
     | theory_atom

# 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
             )
          | Defined
             ( location   : Location
             , name       : str
             , arity      : int
             , sign       : bool
             )
          | ShowTerm
             ( location : Location
             , term     : term
             , body     : body_literal*
             , csp      : bool
             )
          | Minimize
             ( location : Location
             , weight   : term
             , priority : term
             , terms    : term*
             , body     : body_literal*
             )
          | Script
             ( location : Location
             , name     : str
             , code     : str
             )
          | Program
             ( location   : Location
             , name       : str
             , parameters : Id
                             ( location : Location
                             , id       : str
                             )*
             )
          | External
             ( location : Location
             , atom     : symbolic_atom
             , body     : body_literal*
             , type     : term
             )
          | 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
             , sign     : bool
             )
          | 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
                           , term      : str
                           , guard     : TheoryGuardDefinition
                                          ( operators : str*
                                          , term      : str
                                          )?
                           )*
             )
```

Examples
--------
The following example parses a program from a string and passes the resulting
`AST` to the builder:

    >>> from clingo import Control, ast
    >>> from clingo.ast import Location, ProgramBuilder, Position, parse_string
    >>>
    >>> ctl = Control()
    >>>
    >>> with ProgramBuilder(ctl) as bld:
    ...     # parse from string
    ...     parse_string('a.', bld.add)
    ...     # build rule manually
    ...     pos = Position('<string>', 1, 1)
    ...     loc = Location(pos, pos)
    ...     fun = ast.Function(loc, 'b', [], False)
    ...     atm = ast.SymbolicAtom(fun)
    ...     lit = ast.Literal(loc, ast.Sign.NoSign, atm)
    ...     bld.add(ast.Rule(loc, lit, []))
    ...
    >>> ctl.ground([('base', [])])
    >>> print(ctl.solve(on_model=print))
    a b
    SAT

The next example shows how to transform ASTs using the `Transformer` class:

    >>> from clingo.ast import Transformer, Variable, parse_string
    >>>
    >>> class VariableRenamer(Transformer):
    ...     def visit_Variable(self, node):
    ...         return node.update(name='_' + node.name)
    ...
    >>> vrt = VariableRenamer()
    >>> parse_string('p(X) :- q(X).', lambda stm: print(str(vrt(stm))))
    #program base.
    p(_X) :- q(_X).
'''

from enum import Enum, IntEnum
from typing import Any, Callable, ContextManager, Dict, List, MutableSequence, NamedTuple, Optional, Sequence, Tuple, Union
from collections import abc
from functools import total_ordering

from ._internal import (_CBData, _Error,
                        _cb_error_handler, _c_call, _ffi, _handle_error, _lib, _str, _to_str)
from .util import Slice, SlicedMutableSequence
from .core import Logger
from .control import Control
from .symbol import Symbol

__all__ = [ 'AST', 'ASTSequence', 'ASTType', 'ASTValue', 'Aggregate',
            'AggregateFunction', 'AggregateGuard', 'BinaryOperation',
            'BinaryOperator', 'BodyAggregate', 'BodyAggregateElement',
            'BooleanConstant', 'Comparison', 'ComparisonOperator',
            'ConditionalLiteral', 'CspGuard', 'CspLiteral', 'CspProduct',
            'CspSum', 'Defined', 'Definition', 'Disjoint', 'DisjointElement',
            'Disjunction', 'Edge', 'External', 'Function', 'HeadAggregate',
            'HeadAggregateElement', 'Heuristic', 'Id', 'Interval', 'Literal',
            'Location', 'Minimize', 'Pool', 'Position', 'Program',
            'ProgramBuilder', 'ProjectAtom', 'ProjectSignature', 'Rule',
            'Script', 'ShowSignature', 'ShowTerm', 'Sign', 'StrSequence',
            'SymbolicTerm', 'TheoryAtom', 'TheoryAtomDefinition',
            'TheoryAtomElement', 'TheoryAtomType', 'TheoryDefinition',
            'TheoryFunction', 'TheoryGuard', 'TheoryGuardDefinition',
            'TheoryOperatorDefinition', 'TheoryOperatorType', 'TheorySequence',
            'TheorySequenceType', 'TheoryTermDefinition', 'TheoryUnparsedTerm',
            'TheoryUnparsedTermElement', 'Transformer', 'UnaryOperation',
            'UnaryOperator', 'Variable', 'parse_files', 'parse_string' ]

# pylint: disable=protected-access,invalid-name,too-many-lines,too-many-ancestors

class ASTType(Enum):
    '''
    Enumeration of ast node types.
    '''
    Id = _lib.clingo_ast_type_id
    Variable = _lib.clingo_ast_type_variable
    SymbolicTerm = _lib.clingo_ast_type_symbolic_term
    UnaryOperation = _lib.clingo_ast_type_unary_operation
    BinaryOperation = _lib.clingo_ast_type_binary_operation
    Interval = _lib.clingo_ast_type_interval
    Function = _lib.clingo_ast_type_function
    Pool = _lib.clingo_ast_type_pool
    CspProduct = _lib.clingo_ast_type_csp_product
    CspSum = _lib.clingo_ast_type_csp_sum
    CspGuard = _lib.clingo_ast_type_csp_guard
    BooleanConstant = _lib.clingo_ast_type_boolean_constant
    SymbolicAtom = _lib.clingo_ast_type_symbolic_atom
    Comparison = _lib.clingo_ast_type_comparison
    CspLiteral = _lib.clingo_ast_type_csp_literal
    AggregateGuard = _lib.clingo_ast_type_aggregate_guard
    ConditionalLiteral = _lib.clingo_ast_type_conditional_literal
    Aggregate = _lib.clingo_ast_type_aggregate
    BodyAggregateElement = _lib.clingo_ast_type_body_aggregate_element
    BodyAggregate = _lib.clingo_ast_type_body_aggregate
    HeadAggregateElement = _lib.clingo_ast_type_head_aggregate_element
    HeadAggregate = _lib.clingo_ast_type_head_aggregate
    Disjunction = _lib.clingo_ast_type_disjunction
    DisjointElement = _lib.clingo_ast_type_disjoint_element
    Disjoint = _lib.clingo_ast_type_disjoint
    TheorySequence = _lib.clingo_ast_type_theory_sequence
    TheoryFunction = _lib.clingo_ast_type_theory_function
    TheoryUnparsedTermElement = _lib.clingo_ast_type_theory_unparsed_term_element
    TheoryUnparsedTerm = _lib.clingo_ast_type_theory_unparsed_term
    TheoryGuard = _lib.clingo_ast_type_theory_guard
    TheoryAtomElement = _lib.clingo_ast_type_theory_atom_element
    TheoryAtom = _lib.clingo_ast_type_theory_atom
    Literal = _lib.clingo_ast_type_literal
    TheoryOperatorDefinition = _lib.clingo_ast_type_theory_operator_definition
    TheoryTermDefinition = _lib.clingo_ast_type_theory_term_definition
    TheoryGuardDefinition = _lib.clingo_ast_type_theory_guard_definition
    TheoryAtomDefinition = _lib.clingo_ast_type_theory_atom_definition
    Rule = _lib.clingo_ast_type_rule
    Definition = _lib.clingo_ast_type_definition
    ShowSignature = _lib.clingo_ast_type_show_signature
    ShowTerm = _lib.clingo_ast_type_show_term
    Minimize = _lib.clingo_ast_type_minimize
    Script = _lib.clingo_ast_type_script
    Program = _lib.clingo_ast_type_program
    External = _lib.clingo_ast_type_external
    Edge = _lib.clingo_ast_type_edge
    Heuristic = _lib.clingo_ast_type_heuristic
    ProjectAtom = _lib.clingo_ast_type_project_atom
    ProjectSignature = _lib.clingo_ast_type_project_signature
    Defined = _lib.clingo_ast_type_defined
    TheoryDefinition = _lib.clingo_ast_type_theory_definition

class AggregateFunction(IntEnum):
    '''
    Enumeration of aggegate functions.
    '''
    Count = _lib.clingo_ast_aggregate_function_count
    '''
    The `#count` function.
    '''
    Max = _lib.clingo_ast_aggregate_function_max
    '''
    The `#max` function.
    '''
    Min = _lib.clingo_ast_aggregate_function_min
    '''
    The `#min` function.
    '''
    Sum = _lib.clingo_ast_aggregate_function_sum
    '''
    The `#sum` function.
    '''
    SumPlus = _lib.clingo_ast_aggregate_function_sump
    '''
    The `#sum+` function.
    '''

class BinaryOperator(IntEnum):
    '''
    Enumeration of binary operators.
    '''
    And = _lib.clingo_ast_binary_operator_and
    '''
    For bitwise and.
    '''
    Division = _lib.clingo_ast_binary_operator_division
    '''
    For arithmetic division.
    '''
    Minus = _lib.clingo_ast_binary_operator_minus
    '''
    For arithmetic subtraction.
    '''
    Modulo = _lib.clingo_ast_binary_operator_modulo
    '''
    For arithmetic modulo.
    '''
    Multiplication = _lib.clingo_ast_binary_operator_multiplication
    '''
    For arithmetic multipilcation.
    '''
    Or = _lib.clingo_ast_binary_operator_or
    '''
    For bitwise or.
    '''
    Plus = _lib.clingo_ast_binary_operator_plus
    '''
    For arithmetic addition.
    '''
    Power = _lib.clingo_ast_binary_operator_power
    '''
    For arithmetic exponentiation.
    '''
    XOr = _lib.clingo_ast_binary_operator_xor
    '''
    For bitwise exclusive or.
    '''

class ComparisonOperator(IntEnum):
    '''
    Enumeration of comparison operators.
    '''
    Equal = _lib.clingo_ast_comparison_operator_equal
    '''
    The `=` operator
    '''
    GreaterEqual = _lib.clingo_ast_comparison_operator_greater_equal
    '''
    The `>=` operator.
    '''
    GreaterThan = _lib.clingo_ast_comparison_operator_greater_than
    '''
    The `>` operator.
    '''
    LessEqual = _lib.clingo_ast_comparison_operator_less_equal
    '''
    The `<=` operator.
    '''
    LessThan = _lib.clingo_ast_comparison_operator_less_than
    '''
    The `<` operator.
    '''
    NotEqual = _lib.clingo_ast_comparison_operator_not_equal
    '''
    The `!=` operator.
    '''

class Sign(IntEnum):
    '''
    Enumeration of signs for literals.
    '''
    DoubleNegation = _lib.clingo_ast_sign_double_negation
    '''
    For double negated literals (with prefix `not not`)
    '''
    Negation = _lib.clingo_ast_sign_negation
    '''
    For negative literals (with prefix `not`).
    '''
    NoSign = _lib.clingo_ast_sign_no_sign
    '''
    For positive literals.
    '''

class TheoryAtomType(IntEnum):
    '''
    Enumeration of theory atom types.
    '''
    Any = _lib.clingo_ast_theory_atom_definition_type_any
    '''
    For atoms that can occur anywhere in a rule.
    '''
    Body = _lib.clingo_ast_theory_atom_definition_type_body
    '''
    For atoms that can only occur in rule bodies.
    '''
    Directive = _lib.clingo_ast_theory_atom_definition_type_directive
    '''
    For atoms that can only occur in facts.
    '''
    Head = _lib.clingo_ast_theory_atom_definition_type_head
    '''
    For atoms that can only occur in rule heads.
    '''

class TheoryOperatorType(IntEnum):
    '''
    Enumeration of operator types.
    '''
    BinaryLeft = _lib.clingo_ast_theory_operator_type_binary_left
    '''
    For binary left associative operators.
    '''
    BinaryRight = _lib.clingo_ast_theory_operator_type_binary_right
    '''
    For binary right associative operator.
    '''
    Unary = _lib.clingo_ast_theory_operator_type_unary
    '''
    For unary operators.
    '''

class TheorySequenceType(IntEnum):
    '''
    Enumeration of theory term sequence types.
    '''
    List = _lib.clingo_ast_theory_sequence_type_list
    '''
    For sequences enclosed in brackets.
    '''
    Set = _lib.clingo_ast_theory_sequence_type_set
    '''
    For sequences enclosed in braces.
    '''
    Tuple = _lib.clingo_ast_theory_sequence_type_tuple
    '''
    For sequences enclosed in parenthesis.
    '''

class UnaryOperator(IntEnum):
    '''
    Enumeration of signs for literals.
    '''
    Absolute = _lib.clingo_ast_unary_operator_absolute
    '''
    For taking the absolute value.
    '''
    Minus = _lib.clingo_ast_unary_operator_minus
    '''
    For unary minus and classical negation.
    '''
    Negation = _lib.clingo_ast_unary_operator_negation
    '''
    For bitwise negation.
    '''

class ASTSequence(abc.MutableSequence):
    '''
    A sequence holding `AST` nodes.
    '''
    def __init__(self, rep, attribute):
        self._rep = rep
        self._attribute = attribute
        _lib.clingo_ast_acquire(self._rep)

    def __del__(self):
        _lib.clingo_ast_release(self._rep)

    def __len__(self) -> int:
        return _c_call('size_t', _lib.clingo_ast_attribute_size_ast_array, self._rep, self._attribute)

    def __getitem__(self, index):
        if isinstance(index, slice):
            return SlicedMutableSequence(self, Slice(index))
        size = len(self)
        if index < 0:
            index += size
        if index < 0 or index >= size:
            raise IndexError('invalid index')
        return AST(_c_call('clingo_ast_t*', _lib.clingo_ast_attribute_get_ast_at, self._rep, self._attribute, index))

    def __iter__(self):
        for index in range(len(self)):
            yield AST(_c_call('clingo_ast_t*', _lib.clingo_ast_attribute_get_ast_at, self._rep, self._attribute, index))

    def __setitem__(self, index, ast):
        if isinstance(index, slice):
            raise TypeError('slicing not implemented')
        _handle_error(_lib.clingo_ast_attribute_set_ast_at(self._rep, self._attribute, index, ast._rep))

    def __delitem__(self, index):
        if isinstance(index, slice):
            raise TypeError('slicing not implemented')
        size = len(self)
        if index < 0:
            index += size
        if index < 0 or index >= size:
            raise IndexError('invalid index')
        _handle_error(_lib.clingo_ast_attribute_delete_ast_at(self._rep, self._attribute, index))

    def insert(self, index, value):
        _handle_error(_lib.clingo_ast_attribute_insert_ast_at(self._rep, self._attribute, index, value._rep))

    def clear(self):
        '''
        Remove all elements from the sequence.
        '''
        for i in range(len(self), 0, -1):
            del self[i - 1]

    def __str__(self):
        return str(list(self))

    def __repr__(self):
        return repr(list(self))

class StrSequence(abc.MutableSequence):
    '''
    A sequence holding strings.
    '''
    def __init__(self, rep, attribute):
        self._attribute = attribute
        self._rep = rep
        _lib.clingo_ast_acquire(self._rep)

    def __del__(self):
        _lib.clingo_ast_release(self._rep)

    def __len__(self) -> int:
        return _c_call('size_t', _lib.clingo_ast_attribute_size_string_array, self._rep, self._attribute)

    def __getitem__(self, index):
        if isinstance(index, slice):
            return SlicedMutableSequence(self, Slice(index))
        size = len(self)
        if index < 0:
            index += size
        if index < 0 or index >= size:
            raise IndexError('invalid index')
        return _to_str(_c_call('char*', _lib.clingo_ast_attribute_get_string_at, self._rep, self._attribute, index))

    def __iter__(self):
        for index in range(len(self)):
            yield _to_str(_c_call('char*', _lib.clingo_ast_attribute_get_string_at, self._rep, self._attribute, index))

    def __setitem__(self, index, value):
        if isinstance(index, slice):
            raise TypeError('slicing not implemented')
        _handle_error(_lib.clingo_str_attribute_set_string_at(self._rep, self._attribute, index, value.encode()))

    def __delitem__(self, index):
        if isinstance(index, slice):
            raise TypeError('slicing not implemented')
        size = len(self)
        if index < 0:
            index += size
        if index < 0 or index >= size:
            raise IndexError('invalid index')
        _handle_error(_lib.clingo_ast_attribute_delete_string_at(self._rep, self._attribute, index))

    def insert(self, index, value):
        _handle_error(_lib.clingo_ast_attribute_insert_string_at(self._rep, self._attribute, index, value.encode()))

    def clear(self):
        '''
        Remove all elements from the sequence.
        '''
        for i in range(len(self), 0, -1):
            del self[i - 1]

    def __str__(self):
        return str(list(self))

    def __repr__(self):
        return repr(list(self))

class Position(NamedTuple):
    '''
    Class to point to a position in a text file.
    '''
    filename: str
    '''
    The file name.
    '''
    line: int
    '''
    The line number in the file.
    '''
    column: int
    '''
    The column number in the line.
    '''

class Location(NamedTuple):
    '''
    Class to point to a range in a text file.
    '''
    begin: Position
    '''
    The beginning of the range.
    '''
    end: Position
    '''
    The end of the range.
    '''

def _c_location(loc: Location):
    mema = _ffi.new('char[]', loc.begin.filename.encode())
    memb = _ffi.new('char[]', loc.end.filename.encode())
    return (_ffi.new('clingo_location_t*', (mema,
                                            memb,
                                            loc.begin.line,
                                            loc.end.line,
                                            loc.begin.column,
                                            loc.end.column)), mema, memb)

def _py_location(rep):
    return Location(
        Position(_to_str(rep.begin_file), rep.begin_line, rep.begin_column),
        Position(_to_str(rep.end_file), rep.end_line, rep.end_column))

_attribute_names = { _to_str(_lib.g_clingo_ast_attribute_names.names[i]): i
                     for i in range(_lib.g_clingo_ast_attribute_names.size) }

ASTValue = Union[str, int, Symbol, Location, None, 'AST', StrSequence, ASTSequence]
ASTUpdate = Union[str, int, Symbol, Location, None, 'AST', Sequence[str], Sequence['AST']]

@total_ordering
class AST:
    '''
    Represents a node in the abstract syntax tree.

    The attributes of an `AST` are tied to its type. They correspond to the
    grammar in the description of the `clingo.ast` module. `AST` nodes can be
    constructed using one of the functions provided in this module.

    Furthermore, AST nodes implement Python's rich comparison operators and are
    ordered structurally ignoring the location. They can also be used as
    dictionary keys. Their string representation corresponds to their gringo
    representation. In fact, the string representation of any AST obtained from
    `parse_files` and `parse_string` can be parsed again. Note that it is
    possible to construct ASTs that are not parsable, though.
    '''
    def __init__(self, rep):
        super().__setattr__('_rep', rep)

    def __eq__(self, other):
        if not isinstance(other, AST):
            return NotImplemented
        return _lib.clingo_ast_equal(self._rep, other._rep)

    def __lt__(self, other):
        if not isinstance(other, AST):
            return NotImplemented
        return _lib.clingo_ast_less_than(self._rep, other._rep)

    def __hash__(self):
        return _lib.clingo_ast_hash(self._rep)

    def __del__(self):
        _lib.clingo_ast_release(self._rep)

    def __getattr__(self, name):
        attr_id = _attribute_names.get(name)
        if attr_id is None or not _c_call('bool', _lib.clingo_ast_has_attribute, self._rep, attr_id):
            raise AttributeError(f'no attribute: {name}')
        attr_type = _c_call('clingo_ast_attribute_type_t', _lib.clingo_ast_attribute_type, self._rep, attr_id)
        if attr_type == _lib.clingo_ast_attribute_type_string:
            return _to_str(_c_call('char*', _lib.clingo_ast_attribute_get_string, self._rep, attr_id))
        if attr_type == _lib.clingo_ast_attribute_type_number:
            return _c_call('int', _lib.clingo_ast_attribute_get_number, self._rep, attr_id)
        if attr_type == _lib.clingo_ast_attribute_type_symbol:
            return Symbol(_c_call('clingo_symbol_t', _lib.clingo_ast_attribute_get_symbol,
                                                self._rep, attr_id))
        if attr_type == _lib.clingo_ast_attribute_type_location:
            return _py_location(_c_call('clingo_location_t', _lib.clingo_ast_attribute_get_location,
                                        self._rep, attr_id))
        if attr_type == _lib.clingo_ast_attribute_type_optional_ast:
            rep = _c_call('clingo_ast_t*', _lib.clingo_ast_attribute_get_optional_ast, self._rep, attr_id)
            return AST(rep) if rep != _ffi.NULL else None
        if attr_type == _lib.clingo_ast_attribute_type_ast:
            return AST(_c_call('clingo_ast_t*', _lib.clingo_ast_attribute_get_ast, self._rep, attr_id))
        if attr_type == _lib.clingo_ast_attribute_type_string_array:
            return StrSequence(self._rep, attr_id)
        assert attr_type == _lib.clingo_ast_attribute_type_ast_array
        return ASTSequence(self._rep, attr_id)

    def __setattr__(self, name, value):
        attr_id = getattr(_lib, f'clingo_ast_attribute_{name}')
        if not _c_call('bool', _lib.clingo_ast_has_attribute, self._rep, attr_id):
            raise AttributeError(f'no attribute: {name}')
        attr_type = _c_call('clingo_ast_attribute_type_t', _lib.clingo_ast_attribute_type, self._rep, attr_id)
        if attr_type == _lib.clingo_ast_attribute_type_string:
            _handle_error(_lib.clingo_ast_attribute_set_string(self._rep, attr_id, value.encode()))
        elif attr_type == _lib.clingo_ast_attribute_type_number:
            _handle_error(_lib.clingo_ast_attribute_set_number(self._rep, attr_id, value))
        elif attr_type == _lib.clingo_ast_attribute_type_symbol:
            _handle_error(_lib.clingo_ast_attribute_set_symbol(self._rep, attr_id, value._rep))
        elif attr_type == _lib.clingo_ast_attribute_type_location:
            c_loc = _c_location(value)
            _handle_error(_lib.clingo_ast_attribute_set_location(self._rep, attr_id, c_loc[0]))
        elif attr_type == _lib.clingo_ast_attribute_type_optional_ast:
            _handle_error(_lib.clingo_ast_attribute_set_optional_ast(self._rep, attr_id,
                          _ffi.NULL if value is None else value._rep))
        elif attr_type == _lib.clingo_ast_attribute_type_ast:
            _handle_error(_lib.clingo_ast_attribute_set_ast(self._rep, attr_id, value._rep))
        elif attr_type == _lib.clingo_ast_attribute_type_string_array:
            if isinstance(value, StrSequence):
                if attr_id == value._attribute and self._rep == value._rep:
                    value = list(value)
            elif not isinstance(value, list):
                value = list(value)
            str_seq = StrSequence(self._rep, attr_id)
            str_seq.clear()
            str_seq.extend(value)
        else:
            assert attr_type == _lib.clingo_ast_attribute_type_ast_array
            if isinstance(value, ASTSequence):
                if attr_id == value._attribute and self._rep == value._rep:
                    value = list(value)
            elif not isinstance(value, list):
                value = list(value)
            ast_seq = ASTSequence(self._rep, attr_id)
            ast_seq.clear()
            ast_seq.extend(value)

    def __str__(self):
        return _str(_lib.clingo_ast_to_string_size, _lib.clingo_ast_to_string, self._rep)

    def __repr__(self):
        name = str(self.ast_type).replace('ASTType', 'ast')
        args = ', '.join(repr(x) for x in self.values())
        return f'{name}({args})'

    def __copy__(self) -> 'AST':
        '''
        Return a shallow copy of the ast.
        '''
        return AST(_c_call('clingo_ast_t*', _lib.clingo_ast_copy, self._rep))

    def __deepcopy__(self, memo) -> 'AST':
        '''
        Return a deep copy of the ast.
        '''
        return AST(_c_call('clingo_ast_t*', _lib.clingo_ast_deep_copy, self._rep))

    def update(self, **kwargs: ASTUpdate) -> 'AST':
        '''
        Return a copy of the AST also updating the given attributes.

        Note that this function returns a reference to self if no arguments are
        given.
        '''
        if not kwargs:
            return self

        args = []
        for key in self.keys():
            if key in kwargs:
                args.append(kwargs[key])
            else:
                args.append(getattr(self, key))

        cons = globals()[str(self.ast_type).replace('ASTType.', '')]
        return cons(*args)

    def items(self) -> List[Tuple[str, ASTValue]]:
        '''
        The list of items of the AST node.
        '''
        return [ (name, getattr(self, name)) for name in self.keys() ]

    def keys(self) -> List[str]:
        '''
        The list of keys of the AST node.
        '''
        cons = _lib.g_clingo_ast_constructors.constructors[self.ast_type.value]
        names = _lib.g_clingo_ast_attribute_names.names
        return [ _to_str(names[cons.arguments[j].attribute]) for j in range(cons.size) ]

    def values(self) -> List[ASTValue]:
        '''
        The list of values of the AST node.
        '''
        return [ (getattr(self, name)) for name in self.keys() ]

    @property
    def ast_type(self) -> ASTType:
        '''
        The type of the node.
        '''
        return ASTType(_c_call('clingo_ast_type_t', _lib.clingo_ast_get_type, self._rep))

    @property
    def child_keys(self) -> List[str]:
        '''
        List of attribute names containing ASTs.
        '''
        cons = _lib.g_clingo_ast_constructors.constructors[self.ast_type.value]
        names = _lib.g_clingo_ast_attribute_names.names
        return [ _to_str(names[cons.arguments[j].attribute])
                 for j in range(cons.size)
                 if cons.arguments[j].type in (_lib.clingo_ast_attribute_type_ast,
                                               _lib.clingo_ast_attribute_type_optional_ast,
                                               _lib.clingo_ast_attribute_type_ast_array) ]

    def unpool(self, other: bool=True, condition: bool=True) -> List['AST']:
        '''
        Unpool the AST returning a list of ASTs without pool terms.

        Parameters
        ----------
        other
            Remove all pools except those in conditions of conditional
            literals.
        condition
            Only remove pools from conditions of conditional literals.
        '''
        unpool_type = 0
        if other:
            unpool_type |= _lib.clingo_ast_unpool_type_other
        if condition:
            unpool_type |= _lib.clingo_ast_unpool_type_condition

        ret: List[AST] = []
        error = _Error()
        cb_data = _CBData(ret.append, error)
        c_cb_data = _ffi.new_handle(cb_data)
        _handle_error(_lib.clingo_ast_unpool(self._rep, unpool_type, _lib.pyclingo_ast_callback, c_cb_data))
        return ret

@_ffi.def_extern(onerror=_cb_error_handler('data'), name='pyclingo_ast_callback')
def _pyclingo_ast_callback(ast, data):
    '''
    Low-level ast callback.
    '''
    callback = _ffi.from_handle(data).data
    _lib.clingo_ast_acquire(ast)
    callback(AST(ast))

    return True

def parse_files(files: Sequence[str], callback: Callable[[AST], None],
                logger: Optional[Logger]=None, message_limit: int=20) -> None:
    '''
    Parse the programs in the given files and return an abstract syntax tree for
    each statement via a callback.

    The function follows clingo's handling of files on the command line. Filename
    `"-"` is treated as stdin and if an empty list is given, then the parser will
    read from stdin.

    Parameters
    ----------
    files
        List of file names.
    callback
        Callable taking an ast as argument.
    logger
        Function to intercept messages normally printed to standard error.
    message_limit
        The maximum number of messages passed to the logger.

    See Also
    --------
    ProgramBuilder
    '''
    if logger is not None:
        c_logger_data = _ffi.new_handle(logger)
        c_logger = _lib.pyclingo_logger_callback
    else:
        c_logger_data = _ffi.NULL
        c_logger = _ffi.NULL

    error = _Error()
    cb_data = _CBData(callback, error)
    c_cb_data = _ffi.new_handle(cb_data)

    _handle_error(_lib.clingo_ast_parse_files([ _ffi.new('char[]', f.encode()) for f in files ], len(files),
                                              _lib.pyclingo_ast_callback, c_cb_data,
                                              c_logger, c_logger_data,
                                              message_limit), cb_data)

def parse_string(program: str, callback: Callable[[AST], None],
                 logger: Optional[Logger]=None, message_limit: int=20) -> None:
    '''
    Parse the given program and return an abstract syntax tree for each
    statement via a callback.

    Parameters
    ----------
    program
        String representation of the program.
    callback
        Callable taking an ast as argument.
    logger
        Function to intercept messages normally printed to standard error.
    message_limit
        The maximum number of messages passed to the logger.

    See Also
    --------
    ProgramBuilder
    '''
    if logger is not None:
        c_logger_data = _ffi.new_handle(logger)
        c_logger = _lib.pyclingo_logger_callback
    else:
        c_logger_data = _ffi.NULL
        c_logger = _ffi.NULL

    error = _Error()
    cb_data = _CBData(callback, error)
    c_cb_data = _ffi.new_handle(cb_data)

    _handle_error(_lib.clingo_ast_parse_string(program.encode(),
                                               _lib.pyclingo_ast_callback, c_cb_data,
                                               c_logger, c_logger_data,
                                               message_limit), cb_data)

class ProgramBuilder(ContextManager['ProgramBuilder']):
    '''
    Object to build non-ground programs.

    Parameters
    ----------
    control
        The `clingo.control.Control` object to attach the builder to.

    See Also
    --------
    parse_string, parse_files

    Notes
    -----
    This class is a context manager and must be used with Python's `with`
    statement.
    '''
    def __init__(self, control: Control):
        self._rep = _c_call('clingo_program_builder_t*', _lib.clingo_control_program_builder, control._rep)

    def __enter__(self):
        _handle_error(_lib.clingo_program_builder_begin(self._rep))
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        _handle_error(_lib.clingo_program_builder_end(self._rep))
        return False

    def add(self, statement: AST) -> None:
        '''
        Adds a statement in form of an `AST` node to the program.

        Parameters
        ----------
        statement
            The statement to add.
        '''
        _handle_error(_lib.clingo_program_builder_add(self._rep, statement._rep))

class Transformer:
    '''
    Utility class to transform ASTs.

    Classes should inherit from this class and implement functions with name
    `visit_<ast_type>` where `<ast_type>` is the type of the ASTs to visit and
    modify. Such a function should return an updated AST or the same AST if no
    change is necessary. The transformer will take care to copy all parent ASTs
    involving a modified child. Note that the class works like a visitor if
    only self references are returned from such functions.

    Any extra arguments passed to the visit method are passed on to child ASTs.
    '''
    def visit(self, ast: AST, *args: Any, **kwargs: Any) -> AST:
        '''
        Dispatch to a visit method in a base class or visit and transform the
        children of the given AST if it is missing.
        '''
        attr = 'visit_' + str(ast.ast_type).replace('ASTType.', '')
        if hasattr(self, attr):
            return getattr(self, attr)(ast, *args, **kwargs)
        return ast.update(**self.visit_children(ast, *args, **kwargs))

    def visit_children(self, ast: AST, *args: Any, **kwargs: Any) -> Dict[str, ASTUpdate]:
        '''
        Visit and transform the children of the given AST.

        Returns
        -------
        The functions returns a dictionary that can be passed to `AST.update`.
        It contains the attributes and values that have been transformed.
        '''
        update: Dict[str, ASTUpdate] = dict()
        for key in ast.child_keys:
            old = getattr(ast, key)
            new = self._dispatch(old, *args, **kwargs)
            if new is not old:
                update[key] = new
        return update

    def visit_sequence(self, sequence: ASTSequence, *args: Any, **kwargs: Any) -> MutableSequence[AST]:
        '''
        Transform a sequence of ASTs returning the same sequnce if there are no
        changes or a list of ASTs otherwise.
        '''
        ret: MutableSequence[AST]
        ret, lst = sequence, []
        for old in sequence:
            lst.append(self(old, *args, **kwargs))
            if lst[-1] is not old:
                ret = lst
        return ret

    def _dispatch(self, ast: Union[None, AST, ASTSequence], *args: Any, **kwargs: Any) -> Union[None, AST, MutableSequence[AST]]:
        '''
        Visit and transform an (optional) AST or a sequence of ASTs.
        '''
        if ast is None:
            return ast

        if isinstance(ast, AST):
            return self.visit(ast, *args, **kwargs) # type: ignore

        if isinstance(ast, abc.Sequence):
            return self.visit_sequence(ast, *args, **kwargs)

        raise TypeError('unexpected type')

    def __call__(self, ast: AST, *args: Any, **kwargs: Any) -> AST:
        '''
        Alternative way to call `Transformer.visit`.
        '''
        return self.visit(ast, *args, **kwargs)

def Id(location: Location, name: str) -> AST:
    '''
    Construct an AST node of type `ASTType.Id`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_id, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode())))
    return AST(p_ast[0])

def Variable(location: Location, name: str) -> AST:
    '''
    Construct an AST node of type `ASTType.Variable`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_variable, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode())))
    return AST(p_ast[0])

def SymbolicTerm(location: Location, symbol: Symbol) -> AST:
    '''
    Construct an AST node of type `ASTType.SymbolicTerm`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_symbolic_term, p_ast,
        c_location[0],
        _ffi.cast('clingo_symbol_t', symbol._rep)))
    return AST(p_ast[0])

def UnaryOperation(location: Location, operator_type: int, argument: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.UnaryOperation`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_unary_operation, p_ast,
        c_location[0],
        _ffi.cast('int', operator_type),
        argument._rep))
    return AST(p_ast[0])

def BinaryOperation(location: Location, operator_type: int, left: AST, right: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.BinaryOperation`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_binary_operation, p_ast,
        c_location[0],
        _ffi.cast('int', operator_type),
        left._rep,
        right._rep))
    return AST(p_ast[0])

def Interval(location: Location, left: AST, right: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.Interval`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_interval, p_ast,
        c_location[0],
        left._rep,
        right._rep))
    return AST(p_ast[0])

def Function(location: Location, name: str, arguments: Sequence[AST], external: int) -> AST:
    '''
    Construct an AST node of type `ASTType.Function`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_function, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in arguments ]),
        _ffi.cast('size_t', len(arguments)),
        _ffi.cast('int', external)))
    return AST(p_ast[0])

def Pool(location: Location, arguments: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Pool`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_pool, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in arguments ]),
        _ffi.cast('size_t', len(arguments))))
    return AST(p_ast[0])

def CspProduct(location: Location, coefficient: AST, variable: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.CspProduct`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_csp_product, p_ast,
        c_location[0],
        coefficient._rep,
        _ffi.NULL if variable is None else variable._rep))
    return AST(p_ast[0])

def CspSum(location: Location, terms: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.CspSum`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_csp_sum, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms))))
    return AST(p_ast[0])

def CspGuard(comparison: int, term: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.CspGuard`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_csp_guard, p_ast,
        _ffi.cast('int', comparison),
        term._rep))
    return AST(p_ast[0])

def BooleanConstant(value: int) -> AST:
    '''
    Construct an AST node of type `ASTType.BooleanConstant`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_boolean_constant, p_ast,
        _ffi.cast('int', value)))
    return AST(p_ast[0])

def SymbolicAtom(symbol: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.SymbolicAtom`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_symbolic_atom, p_ast,
        symbol._rep))
    return AST(p_ast[0])

def Comparison(comparison: int, left: AST, right: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.Comparison`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_comparison, p_ast,
        _ffi.cast('int', comparison),
        left._rep,
        right._rep))
    return AST(p_ast[0])

def CspLiteral(location: Location, term: AST, guards: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.CspLiteral`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_csp_literal, p_ast,
        c_location[0],
        term._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in guards ]),
        _ffi.cast('size_t', len(guards))))
    return AST(p_ast[0])

def AggregateGuard(comparison: int, term: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.AggregateGuard`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_aggregate_guard, p_ast,
        _ffi.cast('int', comparison),
        term._rep))
    return AST(p_ast[0])

def ConditionalLiteral(location: Location, literal: AST, condition: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.ConditionalLiteral`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_conditional_literal, p_ast,
        c_location[0],
        literal._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in condition ]),
        _ffi.cast('size_t', len(condition))))
    return AST(p_ast[0])

def Aggregate(location: Location, left_guard: Optional[AST], elements: Sequence[AST],
              right_guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Aggregate`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_aggregate, p_ast,
        c_location[0],
        _ffi.NULL if left_guard is None else left_guard._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements)),
        _ffi.NULL if right_guard is None else right_guard._rep))
    return AST(p_ast[0])

def BodyAggregateElement(terms: Sequence[AST], condition: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.BodyAggregateElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_body_aggregate_element, p_ast,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in condition ]),
        _ffi.cast('size_t', len(condition))))
    return AST(p_ast[0])

def BodyAggregate(location: Location, left_guard: Optional[AST], function: int, elements: Sequence[AST],
                  right_guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.BodyAggregate`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_body_aggregate, p_ast,
        c_location[0],
        _ffi.NULL if left_guard is None else left_guard._rep,
        _ffi.cast('int', function),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements)),
        _ffi.NULL if right_guard is None else right_guard._rep))
    return AST(p_ast[0])

def HeadAggregateElement(terms: Sequence[AST], condition: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.HeadAggregateElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_head_aggregate_element, p_ast,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        condition._rep))
    return AST(p_ast[0])

def HeadAggregate(location: Location, left_guard: Optional[AST], function: int, elements: Sequence[AST],
                  right_guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.HeadAggregate`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_head_aggregate, p_ast,
        c_location[0],
        _ffi.NULL if left_guard is None else left_guard._rep,
        _ffi.cast('int', function),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements)),
        _ffi.NULL if right_guard is None else right_guard._rep))
    return AST(p_ast[0])

def Disjunction(location: Location, elements: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Disjunction`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_disjunction, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements))))
    return AST(p_ast[0])

def DisjointElement(location: Location, terms: Sequence[AST], term: AST, condition: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.DisjointElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_disjoint_element, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        term._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in condition ]),
        _ffi.cast('size_t', len(condition))))
    return AST(p_ast[0])

def Disjoint(location: Location, elements: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Disjoint`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_disjoint, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements))))
    return AST(p_ast[0])

def TheorySequence(location: Location, sequence_type: int, terms: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheorySequence`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_sequence, p_ast,
        c_location[0],
        _ffi.cast('int', sequence_type),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms))))
    return AST(p_ast[0])

def TheoryFunction(location: Location, name: str, arguments: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryFunction`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_function, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in arguments ]),
        _ffi.cast('size_t', len(arguments))))
    return AST(p_ast[0])

def TheoryUnparsedTermElement(operators: Sequence[str], term: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryUnparsedTermElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_operators = [ _ffi.new('char[]', x.encode()) for x in operators ]
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_unparsed_term_element, p_ast,
        _ffi.new('char*[]', c_operators),
        _ffi.cast('size_t', len(operators)),
        term._rep))
    return AST(p_ast[0])

def TheoryUnparsedTerm(location: Location, elements: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryUnparsedTerm`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_unparsed_term, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements))))
    return AST(p_ast[0])

def TheoryGuard(operator_name: str, term: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryGuard`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_guard, p_ast,
        _ffi.new('char const[]', operator_name.encode()),
        term._rep))
    return AST(p_ast[0])

def TheoryAtomElement(terms: Sequence[AST], condition: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryAtomElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_atom_element, p_ast,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in condition ]),
        _ffi.cast('size_t', len(condition))))
    return AST(p_ast[0])

def TheoryAtom(location: Location, term: AST, elements: Sequence[AST], guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryAtom`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_atom, p_ast,
        c_location[0],
        term._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements)),
        _ffi.NULL if guard is None else guard._rep))
    return AST(p_ast[0])

def Literal(location: Location, sign: int, atom: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.Literal`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_literal, p_ast,
        c_location[0],
        _ffi.cast('int', sign),
        atom._rep))
    return AST(p_ast[0])

def TheoryOperatorDefinition(location: Location, name: str, priority: int, operator_type: int) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryOperatorDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_operator_definition, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', priority),
        _ffi.cast('int', operator_type)))
    return AST(p_ast[0])

def TheoryTermDefinition(location: Location, name: str, operators: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryTermDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_term_definition, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in operators ]),
        _ffi.cast('size_t', len(operators))))
    return AST(p_ast[0])

def TheoryGuardDefinition(operators: Sequence[str], term: str) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryGuardDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_operators = [ _ffi.new('char[]', x.encode()) for x in operators ]
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_guard_definition, p_ast,
        _ffi.new('char*[]', c_operators),
        _ffi.cast('size_t', len(operators)),
        _ffi.new('char const[]', term.encode())))
    return AST(p_ast[0])

def TheoryAtomDefinition(location: Location, atom_type: int, name: str, arity: int, term: str,
                         guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryAtomDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_atom_definition, p_ast,
        c_location[0],
        _ffi.cast('int', atom_type),
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', arity),
        _ffi.new('char const[]', term.encode()),
        _ffi.NULL if guard is None else guard._rep))
    return AST(p_ast[0])

def Rule(location: Location, head: AST, body: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Rule`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_rule, p_ast,
        c_location[0],
        head._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body))))
    return AST(p_ast[0])

def Definition(location: Location, name: str, value: AST, is_default: int) -> AST:
    '''
    Construct an AST node of type `ASTType.Definition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_definition, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        value._rep,
        _ffi.cast('int', is_default)))
    return AST(p_ast[0])

def ShowSignature(location: Location, name: str, arity: int, positive: int, csp: int) -> AST:
    '''
    Construct an AST node of type `ASTType.ShowSignature`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_show_signature, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', arity),
        _ffi.cast('int', positive),
        _ffi.cast('int', csp)))
    return AST(p_ast[0])

def ShowTerm(location: Location, term: AST, body: Sequence[AST], csp: int) -> AST:
    '''
    Construct an AST node of type `ASTType.ShowTerm`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_show_term, p_ast,
        c_location[0],
        term._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body)),
        _ffi.cast('int', csp)))
    return AST(p_ast[0])

def Minimize(location: Location, weight: AST, priority: AST, terms: Sequence[AST], body: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Minimize`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_minimize, p_ast,
        c_location[0],
        weight._rep,
        priority._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body))))
    return AST(p_ast[0])

def Script(location: Location, name: str, code: str) -> AST:
    '''
    Construct an AST node of type `ASTType.Script`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_script, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('char const[]', code.encode())))
    return AST(p_ast[0])

def Program(location: Location, name: str, parameters: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Program`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_program, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in parameters ]),
        _ffi.cast('size_t', len(parameters))))
    return AST(p_ast[0])

def External(location: Location, atom: AST, body: Sequence[AST], external_type: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.External`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_external, p_ast,
        c_location[0],
        atom._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body)),
        external_type._rep))
    return AST(p_ast[0])

def Edge(location: Location, node_u: AST, node_v: AST, body: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Edge`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_edge, p_ast,
        c_location[0],
        node_u._rep,
        node_v._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body))))
    return AST(p_ast[0])

def Heuristic(location: Location, atom: AST, body: Sequence[AST], bias: AST, priority: AST, modifier: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.Heuristic`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_heuristic, p_ast,
        c_location[0],
        atom._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body)),
        bias._rep,
        priority._rep,
        modifier._rep))
    return AST(p_ast[0])

def ProjectAtom(location: Location, atom: AST, body: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.ProjectAtom`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_project_atom, p_ast,
        c_location[0],
        atom._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body))))
    return AST(p_ast[0])

def ProjectSignature(location: Location, name: str, arity: int, positive: int) -> AST:
    '''
    Construct an AST node of type `ASTType.ProjectSignature`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_project_signature, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', arity),
        _ffi.cast('int', positive)))
    return AST(p_ast[0])

def Defined(location: Location, name: str, arity: int, positive: int) -> AST:
    '''
    Construct an AST node of type `ASTType.Defined`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_defined, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', arity),
        _ffi.cast('int', positive)))
    return AST(p_ast[0])

def TheoryDefinition(location: Location, name: str, terms: Sequence[AST], atoms: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_definition, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in atoms ]),
        _ffi.cast('size_t', len(atoms))))
    return AST(p_ast[0])

Functions

def Aggregate(location: Location, left_guard: Optional[AST], elements: Sequence[AST], right_guard: Optional[AST]) ‑> AST

Construct an AST node of type ASTType.Aggregate.

Expand source code
def Aggregate(location: Location, left_guard: Optional[AST], elements: Sequence[AST],
              right_guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Aggregate`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_aggregate, p_ast,
        c_location[0],
        _ffi.NULL if left_guard is None else left_guard._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements)),
        _ffi.NULL if right_guard is None else right_guard._rep))
    return AST(p_ast[0])
def AggregateGuard(comparison: int, term: AST) ‑> AST

Construct an AST node of type ASTType.AggregateGuard.

Expand source code
def AggregateGuard(comparison: int, term: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.AggregateGuard`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_aggregate_guard, p_ast,
        _ffi.cast('int', comparison),
        term._rep))
    return AST(p_ast[0])
def BinaryOperation(location: Location, operator_type: int, left: AST, right: AST) ‑> AST

Construct an AST node of type ASTType.BinaryOperation.

Expand source code
def BinaryOperation(location: Location, operator_type: int, left: AST, right: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.BinaryOperation`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_binary_operation, p_ast,
        c_location[0],
        _ffi.cast('int', operator_type),
        left._rep,
        right._rep))
    return AST(p_ast[0])
def BodyAggregate(location: Location, left_guard: Optional[AST], function: int, elements: Sequence[AST], right_guard: Optional[AST]) ‑> AST

Construct an AST node of type ASTType.BodyAggregate.

Expand source code
def BodyAggregate(location: Location, left_guard: Optional[AST], function: int, elements: Sequence[AST],
                  right_guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.BodyAggregate`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_body_aggregate, p_ast,
        c_location[0],
        _ffi.NULL if left_guard is None else left_guard._rep,
        _ffi.cast('int', function),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements)),
        _ffi.NULL if right_guard is None else right_guard._rep))
    return AST(p_ast[0])
def BodyAggregateElement(terms: Sequence[AST], condition: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.BodyAggregateElement.

Expand source code
def BodyAggregateElement(terms: Sequence[AST], condition: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.BodyAggregateElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_body_aggregate_element, p_ast,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in condition ]),
        _ffi.cast('size_t', len(condition))))
    return AST(p_ast[0])
def BooleanConstant(value: int) ‑> AST

Construct an AST node of type ASTType.BooleanConstant.

Expand source code
def BooleanConstant(value: int) -> AST:
    '''
    Construct an AST node of type `ASTType.BooleanConstant`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_boolean_constant, p_ast,
        _ffi.cast('int', value)))
    return AST(p_ast[0])
def Comparison(comparison: int, left: AST, right: AST) ‑> AST

Construct an AST node of type ASTType.Comparison.

Expand source code
def Comparison(comparison: int, left: AST, right: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.Comparison`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_comparison, p_ast,
        _ffi.cast('int', comparison),
        left._rep,
        right._rep))
    return AST(p_ast[0])
def ConditionalLiteral(location: Location, literal: AST, condition: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.ConditionalLiteral.

Expand source code
def ConditionalLiteral(location: Location, literal: AST, condition: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.ConditionalLiteral`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_conditional_literal, p_ast,
        c_location[0],
        literal._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in condition ]),
        _ffi.cast('size_t', len(condition))))
    return AST(p_ast[0])
def CspGuard(comparison: int, term: AST) ‑> AST

Construct an AST node of type ASTType.CspGuard.

Expand source code
def CspGuard(comparison: int, term: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.CspGuard`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_csp_guard, p_ast,
        _ffi.cast('int', comparison),
        term._rep))
    return AST(p_ast[0])
def CspLiteral(location: Location, term: AST, guards: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.CspLiteral.

Expand source code
def CspLiteral(location: Location, term: AST, guards: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.CspLiteral`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_csp_literal, p_ast,
        c_location[0],
        term._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in guards ]),
        _ffi.cast('size_t', len(guards))))
    return AST(p_ast[0])
def CspProduct(location: Location, coefficient: AST, variable: Optional[AST]) ‑> AST

Construct an AST node of type ASTType.CspProduct.

Expand source code
def CspProduct(location: Location, coefficient: AST, variable: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.CspProduct`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_csp_product, p_ast,
        c_location[0],
        coefficient._rep,
        _ffi.NULL if variable is None else variable._rep))
    return AST(p_ast[0])
def CspSum(location: Location, terms: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.CspSum.

Expand source code
def CspSum(location: Location, terms: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.CspSum`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_csp_sum, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms))))
    return AST(p_ast[0])
def Defined(location: Location, name: str, arity: int, positive: int) ‑> AST

Construct an AST node of type ASTType.Defined.

Expand source code
def Defined(location: Location, name: str, arity: int, positive: int) -> AST:
    '''
    Construct an AST node of type `ASTType.Defined`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_defined, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', arity),
        _ffi.cast('int', positive)))
    return AST(p_ast[0])
def Definition(location: Location, name: str, value: AST, is_default: int) ‑> AST

Construct an AST node of type ASTType.Definition.

Expand source code
def Definition(location: Location, name: str, value: AST, is_default: int) -> AST:
    '''
    Construct an AST node of type `ASTType.Definition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_definition, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        value._rep,
        _ffi.cast('int', is_default)))
    return AST(p_ast[0])
def Disjoint(location: Location, elements: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.Disjoint.

Expand source code
def Disjoint(location: Location, elements: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Disjoint`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_disjoint, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements))))
    return AST(p_ast[0])
def DisjointElement(location: Location, terms: Sequence[AST], term: AST, condition: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.DisjointElement.

Expand source code
def DisjointElement(location: Location, terms: Sequence[AST], term: AST, condition: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.DisjointElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_disjoint_element, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        term._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in condition ]),
        _ffi.cast('size_t', len(condition))))
    return AST(p_ast[0])
def Disjunction(location: Location, elements: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.Disjunction.

Expand source code
def Disjunction(location: Location, elements: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Disjunction`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_disjunction, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements))))
    return AST(p_ast[0])
def Edge(location: Location, node_u: AST, node_v: AST, body: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.Edge.

Expand source code
def Edge(location: Location, node_u: AST, node_v: AST, body: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Edge`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_edge, p_ast,
        c_location[0],
        node_u._rep,
        node_v._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body))))
    return AST(p_ast[0])
def External(location: Location, atom: AST, body: Sequence[AST], external_type: AST) ‑> AST

Construct an AST node of type ASTType.External.

Expand source code
def External(location: Location, atom: AST, body: Sequence[AST], external_type: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.External`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_external, p_ast,
        c_location[0],
        atom._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body)),
        external_type._rep))
    return AST(p_ast[0])
def Function(location: Location, name: str, arguments: Sequence[AST], external: int) ‑> AST

Construct an AST node of type ASTType.Function.

Expand source code
def Function(location: Location, name: str, arguments: Sequence[AST], external: int) -> AST:
    '''
    Construct an AST node of type `ASTType.Function`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_function, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in arguments ]),
        _ffi.cast('size_t', len(arguments)),
        _ffi.cast('int', external)))
    return AST(p_ast[0])
def HeadAggregate(location: Location, left_guard: Optional[AST], function: int, elements: Sequence[AST], right_guard: Optional[AST]) ‑> AST

Construct an AST node of type ASTType.HeadAggregate.

Expand source code
def HeadAggregate(location: Location, left_guard: Optional[AST], function: int, elements: Sequence[AST],
                  right_guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.HeadAggregate`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_head_aggregate, p_ast,
        c_location[0],
        _ffi.NULL if left_guard is None else left_guard._rep,
        _ffi.cast('int', function),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements)),
        _ffi.NULL if right_guard is None else right_guard._rep))
    return AST(p_ast[0])
def HeadAggregateElement(terms: Sequence[AST], condition: AST) ‑> AST

Construct an AST node of type ASTType.HeadAggregateElement.

Expand source code
def HeadAggregateElement(terms: Sequence[AST], condition: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.HeadAggregateElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_head_aggregate_element, p_ast,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        condition._rep))
    return AST(p_ast[0])
def Heuristic(location: Location, atom: AST, body: Sequence[AST], bias: AST, priority: AST, modifier: AST) ‑> AST

Construct an AST node of type ASTType.Heuristic.

Expand source code
def Heuristic(location: Location, atom: AST, body: Sequence[AST], bias: AST, priority: AST, modifier: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.Heuristic`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_heuristic, p_ast,
        c_location[0],
        atom._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body)),
        bias._rep,
        priority._rep,
        modifier._rep))
    return AST(p_ast[0])
def Id(location: Location, name: str) ‑> AST

Construct an AST node of type ASTType.Id.

Expand source code
def Id(location: Location, name: str) -> AST:
    '''
    Construct an AST node of type `ASTType.Id`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_id, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode())))
    return AST(p_ast[0])
def Interval(location: Location, left: AST, right: AST) ‑> AST

Construct an AST node of type ASTType.Interval.

Expand source code
def Interval(location: Location, left: AST, right: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.Interval`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_interval, p_ast,
        c_location[0],
        left._rep,
        right._rep))
    return AST(p_ast[0])
def Literal(location: Location, sign: int, atom: AST) ‑> AST

Construct an AST node of type ASTType.Literal.

Expand source code
def Literal(location: Location, sign: int, atom: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.Literal`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_literal, p_ast,
        c_location[0],
        _ffi.cast('int', sign),
        atom._rep))
    return AST(p_ast[0])
def Minimize(location: Location, weight: AST, priority: AST, terms: Sequence[AST], body: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.Minimize.

Expand source code
def Minimize(location: Location, weight: AST, priority: AST, terms: Sequence[AST], body: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Minimize`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_minimize, p_ast,
        c_location[0],
        weight._rep,
        priority._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body))))
    return AST(p_ast[0])
def Pool(location: Location, arguments: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.Pool.

Expand source code
def Pool(location: Location, arguments: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Pool`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_pool, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in arguments ]),
        _ffi.cast('size_t', len(arguments))))
    return AST(p_ast[0])
def Program(location: Location, name: str, parameters: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.Program.

Expand source code
def Program(location: Location, name: str, parameters: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Program`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_program, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in parameters ]),
        _ffi.cast('size_t', len(parameters))))
    return AST(p_ast[0])
def ProjectAtom(location: Location, atom: AST, body: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.ProjectAtom.

Expand source code
def ProjectAtom(location: Location, atom: AST, body: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.ProjectAtom`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_project_atom, p_ast,
        c_location[0],
        atom._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body))))
    return AST(p_ast[0])
def ProjectSignature(location: Location, name: str, arity: int, positive: int) ‑> AST

Construct an AST node of type ASTType.ProjectSignature.

Expand source code
def ProjectSignature(location: Location, name: str, arity: int, positive: int) -> AST:
    '''
    Construct an AST node of type `ASTType.ProjectSignature`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_project_signature, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', arity),
        _ffi.cast('int', positive)))
    return AST(p_ast[0])
def Rule(location: Location, head: AST, body: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.Rule.

Expand source code
def Rule(location: Location, head: AST, body: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.Rule`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_rule, p_ast,
        c_location[0],
        head._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body))))
    return AST(p_ast[0])
def Script(location: Location, name: str, code: str) ‑> AST

Construct an AST node of type ASTType.Script.

Expand source code
def Script(location: Location, name: str, code: str) -> AST:
    '''
    Construct an AST node of type `ASTType.Script`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_script, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('char const[]', code.encode())))
    return AST(p_ast[0])
def ShowSignature(location: Location, name: str, arity: int, positive: int, csp: int) ‑> AST

Construct an AST node of type ASTType.ShowSignature.

Expand source code
def ShowSignature(location: Location, name: str, arity: int, positive: int, csp: int) -> AST:
    '''
    Construct an AST node of type `ASTType.ShowSignature`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_show_signature, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', arity),
        _ffi.cast('int', positive),
        _ffi.cast('int', csp)))
    return AST(p_ast[0])
def ShowTerm(location: Location, term: AST, body: Sequence[AST], csp: int) ‑> AST

Construct an AST node of type ASTType.ShowTerm.

Expand source code
def ShowTerm(location: Location, term: AST, body: Sequence[AST], csp: int) -> AST:
    '''
    Construct an AST node of type `ASTType.ShowTerm`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_show_term, p_ast,
        c_location[0],
        term._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in body ]),
        _ffi.cast('size_t', len(body)),
        _ffi.cast('int', csp)))
    return AST(p_ast[0])
def SymbolicTerm(location: Location, symbol: Symbol) ‑> AST

Construct an AST node of type ASTType.SymbolicTerm.

Expand source code
def SymbolicTerm(location: Location, symbol: Symbol) -> AST:
    '''
    Construct an AST node of type `ASTType.SymbolicTerm`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_symbolic_term, p_ast,
        c_location[0],
        _ffi.cast('clingo_symbol_t', symbol._rep)))
    return AST(p_ast[0])
def TheoryAtom(location: Location, term: AST, elements: Sequence[AST], guard: Optional[AST]) ‑> AST

Construct an AST node of type ASTType.TheoryAtom.

Expand source code
def TheoryAtom(location: Location, term: AST, elements: Sequence[AST], guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryAtom`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_atom, p_ast,
        c_location[0],
        term._rep,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements)),
        _ffi.NULL if guard is None else guard._rep))
    return AST(p_ast[0])
def TheoryAtomDefinition(location: Location, atom_type: int, name: str, arity: int, term: str, guard: Optional[AST]) ‑> AST

Construct an AST node of type ASTType.TheoryAtomDefinition.

Expand source code
def TheoryAtomDefinition(location: Location, atom_type: int, name: str, arity: int, term: str,
                         guard: Optional[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryAtomDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_atom_definition, p_ast,
        c_location[0],
        _ffi.cast('int', atom_type),
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', arity),
        _ffi.new('char const[]', term.encode()),
        _ffi.NULL if guard is None else guard._rep))
    return AST(p_ast[0])
def TheoryAtomElement(terms: Sequence[AST], condition: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.TheoryAtomElement.

Expand source code
def TheoryAtomElement(terms: Sequence[AST], condition: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryAtomElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_atom_element, p_ast,
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in condition ]),
        _ffi.cast('size_t', len(condition))))
    return AST(p_ast[0])
def TheoryDefinition(location: Location, name: str, terms: Sequence[AST], atoms: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.TheoryDefinition.

Expand source code
def TheoryDefinition(location: Location, name: str, terms: Sequence[AST], atoms: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_definition, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms)),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in atoms ]),
        _ffi.cast('size_t', len(atoms))))
    return AST(p_ast[0])
def TheoryFunction(location: Location, name: str, arguments: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.TheoryFunction.

Expand source code
def TheoryFunction(location: Location, name: str, arguments: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryFunction`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_function, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in arguments ]),
        _ffi.cast('size_t', len(arguments))))
    return AST(p_ast[0])
def TheoryGuard(operator_name: str, term: AST) ‑> AST

Construct an AST node of type ASTType.TheoryGuard.

Expand source code
def TheoryGuard(operator_name: str, term: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryGuard`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_guard, p_ast,
        _ffi.new('char const[]', operator_name.encode()),
        term._rep))
    return AST(p_ast[0])
def TheoryGuardDefinition(operators: Sequence[str], term: str) ‑> AST

Construct an AST node of type ASTType.TheoryGuardDefinition.

Expand source code
def TheoryGuardDefinition(operators: Sequence[str], term: str) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryGuardDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_operators = [ _ffi.new('char[]', x.encode()) for x in operators ]
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_guard_definition, p_ast,
        _ffi.new('char*[]', c_operators),
        _ffi.cast('size_t', len(operators)),
        _ffi.new('char const[]', term.encode())))
    return AST(p_ast[0])
def TheoryOperatorDefinition(location: Location, name: str, priority: int, operator_type: int) ‑> AST

Construct an AST node of type ASTType.TheoryOperatorDefinition.

Expand source code
def TheoryOperatorDefinition(location: Location, name: str, priority: int, operator_type: int) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryOperatorDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_operator_definition, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.cast('int', priority),
        _ffi.cast('int', operator_type)))
    return AST(p_ast[0])
def TheorySequence(location: Location, sequence_type: int, terms: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.TheorySequence.

Expand source code
def TheorySequence(location: Location, sequence_type: int, terms: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheorySequence`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_sequence, p_ast,
        c_location[0],
        _ffi.cast('int', sequence_type),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in terms ]),
        _ffi.cast('size_t', len(terms))))
    return AST(p_ast[0])
def TheoryTermDefinition(location: Location, name: str, operators: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.TheoryTermDefinition.

Expand source code
def TheoryTermDefinition(location: Location, name: str, operators: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryTermDefinition`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_term_definition, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode()),
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in operators ]),
        _ffi.cast('size_t', len(operators))))
    return AST(p_ast[0])
def TheoryUnparsedTerm(location: Location, elements: Sequence[AST]) ‑> AST

Construct an AST node of type ASTType.TheoryUnparsedTerm.

Expand source code
def TheoryUnparsedTerm(location: Location, elements: Sequence[AST]) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryUnparsedTerm`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_unparsed_term, p_ast,
        c_location[0],
        _ffi.new('clingo_ast_t*[]', [ x._rep for x in elements ]),
        _ffi.cast('size_t', len(elements))))
    return AST(p_ast[0])
def TheoryUnparsedTermElement(operators: Sequence[str], term: AST) ‑> AST

Construct an AST node of type ASTType.TheoryUnparsedTermElement.

Expand source code
def TheoryUnparsedTermElement(operators: Sequence[str], term: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.TheoryUnparsedTermElement`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_operators = [ _ffi.new('char[]', x.encode()) for x in operators ]
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_theory_unparsed_term_element, p_ast,
        _ffi.new('char*[]', c_operators),
        _ffi.cast('size_t', len(operators)),
        term._rep))
    return AST(p_ast[0])
def UnaryOperation(location: Location, operator_type: int, argument: AST) ‑> AST

Construct an AST node of type ASTType.UnaryOperation.

Expand source code
def UnaryOperation(location: Location, operator_type: int, argument: AST) -> AST:
    '''
    Construct an AST node of type `ASTType.UnaryOperation`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_unary_operation, p_ast,
        c_location[0],
        _ffi.cast('int', operator_type),
        argument._rep))
    return AST(p_ast[0])
def Variable(location: Location, name: str) ‑> AST

Construct an AST node of type ASTType.Variable.

Expand source code
def Variable(location: Location, name: str) -> AST:
    '''
    Construct an AST node of type `ASTType.Variable`.
    '''
    p_ast = _ffi.new('clingo_ast_t**')
    c_location = _c_location(location)
    _handle_error(_lib.clingo_ast_build(
        _lib.clingo_ast_type_variable, p_ast,
        c_location[0],
        _ffi.new('char const[]', name.encode())))
    return AST(p_ast[0])
def parse_files(files: Sequence[str], callback: Callable[[AST], None], logger: Optional[Callable[[MessageCode, str], None]] = None, message_limit: int = 20) ‑> None

Parse the programs in the given files and return an abstract syntax tree for each statement via a callback.

The function follows clingo's handling of files on the command line. Filename "-" is treated as stdin and if an empty list is given, then the parser will read from stdin.

Parameters

files
List of file names.
callback
Callable taking an ast as argument.
logger
Function to intercept messages normally printed to standard error.
message_limit
The maximum number of messages passed to the logger.

See Also

ProgramBuilder

Expand source code
def parse_files(files: Sequence[str], callback: Callable[[AST], None],
                logger: Optional[Logger]=None, message_limit: int=20) -> None:
    '''
    Parse the programs in the given files and return an abstract syntax tree for
    each statement via a callback.

    The function follows clingo's handling of files on the command line. Filename
    `"-"` is treated as stdin and if an empty list is given, then the parser will
    read from stdin.

    Parameters
    ----------
    files
        List of file names.
    callback
        Callable taking an ast as argument.
    logger
        Function to intercept messages normally printed to standard error.
    message_limit
        The maximum number of messages passed to the logger.

    See Also
    --------
    ProgramBuilder
    '''
    if logger is not None:
        c_logger_data = _ffi.new_handle(logger)
        c_logger = _lib.pyclingo_logger_callback
    else:
        c_logger_data = _ffi.NULL
        c_logger = _ffi.NULL

    error = _Error()
    cb_data = _CBData(callback, error)
    c_cb_data = _ffi.new_handle(cb_data)

    _handle_error(_lib.clingo_ast_parse_files([ _ffi.new('char[]', f.encode()) for f in files ], len(files),
                                              _lib.pyclingo_ast_callback, c_cb_data,
                                              c_logger, c_logger_data,
                                              message_limit), cb_data)
def parse_string(program: str, callback: Callable[[AST], None], logger: Optional[Callable[[MessageCode, str], None]] = None, message_limit: int = 20) ‑> None

Parse the given program and return an abstract syntax tree for each statement via a callback.

Parameters

program
String representation of the program.
callback
Callable taking an ast as argument.
logger
Function to intercept messages normally printed to standard error.
message_limit
The maximum number of messages passed to the logger.

See Also

ProgramBuilder

Expand source code
def parse_string(program: str, callback: Callable[[AST], None],
                 logger: Optional[Logger]=None, message_limit: int=20) -> None:
    '''
    Parse the given program and return an abstract syntax tree for each
    statement via a callback.

    Parameters
    ----------
    program
        String representation of the program.
    callback
        Callable taking an ast as argument.
    logger
        Function to intercept messages normally printed to standard error.
    message_limit
        The maximum number of messages passed to the logger.

    See Also
    --------
    ProgramBuilder
    '''
    if logger is not None:
        c_logger_data = _ffi.new_handle(logger)
        c_logger = _lib.pyclingo_logger_callback
    else:
        c_logger_data = _ffi.NULL
        c_logger = _ffi.NULL

    error = _Error()
    cb_data = _CBData(callback, error)
    c_cb_data = _ffi.new_handle(cb_data)

    _handle_error(_lib.clingo_ast_parse_string(program.encode(),
                                               _lib.pyclingo_ast_callback, c_cb_data,
                                               c_logger, c_logger_data,
                                               message_limit), cb_data)

Classes

class AST (rep)

Represents a node in the abstract syntax tree.

The attributes of an AST are tied to its type. They correspond to the grammar in the description of the clingo.ast module. AST nodes can be constructed using one of the functions provided in this module.

Furthermore, AST nodes implement Python's rich comparison operators and are ordered structurally ignoring the location. They can also be used as dictionary keys. Their string representation corresponds to their gringo representation. In fact, the string representation of any AST obtained from parse_files() and parse_string() can be parsed again. Note that it is possible to construct ASTs that are not parsable, though.

Expand source code
class AST:
    '''
    Represents a node in the abstract syntax tree.

    The attributes of an `AST` are tied to its type. They correspond to the
    grammar in the description of the `clingo.ast` module. `AST` nodes can be
    constructed using one of the functions provided in this module.

    Furthermore, AST nodes implement Python's rich comparison operators and are
    ordered structurally ignoring the location. They can also be used as
    dictionary keys. Their string representation corresponds to their gringo
    representation. In fact, the string representation of any AST obtained from
    `parse_files` and `parse_string` can be parsed again. Note that it is
    possible to construct ASTs that are not parsable, though.
    '''
    def __init__(self, rep):
        super().__setattr__('_rep', rep)

    def __eq__(self, other):
        if not isinstance(other, AST):
            return NotImplemented
        return _lib.clingo_ast_equal(self._rep, other._rep)

    def __lt__(self, other):
        if not isinstance(other, AST):
            return NotImplemented
        return _lib.clingo_ast_less_than(self._rep, other._rep)

    def __hash__(self):
        return _lib.clingo_ast_hash(self._rep)

    def __del__(self):
        _lib.clingo_ast_release(self._rep)

    def __getattr__(self, name):
        attr_id = _attribute_names.get(name)
        if attr_id is None or not _c_call('bool', _lib.clingo_ast_has_attribute, self._rep, attr_id):
            raise AttributeError(f'no attribute: {name}')
        attr_type = _c_call('clingo_ast_attribute_type_t', _lib.clingo_ast_attribute_type, self._rep, attr_id)
        if attr_type == _lib.clingo_ast_attribute_type_string:
            return _to_str(_c_call('char*', _lib.clingo_ast_attribute_get_string, self._rep, attr_id))
        if attr_type == _lib.clingo_ast_attribute_type_number:
            return _c_call('int', _lib.clingo_ast_attribute_get_number, self._rep, attr_id)
        if attr_type == _lib.clingo_ast_attribute_type_symbol:
            return Symbol(_c_call('clingo_symbol_t', _lib.clingo_ast_attribute_get_symbol,
                                                self._rep, attr_id))
        if attr_type == _lib.clingo_ast_attribute_type_location:
            return _py_location(_c_call('clingo_location_t', _lib.clingo_ast_attribute_get_location,
                                        self._rep, attr_id))
        if attr_type == _lib.clingo_ast_attribute_type_optional_ast:
            rep = _c_call('clingo_ast_t*', _lib.clingo_ast_attribute_get_optional_ast, self._rep, attr_id)
            return AST(rep) if rep != _ffi.NULL else None
        if attr_type == _lib.clingo_ast_attribute_type_ast:
            return AST(_c_call('clingo_ast_t*', _lib.clingo_ast_attribute_get_ast, self._rep, attr_id))
        if attr_type == _lib.clingo_ast_attribute_type_string_array:
            return StrSequence(self._rep, attr_id)
        assert attr_type == _lib.clingo_ast_attribute_type_ast_array
        return ASTSequence(self._rep, attr_id)

    def __setattr__(self, name, value):
        attr_id = getattr(_lib, f'clingo_ast_attribute_{name}')
        if not _c_call('bool', _lib.clingo_ast_has_attribute, self._rep, attr_id):
            raise AttributeError(f'no attribute: {name}')
        attr_type = _c_call('clingo_ast_attribute_type_t', _lib.clingo_ast_attribute_type, self._rep, attr_id)
        if attr_type == _lib.clingo_ast_attribute_type_string:
            _handle_error(_lib.clingo_ast_attribute_set_string(self._rep, attr_id, value.encode()))
        elif attr_type == _lib.clingo_ast_attribute_type_number:
            _handle_error(_lib.clingo_ast_attribute_set_number(self._rep, attr_id, value))
        elif attr_type == _lib.clingo_ast_attribute_type_symbol:
            _handle_error(_lib.clingo_ast_attribute_set_symbol(self._rep, attr_id, value._rep))
        elif attr_type == _lib.clingo_ast_attribute_type_location:
            c_loc = _c_location(value)
            _handle_error(_lib.clingo_ast_attribute_set_location(self._rep, attr_id, c_loc[0]))
        elif attr_type == _lib.clingo_ast_attribute_type_optional_ast:
            _handle_error(_lib.clingo_ast_attribute_set_optional_ast(self._rep, attr_id,
                          _ffi.NULL if value is None else value._rep))
        elif attr_type == _lib.clingo_ast_attribute_type_ast:
            _handle_error(_lib.clingo_ast_attribute_set_ast(self._rep, attr_id, value._rep))
        elif attr_type == _lib.clingo_ast_attribute_type_string_array:
            if isinstance(value, StrSequence):
                if attr_id == value._attribute and self._rep == value._rep:
                    value = list(value)
            elif not isinstance(value, list):
                value = list(value)
            str_seq = StrSequence(self._rep, attr_id)
            str_seq.clear()
            str_seq.extend(value)
        else:
            assert attr_type == _lib.clingo_ast_attribute_type_ast_array
            if isinstance(value, ASTSequence):
                if attr_id == value._attribute and self._rep == value._rep:
                    value = list(value)
            elif not isinstance(value, list):
                value = list(value)
            ast_seq = ASTSequence(self._rep, attr_id)
            ast_seq.clear()
            ast_seq.extend(value)

    def __str__(self):
        return _str(_lib.clingo_ast_to_string_size, _lib.clingo_ast_to_string, self._rep)

    def __repr__(self):
        name = str(self.ast_type).replace('ASTType', 'ast')
        args = ', '.join(repr(x) for x in self.values())
        return f'{name}({args})'

    def __copy__(self) -> 'AST':
        '''
        Return a shallow copy of the ast.
        '''
        return AST(_c_call('clingo_ast_t*', _lib.clingo_ast_copy, self._rep))

    def __deepcopy__(self, memo) -> 'AST':
        '''
        Return a deep copy of the ast.
        '''
        return AST(_c_call('clingo_ast_t*', _lib.clingo_ast_deep_copy, self._rep))

    def update(self, **kwargs: ASTUpdate) -> 'AST':
        '''
        Return a copy of the AST also updating the given attributes.

        Note that this function returns a reference to self if no arguments are
        given.
        '''
        if not kwargs:
            return self

        args = []
        for key in self.keys():
            if key in kwargs:
                args.append(kwargs[key])
            else:
                args.append(getattr(self, key))

        cons = globals()[str(self.ast_type).replace('ASTType.', '')]
        return cons(*args)

    def items(self) -> List[Tuple[str, ASTValue]]:
        '''
        The list of items of the AST node.
        '''
        return [ (name, getattr(self, name)) for name in self.keys() ]

    def keys(self) -> List[str]:
        '''
        The list of keys of the AST node.
        '''
        cons = _lib.g_clingo_ast_constructors.constructors[self.ast_type.value]
        names = _lib.g_clingo_ast_attribute_names.names
        return [ _to_str(names[cons.arguments[j].attribute]) for j in range(cons.size) ]

    def values(self) -> List[ASTValue]:
        '''
        The list of values of the AST node.
        '''
        return [ (getattr(self, name)) for name in self.keys() ]

    @property
    def ast_type(self) -> ASTType:
        '''
        The type of the node.
        '''
        return ASTType(_c_call('clingo_ast_type_t', _lib.clingo_ast_get_type, self._rep))

    @property
    def child_keys(self) -> List[str]:
        '''
        List of attribute names containing ASTs.
        '''
        cons = _lib.g_clingo_ast_constructors.constructors[self.ast_type.value]
        names = _lib.g_clingo_ast_attribute_names.names
        return [ _to_str(names[cons.arguments[j].attribute])
                 for j in range(cons.size)
                 if cons.arguments[j].type in (_lib.clingo_ast_attribute_type_ast,
                                               _lib.clingo_ast_attribute_type_optional_ast,
                                               _lib.clingo_ast_attribute_type_ast_array) ]

    def unpool(self, other: bool=True, condition: bool=True) -> List['AST']:
        '''
        Unpool the AST returning a list of ASTs without pool terms.

        Parameters
        ----------
        other
            Remove all pools except those in conditions of conditional
            literals.
        condition
            Only remove pools from conditions of conditional literals.
        '''
        unpool_type = 0
        if other:
            unpool_type |= _lib.clingo_ast_unpool_type_other
        if condition:
            unpool_type |= _lib.clingo_ast_unpool_type_condition

        ret: List[AST] = []
        error = _Error()
        cb_data = _CBData(ret.append, error)
        c_cb_data = _ffi.new_handle(cb_data)
        _handle_error(_lib.clingo_ast_unpool(self._rep, unpool_type, _lib.pyclingo_ast_callback, c_cb_data))
        return ret

Instance variables

var ast_typeASTType

The type of the node.

Expand source code
@property
def ast_type(self) -> ASTType:
    '''
    The type of the node.
    '''
    return ASTType(_c_call('clingo_ast_type_t', _lib.clingo_ast_get_type, self._rep))
var child_keys : List[str]

List of attribute names containing ASTs.

Expand source code
@property
def child_keys(self) -> List[str]:
    '''
    List of attribute names containing ASTs.
    '''
    cons = _lib.g_clingo_ast_constructors.constructors[self.ast_type.value]
    names = _lib.g_clingo_ast_attribute_names.names
    return [ _to_str(names[cons.arguments[j].attribute])
             for j in range(cons.size)
             if cons.arguments[j].type in (_lib.clingo_ast_attribute_type_ast,
                                           _lib.clingo_ast_attribute_type_optional_ast,
                                           _lib.clingo_ast_attribute_type_ast_array) ]

Methods

def items(self) ‑> List[Tuple[str, Union[str, int, SymbolLocation, None, ASTStrSequenceASTSequence]]]

The list of items of the AST node.

Expand source code
def items(self) -> List[Tuple[str, ASTValue]]:
    '''
    The list of items of the AST node.
    '''
    return [ (name, getattr(self, name)) for name in self.keys() ]
def keys(self) ‑> List[str]

The list of keys of the AST node.

Expand source code
def keys(self) -> List[str]:
    '''
    The list of keys of the AST node.
    '''
    cons = _lib.g_clingo_ast_constructors.constructors[self.ast_type.value]
    names = _lib.g_clingo_ast_attribute_names.names
    return [ _to_str(names[cons.arguments[j].attribute]) for j in range(cons.size) ]
def unpool(self, other: bool = True, condition: bool = True) ‑> List[AST]

Unpool the AST returning a list of ASTs without pool terms.

Parameters

other
Remove all pools except those in conditions of conditional literals.
condition
Only remove pools from conditions of conditional literals.
Expand source code
def unpool(self, other: bool=True, condition: bool=True) -> List['AST']:
    '''
    Unpool the AST returning a list of ASTs without pool terms.

    Parameters
    ----------
    other
        Remove all pools except those in conditions of conditional
        literals.
    condition
        Only remove pools from conditions of conditional literals.
    '''
    unpool_type = 0
    if other:
        unpool_type |= _lib.clingo_ast_unpool_type_other
    if condition:
        unpool_type |= _lib.clingo_ast_unpool_type_condition

    ret: List[AST] = []
    error = _Error()
    cb_data = _CBData(ret.append, error)
    c_cb_data = _ffi.new_handle(cb_data)
    _handle_error(_lib.clingo_ast_unpool(self._rep, unpool_type, _lib.pyclingo_ast_callback, c_cb_data))
    return ret
def update(self, **kwargs: Union[str, int, SymbolLocation, None, ForwardRef('AST'), Sequence[str], Sequence[ForwardRef('AST')]]) ‑> AST

Return a copy of the AST also updating the given attributes.

Note that this function returns a reference to self if no arguments are given.

Expand source code
def update(self, **kwargs: ASTUpdate) -> 'AST':
    '''
    Return a copy of the AST also updating the given attributes.

    Note that this function returns a reference to self if no arguments are
    given.
    '''
    if not kwargs:
        return self

    args = []
    for key in self.keys():
        if key in kwargs:
            args.append(kwargs[key])
        else:
            args.append(getattr(self, key))

    cons = globals()[str(self.ast_type).replace('ASTType.', '')]
    return cons(*args)
def values(self) ‑> List[Union[str, int, SymbolLocation, None, ASTStrSequenceASTSequence]]

The list of values of the AST node.

Expand source code
def values(self) -> List[ASTValue]:
    '''
    The list of values of the AST node.
    '''
    return [ (getattr(self, name)) for name in self.keys() ]
class ASTSequence (rep, attribute)

A sequence holding AST nodes.

Expand source code
class ASTSequence(abc.MutableSequence):
    '''
    A sequence holding `AST` nodes.
    '''
    def __init__(self, rep, attribute):
        self._rep = rep
        self._attribute = attribute
        _lib.clingo_ast_acquire(self._rep)

    def __del__(self):
        _lib.clingo_ast_release(self._rep)

    def __len__(self) -> int:
        return _c_call('size_t', _lib.clingo_ast_attribute_size_ast_array, self._rep, self._attribute)

    def __getitem__(self, index):
        if isinstance(index, slice):
            return SlicedMutableSequence(self, Slice(index))
        size = len(self)
        if index < 0:
            index += size
        if index < 0 or index >= size:
            raise IndexError('invalid index')
        return AST(_c_call('clingo_ast_t*', _lib.clingo_ast_attribute_get_ast_at, self._rep, self._attribute, index))

    def __iter__(self):
        for index in range(len(self)):
            yield AST(_c_call('clingo_ast_t*', _lib.clingo_ast_attribute_get_ast_at, self._rep, self._attribute, index))

    def __setitem__(self, index, ast):
        if isinstance(index, slice):
            raise TypeError('slicing not implemented')
        _handle_error(_lib.clingo_ast_attribute_set_ast_at(self._rep, self._attribute, index, ast._rep))

    def __delitem__(self, index):
        if isinstance(index, slice):
            raise TypeError('slicing not implemented')
        size = len(self)
        if index < 0:
            index += size
        if index < 0 or index >= size:
            raise IndexError('invalid index')
        _handle_error(_lib.clingo_ast_attribute_delete_ast_at(self._rep, self._attribute, index))

    def insert(self, index, value):
        _handle_error(_lib.clingo_ast_attribute_insert_ast_at(self._rep, self._attribute, index, value._rep))

    def clear(self):
        '''
        Remove all elements from the sequence.
        '''
        for i in range(len(self), 0, -1):
            del self[i - 1]

    def __str__(self):
        return str(list(self))

    def __repr__(self):
        return repr(list(self))

Ancestors

  • collections.abc.MutableSequence
  • collections.abc.Sequence
  • collections.abc.Reversible
  • collections.abc.Collection
  • collections.abc.Sized
  • collections.abc.Iterable
  • collections.abc.Container

Methods

def clear(self)

Remove all elements from the sequence.

Expand source code
def clear(self):
    '''
    Remove all elements from the sequence.
    '''
    for i in range(len(self), 0, -1):
        del self[i - 1]
def insert(self, index, value)

S.insert(index, value) – insert value before index

Expand source code
def insert(self, index, value):
    _handle_error(_lib.clingo_ast_attribute_insert_ast_at(self._rep, self._attribute, index, value._rep))
class ASTType (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of ast node types.

Expand source code
class ASTType(Enum):
    '''
    Enumeration of ast node types.
    '''
    Id = _lib.clingo_ast_type_id
    Variable = _lib.clingo_ast_type_variable
    SymbolicTerm = _lib.clingo_ast_type_symbolic_term
    UnaryOperation = _lib.clingo_ast_type_unary_operation
    BinaryOperation = _lib.clingo_ast_type_binary_operation
    Interval = _lib.clingo_ast_type_interval
    Function = _lib.clingo_ast_type_function
    Pool = _lib.clingo_ast_type_pool
    CspProduct = _lib.clingo_ast_type_csp_product
    CspSum = _lib.clingo_ast_type_csp_sum
    CspGuard = _lib.clingo_ast_type_csp_guard
    BooleanConstant = _lib.clingo_ast_type_boolean_constant
    SymbolicAtom = _lib.clingo_ast_type_symbolic_atom
    Comparison = _lib.clingo_ast_type_comparison
    CspLiteral = _lib.clingo_ast_type_csp_literal
    AggregateGuard = _lib.clingo_ast_type_aggregate_guard
    ConditionalLiteral = _lib.clingo_ast_type_conditional_literal
    Aggregate = _lib.clingo_ast_type_aggregate
    BodyAggregateElement = _lib.clingo_ast_type_body_aggregate_element
    BodyAggregate = _lib.clingo_ast_type_body_aggregate
    HeadAggregateElement = _lib.clingo_ast_type_head_aggregate_element
    HeadAggregate = _lib.clingo_ast_type_head_aggregate
    Disjunction = _lib.clingo_ast_type_disjunction
    DisjointElement = _lib.clingo_ast_type_disjoint_element
    Disjoint = _lib.clingo_ast_type_disjoint
    TheorySequence = _lib.clingo_ast_type_theory_sequence
    TheoryFunction = _lib.clingo_ast_type_theory_function
    TheoryUnparsedTermElement = _lib.clingo_ast_type_theory_unparsed_term_element
    TheoryUnparsedTerm = _lib.clingo_ast_type_theory_unparsed_term
    TheoryGuard = _lib.clingo_ast_type_theory_guard
    TheoryAtomElement = _lib.clingo_ast_type_theory_atom_element
    TheoryAtom = _lib.clingo_ast_type_theory_atom
    Literal = _lib.clingo_ast_type_literal
    TheoryOperatorDefinition = _lib.clingo_ast_type_theory_operator_definition
    TheoryTermDefinition = _lib.clingo_ast_type_theory_term_definition
    TheoryGuardDefinition = _lib.clingo_ast_type_theory_guard_definition
    TheoryAtomDefinition = _lib.clingo_ast_type_theory_atom_definition
    Rule = _lib.clingo_ast_type_rule
    Definition = _lib.clingo_ast_type_definition
    ShowSignature = _lib.clingo_ast_type_show_signature
    ShowTerm = _lib.clingo_ast_type_show_term
    Minimize = _lib.clingo_ast_type_minimize
    Script = _lib.clingo_ast_type_script
    Program = _lib.clingo_ast_type_program
    External = _lib.clingo_ast_type_external
    Edge = _lib.clingo_ast_type_edge
    Heuristic = _lib.clingo_ast_type_heuristic
    ProjectAtom = _lib.clingo_ast_type_project_atom
    ProjectSignature = _lib.clingo_ast_type_project_signature
    Defined = _lib.clingo_ast_type_defined
    TheoryDefinition = _lib.clingo_ast_type_theory_definition

Ancestors

  • enum.Enum

Class variables

var Aggregate
var AggregateGuard
var BinaryOperation
var BodyAggregate
var BodyAggregateElement
var BooleanConstant
var Comparison
var ConditionalLiteral
var CspGuard
var CspLiteral
var CspProduct
var CspSum
var Defined
var Definition
var Disjoint
var DisjointElement
var Disjunction
var Edge
var External
var Function
var HeadAggregate
var HeadAggregateElement
var Heuristic
var Id
var Interval
var Literal
var Minimize
var Pool
var Program
var ProjectAtom
var ProjectSignature
var Rule
var Script
var ShowSignature
var ShowTerm
var SymbolicAtom
var SymbolicTerm
var TheoryAtom
var TheoryAtomDefinition
var TheoryAtomElement
var TheoryDefinition
var TheoryFunction
var TheoryGuard
var TheoryGuardDefinition
var TheoryOperatorDefinition
var TheorySequence
var TheoryTermDefinition
var TheoryUnparsedTerm
var TheoryUnparsedTermElement
var UnaryOperation
var Variable
class AggregateFunction (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of aggegate functions.

Expand source code
class AggregateFunction(IntEnum):
    '''
    Enumeration of aggegate functions.
    '''
    Count = _lib.clingo_ast_aggregate_function_count
    '''
    The `#count` function.
    '''
    Max = _lib.clingo_ast_aggregate_function_max
    '''
    The `#max` function.
    '''
    Min = _lib.clingo_ast_aggregate_function_min
    '''
    The `#min` function.
    '''
    Sum = _lib.clingo_ast_aggregate_function_sum
    '''
    The `#sum` function.
    '''
    SumPlus = _lib.clingo_ast_aggregate_function_sump
    '''
    The `#sum+` function.
    '''

Ancestors

  • enum.IntEnum
  • builtins.int
  • enum.Enum

Class variables

var Count

The #count function.

var Max

The #max function.

var Min

The #min function.

var Sum

The #sum function.

var SumPlus

The #sum+ function.

class BinaryOperator (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of binary operators.

Expand source code
class BinaryOperator(IntEnum):
    '''
    Enumeration of binary operators.
    '''
    And = _lib.clingo_ast_binary_operator_and
    '''
    For bitwise and.
    '''
    Division = _lib.clingo_ast_binary_operator_division
    '''
    For arithmetic division.
    '''
    Minus = _lib.clingo_ast_binary_operator_minus
    '''
    For arithmetic subtraction.
    '''
    Modulo = _lib.clingo_ast_binary_operator_modulo
    '''
    For arithmetic modulo.
    '''
    Multiplication = _lib.clingo_ast_binary_operator_multiplication
    '''
    For arithmetic multipilcation.
    '''
    Or = _lib.clingo_ast_binary_operator_or
    '''
    For bitwise or.
    '''
    Plus = _lib.clingo_ast_binary_operator_plus
    '''
    For arithmetic addition.
    '''
    Power = _lib.clingo_ast_binary_operator_power
    '''
    For arithmetic exponentiation.
    '''
    XOr = _lib.clingo_ast_binary_operator_xor
    '''
    For bitwise exclusive or.
    '''

Ancestors

  • enum.IntEnum
  • builtins.int
  • enum.Enum

Class variables

var And

For bitwise and.

var Division

For arithmetic division.

var Minus

For arithmetic subtraction.

var Modulo

For arithmetic modulo.

var Multiplication

For arithmetic multipilcation.

var Or

For bitwise or.

var Plus

For arithmetic addition.

var Power

For arithmetic exponentiation.

var XOr

For bitwise exclusive or.

class ComparisonOperator (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of comparison operators.

Expand source code
class ComparisonOperator(IntEnum):
    '''
    Enumeration of comparison operators.
    '''
    Equal = _lib.clingo_ast_comparison_operator_equal
    '''
    The `=` operator
    '''
    GreaterEqual = _lib.clingo_ast_comparison_operator_greater_equal
    '''
    The `>=` operator.
    '''
    GreaterThan = _lib.clingo_ast_comparison_operator_greater_than
    '''
    The `>` operator.
    '''
    LessEqual = _lib.clingo_ast_comparison_operator_less_equal
    '''
    The `<=` operator.
    '''
    LessThan = _lib.clingo_ast_comparison_operator_less_than
    '''
    The `<` operator.
    '''
    NotEqual = _lib.clingo_ast_comparison_operator_not_equal
    '''
    The `!=` operator.
    '''

Ancestors

  • enum.IntEnum
  • builtins.int
  • enum.Enum

Class variables

var Equal

The = operator

var GreaterEqual

The >= operator.

var GreaterThan

The > operator.

var LessEqual

The <= operator.

var LessThan

The < operator.

var NotEqual

The != operator.

class Location (begin: Position, end: Position)

Class to point to a range in a text file.

Expand source code
class Location(NamedTuple):
    '''
    Class to point to a range in a text file.
    '''
    begin: Position
    '''
    The beginning of the range.
    '''
    end: Position
    '''
    The end of the range.
    '''

Ancestors

  • builtins.tuple

Instance variables

var beginPosition

The beginning of the range.

var endPosition

The end of the range.

class Position (filename: str, line: int, column: int)

Class to point to a position in a text file.

Expand source code
class Position(NamedTuple):
    '''
    Class to point to a position in a text file.
    '''
    filename: str
    '''
    The file name.
    '''
    line: int
    '''
    The line number in the file.
    '''
    column: int
    '''
    The column number in the line.
    '''

Ancestors

  • builtins.tuple

Instance variables

var column : int

The column number in the line.

var filename : str

The file name.

var line : int

The line number in the file.

class ProgramBuilder (control: Control)

Object to build non-ground programs.

Parameters

control
The Control object to attach the builder to.

See Also

parse_string(), parse_files()

Notes

This class is a context manager and must be used with Python's with statement.

Expand source code
class ProgramBuilder(ContextManager['ProgramBuilder']):
    '''
    Object to build non-ground programs.

    Parameters
    ----------
    control
        The `clingo.control.Control` object to attach the builder to.

    See Also
    --------
    parse_string, parse_files

    Notes
    -----
    This class is a context manager and must be used with Python's `with`
    statement.
    '''
    def __init__(self, control: Control):
        self._rep = _c_call('clingo_program_builder_t*', _lib.clingo_control_program_builder, control._rep)

    def __enter__(self):
        _handle_error(_lib.clingo_program_builder_begin(self._rep))
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        _handle_error(_lib.clingo_program_builder_end(self._rep))
        return False

    def add(self, statement: AST) -> None:
        '''
        Adds a statement in form of an `AST` node to the program.

        Parameters
        ----------
        statement
            The statement to add.
        '''
        _handle_error(_lib.clingo_program_builder_add(self._rep, statement._rep))

Ancestors

  • contextlib.AbstractContextManager
  • abc.ABC
  • typing.Generic

Methods

def add(self, statement: AST) ‑> None

Adds a statement in form of an AST node to the program.

Parameters

statement
The statement to add.
Expand source code
def add(self, statement: AST) -> None:
    '''
    Adds a statement in form of an `AST` node to the program.

    Parameters
    ----------
    statement
        The statement to add.
    '''
    _handle_error(_lib.clingo_program_builder_add(self._rep, statement._rep))
class Sign (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of signs for literals.

Expand source code
class Sign(IntEnum):
    '''
    Enumeration of signs for literals.
    '''
    DoubleNegation = _lib.clingo_ast_sign_double_negation
    '''
    For double negated literals (with prefix `not not`)
    '''
    Negation = _lib.clingo_ast_sign_negation
    '''
    For negative literals (with prefix `not`).
    '''
    NoSign = _lib.clingo_ast_sign_no_sign
    '''
    For positive literals.
    '''

Ancestors

  • enum.IntEnum
  • builtins.int
  • enum.Enum

Class variables

var DoubleNegation

For double negated literals (with prefix not not)

var Negation

For negative literals (with prefix not).

var NoSign

For positive literals.

class StrSequence (rep, attribute)

A sequence holding strings.

Expand source code
class StrSequence(abc.MutableSequence):
    '''
    A sequence holding strings.
    '''
    def __init__(self, rep, attribute):
        self._attribute = attribute
        self._rep = rep
        _lib.clingo_ast_acquire(self._rep)

    def __del__(self):
        _lib.clingo_ast_release(self._rep)

    def __len__(self) -> int:
        return _c_call('size_t', _lib.clingo_ast_attribute_size_string_array, self._rep, self._attribute)

    def __getitem__(self, index):
        if isinstance(index, slice):
            return SlicedMutableSequence(self, Slice(index))
        size = len(self)
        if index < 0:
            index += size
        if index < 0 or index >= size:
            raise IndexError('invalid index')
        return _to_str(_c_call('char*', _lib.clingo_ast_attribute_get_string_at, self._rep, self._attribute, index))

    def __iter__(self):
        for index in range(len(self)):
            yield _to_str(_c_call('char*', _lib.clingo_ast_attribute_get_string_at, self._rep, self._attribute, index))

    def __setitem__(self, index, value):
        if isinstance(index, slice):
            raise TypeError('slicing not implemented')
        _handle_error(_lib.clingo_str_attribute_set_string_at(self._rep, self._attribute, index, value.encode()))

    def __delitem__(self, index):
        if isinstance(index, slice):
            raise TypeError('slicing not implemented')
        size = len(self)
        if index < 0:
            index += size
        if index < 0 or index >= size:
            raise IndexError('invalid index')
        _handle_error(_lib.clingo_ast_attribute_delete_string_at(self._rep, self._attribute, index))

    def insert(self, index, value):
        _handle_error(_lib.clingo_ast_attribute_insert_string_at(self._rep, self._attribute, index, value.encode()))

    def clear(self):
        '''
        Remove all elements from the sequence.
        '''
        for i in range(len(self), 0, -1):
            del self[i - 1]

    def __str__(self):
        return str(list(self))

    def __repr__(self):
        return repr(list(self))

Ancestors

  • collections.abc.MutableSequence
  • collections.abc.Sequence
  • collections.abc.Reversible
  • collections.abc.Collection
  • collections.abc.Sized
  • collections.abc.Iterable
  • collections.abc.Container

Methods

def clear(self)

Remove all elements from the sequence.

Expand source code
def clear(self):
    '''
    Remove all elements from the sequence.
    '''
    for i in range(len(self), 0, -1):
        del self[i - 1]
def insert(self, index, value)

S.insert(index, value) – insert value before index

Expand source code
def insert(self, index, value):
    _handle_error(_lib.clingo_ast_attribute_insert_string_at(self._rep, self._attribute, index, value.encode()))
class TheoryAtomType (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of theory atom types.

Expand source code
class TheoryAtomType(IntEnum):
    '''
    Enumeration of theory atom types.
    '''
    Any = _lib.clingo_ast_theory_atom_definition_type_any
    '''
    For atoms that can occur anywhere in a rule.
    '''
    Body = _lib.clingo_ast_theory_atom_definition_type_body
    '''
    For atoms that can only occur in rule bodies.
    '''
    Directive = _lib.clingo_ast_theory_atom_definition_type_directive
    '''
    For atoms that can only occur in facts.
    '''
    Head = _lib.clingo_ast_theory_atom_definition_type_head
    '''
    For atoms that can only occur in rule heads.
    '''

Ancestors

  • enum.IntEnum
  • builtins.int
  • enum.Enum

Class variables

var Any

For atoms that can occur anywhere in a rule.

var Body

For atoms that can only occur in rule bodies.

var Directive

For atoms that can only occur in facts.

var Head

For atoms that can only occur in rule heads.

class TheoryOperatorType (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of operator types.

Expand source code
class TheoryOperatorType(IntEnum):
    '''
    Enumeration of operator types.
    '''
    BinaryLeft = _lib.clingo_ast_theory_operator_type_binary_left
    '''
    For binary left associative operators.
    '''
    BinaryRight = _lib.clingo_ast_theory_operator_type_binary_right
    '''
    For binary right associative operator.
    '''
    Unary = _lib.clingo_ast_theory_operator_type_unary
    '''
    For unary operators.
    '''

Ancestors

  • enum.IntEnum
  • builtins.int
  • enum.Enum

Class variables

var BinaryLeft

For binary left associative operators.

var BinaryRight

For binary right associative operator.

var Unary

For unary operators.

class TheorySequenceType (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of theory term sequence types.

Expand source code
class TheorySequenceType(IntEnum):
    '''
    Enumeration of theory term sequence types.
    '''
    List = _lib.clingo_ast_theory_sequence_type_list
    '''
    For sequences enclosed in brackets.
    '''
    Set = _lib.clingo_ast_theory_sequence_type_set
    '''
    For sequences enclosed in braces.
    '''
    Tuple = _lib.clingo_ast_theory_sequence_type_tuple
    '''
    For sequences enclosed in parenthesis.
    '''

Ancestors

  • enum.IntEnum
  • builtins.int
  • enum.Enum

Class variables

var List

For sequences enclosed in brackets.

var Set

For sequences enclosed in braces.

var Tuple

For sequences enclosed in parenthesis.

class Transformer

Utility class to transform ASTs.

Classes should inherit from this class and implement functions with name visit_<ast_type> where <ast_type> is the type of the ASTs to visit and modify. Such a function should return an updated AST or the same AST if no change is necessary. The transformer will take care to copy all parent ASTs involving a modified child. Note that the class works like a visitor if only self references are returned from such functions.

Any extra arguments passed to the visit method are passed on to child ASTs.

Expand source code
class Transformer:
    '''
    Utility class to transform ASTs.

    Classes should inherit from this class and implement functions with name
    `visit_<ast_type>` where `<ast_type>` is the type of the ASTs to visit and
    modify. Such a function should return an updated AST or the same AST if no
    change is necessary. The transformer will take care to copy all parent ASTs
    involving a modified child. Note that the class works like a visitor if
    only self references are returned from such functions.

    Any extra arguments passed to the visit method are passed on to child ASTs.
    '''
    def visit(self, ast: AST, *args: Any, **kwargs: Any) -> AST:
        '''
        Dispatch to a visit method in a base class or visit and transform the
        children of the given AST if it is missing.
        '''
        attr = 'visit_' + str(ast.ast_type).replace('ASTType.', '')
        if hasattr(self, attr):
            return getattr(self, attr)(ast, *args, **kwargs)
        return ast.update(**self.visit_children(ast, *args, **kwargs))

    def visit_children(self, ast: AST, *args: Any, **kwargs: Any) -> Dict[str, ASTUpdate]:
        '''
        Visit and transform the children of the given AST.

        Returns
        -------
        The functions returns a dictionary that can be passed to `AST.update`.
        It contains the attributes and values that have been transformed.
        '''
        update: Dict[str, ASTUpdate] = dict()
        for key in ast.child_keys:
            old = getattr(ast, key)
            new = self._dispatch(old, *args, **kwargs)
            if new is not old:
                update[key] = new
        return update

    def visit_sequence(self, sequence: ASTSequence, *args: Any, **kwargs: Any) -> MutableSequence[AST]:
        '''
        Transform a sequence of ASTs returning the same sequnce if there are no
        changes or a list of ASTs otherwise.
        '''
        ret: MutableSequence[AST]
        ret, lst = sequence, []
        for old in sequence:
            lst.append(self(old, *args, **kwargs))
            if lst[-1] is not old:
                ret = lst
        return ret

    def _dispatch(self, ast: Union[None, AST, ASTSequence], *args: Any, **kwargs: Any) -> Union[None, AST, MutableSequence[AST]]:
        '''
        Visit and transform an (optional) AST or a sequence of ASTs.
        '''
        if ast is None:
            return ast

        if isinstance(ast, AST):
            return self.visit(ast, *args, **kwargs) # type: ignore

        if isinstance(ast, abc.Sequence):
            return self.visit_sequence(ast, *args, **kwargs)

        raise TypeError('unexpected type')

    def __call__(self, ast: AST, *args: Any, **kwargs: Any) -> AST:
        '''
        Alternative way to call `Transformer.visit`.
        '''
        return self.visit(ast, *args, **kwargs)

Subclasses

Methods

def visit(self, ast: AST, *args: Any, **kwargs: Any) ‑> AST

Dispatch to a visit method in a base class or visit and transform the children of the given AST if it is missing.

Expand source code
def visit(self, ast: AST, *args: Any, **kwargs: Any) -> AST:
    '''
    Dispatch to a visit method in a base class or visit and transform the
    children of the given AST if it is missing.
    '''
    attr = 'visit_' + str(ast.ast_type).replace('ASTType.', '')
    if hasattr(self, attr):
        return getattr(self, attr)(ast, *args, **kwargs)
    return ast.update(**self.visit_children(ast, *args, **kwargs))
def visit_children(self, ast: AST, *args: Any, **kwargs: Any) ‑> Dict[str, Union[str, int, SymbolLocation, None, AST, Sequence[str], Sequence[AST]]]

Visit and transform the children of the given AST.

Returns

The functions returns a dictionary that can be passed to AST.update(). It contains the attributes and values that have been transformed.

Expand source code
def visit_children(self, ast: AST, *args: Any, **kwargs: Any) -> Dict[str, ASTUpdate]:
    '''
    Visit and transform the children of the given AST.

    Returns
    -------
    The functions returns a dictionary that can be passed to `AST.update`.
    It contains the attributes and values that have been transformed.
    '''
    update: Dict[str, ASTUpdate] = dict()
    for key in ast.child_keys:
        old = getattr(ast, key)
        new = self._dispatch(old, *args, **kwargs)
        if new is not old:
            update[key] = new
    return update
def visit_sequence(self, sequence: ASTSequence, *args: Any, **kwargs: Any) ‑> MutableSequence[AST]

Transform a sequence of ASTs returning the same sequnce if there are no changes or a list of ASTs otherwise.

Expand source code
def visit_sequence(self, sequence: ASTSequence, *args: Any, **kwargs: Any) -> MutableSequence[AST]:
    '''
    Transform a sequence of ASTs returning the same sequnce if there are no
    changes or a list of ASTs otherwise.
    '''
    ret: MutableSequence[AST]
    ret, lst = sequence, []
    for old in sequence:
        lst.append(self(old, *args, **kwargs))
        if lst[-1] is not old:
            ret = lst
    return ret
class UnaryOperator (value, names=None, *, module=None, qualname=None, type=None, start=1)

Enumeration of signs for literals.

Expand source code
class UnaryOperator(IntEnum):
    '''
    Enumeration of signs for literals.
    '''
    Absolute = _lib.clingo_ast_unary_operator_absolute
    '''
    For taking the absolute value.
    '''
    Minus = _lib.clingo_ast_unary_operator_minus
    '''
    For unary minus and classical negation.
    '''
    Negation = _lib.clingo_ast_unary_operator_negation
    '''
    For bitwise negation.
    '''

Ancestors

  • enum.IntEnum
  • builtins.int
  • enum.Enum

Class variables

var Absolute

For taking the absolute value.

var Minus

For unary minus and classical negation.

var Negation

For bitwise negation.