openpectus.lsp.lsp_analysis

Attributes

`logger`
`operator_descriptions`

Classes

`AnalysisInput`
`AnalysisResult`
`MacroVisitor`

Functions

`fetch_uod_info`(engine_id)
`fetch_process_value`(engine_id, tag_name)
`build_tags`(uod_def)
`build_commands`(uod_def)
`create_analysis_input`(engine_id)
`analyze`(input, document)	Parse document as pcode and run semantic analysis on it
`lint`(document, engine_id)
`starts_with_any`(query, candidates)	Return True if query starts with any of the candidates
`ends_with_any`(query, candidates)	Return True if query ends with any of the candidates
`contains_any`(query, candidates)	Return True if query contains any of the candidates
`identify_called_macro`(program, macro_call)
`get_code_called_by_macro`(document, macro_call)
`hover`(document, position, engine_id)
`completions`(document, position, ignored_names, engine_id)
`code_actions`(config, workspace, document, range, context)
`get_line`(document, position)
`units_compaible_with_tag`(analysis_input, tag_name)
`lsp_range_from_ast_range`(ast_range)
`ast_position_from_lsp_position`(lsp_position)

Module Contents

openpectus.lsp.lsp_analysis.logger

openpectus.lsp.lsp_analysis.operator_descriptions

openpectus.lsp.lsp_analysis.fetch_uod_info(engine_id)

Parameters:: engine_id (str)
Return type:: openpectus.protocol.models.UodDefinition | None

openpectus.lsp.lsp_analysis.fetch_process_value(engine_id, tag_name)

Parameters:: engine_id (str)
Return type:: openpectus.protocol.models.TagValue | None

openpectus.lsp.lsp_analysis.build_tags(uod_def)

Parameters:: uod_def (openpectus.protocol.models.UodDefinition)
Return type:: openpectus.lang.exec.tags.TagValueCollection

openpectus.lsp.lsp_analysis.build_commands(uod_def)

Parameters:: uod_def (openpectus.protocol.models.UodDefinition)
Return type:: openpectus.lang.exec.commands.CommandCollection

class openpectus.lsp.lsp_analysis.AnalysisInput(commands, tags, engine_id)

Parameters:

commands (openpectus.lang.exec.commands.CommandCollection)
tags (openpectus.lang.exec.tags.TagValueCollection)
engine_id (str)

commands: openpectus.lang.exec.commands.CommandCollection

tags: openpectus.lang.exec.tags.TagValueCollection

engine_id: str

command_completions

tag_completions

get_command_completions(query)

Parameters:: query (str)
Return type:: list[str]

get_tag_completions(query)

Parameters:: query (str)
Return type:: list[str]

__str__()

Return type:: str

openpectus.lsp.lsp_analysis.create_analysis_input(engine_id)

Parameters:: engine_id (str)
Return type:: AnalysisInput

class openpectus.lsp.lsp_analysis.AnalysisResult(program, items, input)

Parameters:

program (openpectus.lang.model.ast.ProgramNode)
items (list[openpectus.lang.exec.analyzer.AnalyzerItem])
input (AnalysisInput)

program

items

input

__str__()

Return type:: str

openpectus.lsp.lsp_analysis.analyze(input, document)

Parse document as pcode and run semantic analysis on it

Parameters:

input (AnalysisInput)
document (pylsp.workspace.Document)

Return type:

openpectus.lsp.lsp_analysis.lint(document, engine_id)

Parameters:

document (pylsp.workspace.Document)
engine_id (str)

Return type:

list[openpectus.lsp.model.Diagnostic]

openpectus.lsp.lsp_analysis.starts_with_any(query, candidates)

Return True if query starts with any of the candidates

Parameters:

query (str)
candidates (list[str])

Return type:

bool

openpectus.lsp.lsp_analysis.ends_with_any(query, candidates)

Return True if query ends with any of the candidates

Parameters:

query (str)
candidates (list[str])

Return type:

bool

openpectus.lsp.lsp_analysis.contains_any(query, candidates)

Return True if query contains any of the candidates

Parameters:

query (str)
candidates (list[str])

Return type:

bool

class openpectus.lsp.lsp_analysis.MacroVisitor(macro_call=None)

Bases: openpectus.lang.exec.visitor.NodeVisitor

Parameters:: macro_call (openpectus.lang.model.ast.CallMacroNode | None)

macros: dict[str, openpectus.lang.model.ast.MacroNode]

macro_calls: list[openpectus.lang.model.ast.CallMacroNode] = []

macro_call: openpectus.lang.model.ast.CallMacroNode | None = None

macro_called_by_macro_call: openpectus.lang.model.ast.MacroNode | None = None

visit_CallMacroNode(node)

Parameters:: node (openpectus.lang.model.ast.CallMacroNode)

visit_MacroNode(node)

Parameters:: node (openpectus.lang.model.ast.MacroNode)

openpectus.lsp.lsp_analysis.identify_called_macro(program, macro_call)

Parameters:

program (openpectus.lang.model.ast.ProgramNode)
macro_call (openpectus.lang.model.ast.CallMacroNode)

Return type:

None | openpectus.lang.model.ast.MacroNode

openpectus.lsp.lsp_analysis.get_code_called_by_macro(document, macro_call)

Parameters:

document (pylsp.workspace.Document)
macro_call (openpectus.lang.model.ast.CallMacroNode)

Return type:

None | str

openpectus.lsp.lsp_analysis.hover(document, position, engine_id)

Parameters:

document (pylsp.workspace.Document)
position (openpectus.lsp.model.Position)
engine_id (str)

Return type:

openpectus.lsp.model.Hover | None

openpectus.lsp.lsp_analysis.completions(document, position, ignored_names, engine_id)

Parameters:

document (pylsp.workspace.Document)
position (openpectus.lsp.model.Position)
engine_id (str)

Return type:

list[openpectus.lsp.model.CompletionItem]

openpectus.lsp.lsp_analysis.code_actions(config, workspace, document, range, context)

Parameters:

config (pylsp.config.config.Config)
workspace (pylsp.workspace.Workspace)
document (pylsp.workspace.Document)
range (openpectus.lsp.model.Range)
context (openpectus.lsp.model.CodeActionContext)

Return type:

list[openpectus.lsp.model.CodeAction]

openpectus.lsp.lsp_analysis.get_line(document, position)

Parameters:

document (pylsp.workspace.Document)
position (openpectus.lsp.model.Position)

Return type:

str | None

openpectus.lsp.lsp_analysis.units_compaible_with_tag(analysis_input, tag_name)

Parameters:

analysis_input (AnalysisInput)
tag_name (str)

Return type:

list[str]

openpectus.lsp.lsp_analysis.lsp_range_from_ast_range(ast_range)

Parameters:: ast_range (openpectus.lang.model.ast.Range)
Return type:: openpectus.lsp.model.Range

openpectus.lsp.lsp_analysis.ast_position_from_lsp_position(lsp_position)

Parameters:: lsp_position (openpectus.lsp.model.Position)
Return type:: openpectus.lang.model.ast.Position