setta 0.0.1.dev0__py3-none-any.whl → 0.0.2.dev0__py3-none-any.whl

setta/tasks/fns/codeAreaInitializeCode.py

@@ -0,0 +1,98 @@
+import json
+
+from pydantic import BaseModel
+
+from setta.code_gen.create_runnable_scripts import generate_final_code_for_sections
+from setta.code_gen.export_selected import export_selected
+from setta.code_gen.find_placeholders import tp
+from setta.tasks.task_runner import RunType
+from setta.utils.constants import C
+
+from .utils import (
+    TaskDefinition,
+    send_document_open_request_with_diagnostics_with_code_dict,
+)
+
+
+class CodeAreaInitializeCodeContent(BaseModel):
+    project: dict
+    sectionId: str
+
+
+async def _codeAreaInitializeCode(message, lsp_writers):
+    message = CodeAreaInitializeCodeContent.parse_obj(message.content)
+    project = message.project
+    exporter_obj = export_selected(
+        project, always_export_args_objs=True, force_include_template_var=False
+    )
+    projectConfigName = project["projectConfig"]["name"]
+    code_dict = await generate_final_code_for_sections(
+        project,
+        exporter_obj,
+        lsp_writers=lsp_writers,
+        folder_path=lsp_writers["full"].project_code_folder(projectConfigName),
+    )
+    send_document_open_request_with_diagnostics_with_code_dict(
+        lsp_writers["full"],
+        code_dict,
+        exporter_obj,
+        projectConfigName,
+    )
+
+    referencable_var_names = []
+    generated_var_names = []
+    if (
+        exporter_obj.code_gen_template_var_section_details["section"].get("id")
+        == message.sectionId
+    ):
+        generated_var_names = list(
+            code_dict[message.sectionId]["var_name_to_decl_rel_position_dict"][
+                tp(C.SETTA_GENERATED_PYTHON)
+            ].keys()
+        )
+        infoToFullName = {
+            tuple(json.loads(k)): v for k, v in project["infoToFullName"].items()
+        }
+        referencable_var_names = [
+            infoToFullName[exporter_obj.var_name_reverse_mapping[v]]
+            for v in generated_var_names
+        ]
+
+    template_var_replacement_values = {}
+    for r in code_dict[message.sectionId]["ref_template_var_positions"]["templateVars"]:
+        template_var_replacement_values[r["keyword"]] = r["value"]
+
+    return {
+        "content": True,
+        "cache": [
+            template_var_replacement_values,
+            generated_var_names,
+            referencable_var_names,
+            exporter_obj,
+            project["fullNameToInfo"],
+            project["fullNameToSectionId"],
+        ],
+    }
+
+
+def get_cache_key(projectConfigId, sectionId):
+    return f"codeAreaInitializeCode-{projectConfigId}-{sectionId}"
+
+
+def write_cache(cache, message, result):
+    if result.get("cache") is None:
+        return
+    message = CodeAreaInitializeCodeContent.parse_obj(message.content)
+    cache[
+        get_cache_key(message.project["projectConfig"]["id"], message.sectionId)
+    ] = result["cache"]
+
+
+codeAreaInitializeCode = TaskDefinition(
+    name="codeAreaInitializeCode",
+    return_message_type="codeAreaInitializeCodeReturn",
+    fn=_codeAreaInitializeCode,
+    write_cache=write_cache,
+    run_as=RunType.NONE,
+    server_dependencies=["lsp_writers"],
+)

setta/tasks/fns/findEVRefs.py

@@ -0,0 +1,236 @@
+import asyncio
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+from setta.code_gen.export_selected import get_gen_code_template_var
+from setta.code_gen.python.check_scope import are_positions_in_scope_with_variable
+from setta.database.utils import create_new_id
+from setta.tasks.task_runner import RunType
+from setta.utils.utils import multireplace
+
+from .utils import (
+    TaskDefinition,
+    generate_unique_variable,
+    prepare_code_for_scope_checking,
+)
+
+
+class TextFieldFindReferencesContent(BaseModel):
+    sectionId: str
+    paramInfoId: Optional[str] = None
+    candidateEVRefs: List[list]
+    templateVars: Optional[List[dict]] = None
+    onlyAfterGenCodeTemplateVar: Optional[bool] = False
+    fullText: str
+
+
+async def _findEVRefs(message, lsp_writers):
+    message_id = message.id
+    message = TextFieldFindReferencesContent.parse_obj(message.content)
+    request_ids = await sendEVRefRequests(
+        message_id,
+        message.sectionId,
+        message.paramInfoId,
+        message.candidateEVRefs,
+        message.templateVars,
+        message.onlyAfterGenCodeTemplateVar,
+        message.fullText,
+        lsp_writers,
+        local=False,
+    )
+
+    if len(request_ids) == 0:
+        return {"content": {"data": {"positions": [], "numMessages": 1}}}
+
+    return None
+
+
+async def sendEVRefRequests(
+    message_id,
+    sectionId,
+    paramInfoId,
+    candidateEVRefs,
+    templateVars,
+    onlyAfterGenCodeTemplateVar,
+    fullText,
+    lsp_writers,
+    local,
+):
+    candidateEVRefs = filterCandidatesByScope(
+        candidateEVRefs,
+        fullText,
+        onlyAfterGenCodeTemplateVar,
+        templateVars,
+    )
+
+    if len(candidateEVRefs) == 0:
+        return []
+
+    code, position_offset, num_keywords = generateCodeForReferenceFinding(
+        candidateEVRefs,
+        fullText,
+        onlyAfterGenCodeTemplateVar,
+        templateVars,
+    )
+    code_id = f"{sectionId}-{paramInfoId}-find-references"
+
+    await lsp_writers["basic"].send_document_open_request(code_id, code)
+    request_ids = []
+    for idx in range(num_keywords):
+        request_id = f"{message_id}-{idx}"
+        request_ids.append(request_id)
+        lsp_writers["basic"].create_asyncio_task(
+            lsp_writers["basic"].send_reference_request(
+                position_offset=position_offset,
+                line=idx,
+                character=0,
+                code_id=code_id,
+                request_id=request_id,
+                return_id=message_id,
+                num_messages=num_keywords,
+            ),
+            request_id,
+            local=local,
+        )
+
+    return request_ids
+
+
+async def findEVRefsLocally(
+    sectionId,
+    paramInfoId,
+    candidateEVRefs,
+    templateVars,
+    onlyAfterGenCodeTemplateVar,
+    fullText,
+    fullNameToInfo,
+    lsp_writers,
+):
+    evRefRequestId = create_new_id()
+    request_ids = await sendEVRefRequests(
+        evRefRequestId,
+        sectionId,
+        paramInfoId,
+        candidateEVRefs,
+        templateVars,
+        onlyAfterGenCodeTemplateVar,
+        fullText,
+        lsp_writers,
+        local=True,
+    )
+
+    if len(request_ids) == 0:
+        return []
+
+    responses = await waitForEVRefResponses(request_ids, lsp_writers)
+    positions = []
+    for r in responses:
+        positions.extend(r["data"]["positions"])
+    return construct_ev_refs(positions, fullNameToInfo, fullText)
+
+
+def construct_ev_refs(keyword_positions, fullNameToInfo, fullText):
+    output = []
+    for k in keyword_positions:
+        keyword = fullText[k["startPos"] : k["endPos"]]
+        if keyword in fullNameToInfo:
+            info = fullNameToInfo[keyword]
+            output.append(
+                {
+                    "sectionId": info["sectionId"],
+                    "paramInfoId": info["paramInfoId"],
+                    "isArgsObj": info["isArgsObj"],
+                    "startPos": k["startPos"],
+                    "keyword": keyword,
+                }
+            )
+    return output
+
+
+async def waitForEVRefResponses(request_ids, lsp_writers):
+    request_futures = []
+    for r in request_ids:
+        future = lsp_writers["basic"].wait_for_response(r)
+        request_futures.append(future)
+
+    return await asyncio.gather(*request_futures)
+
+
+def filterCandidatesByScope(
+    candidateEVRefs, fullText, onlyAfterGenCodeTemplateVar, templateVars
+):
+    if not onlyAfterGenCodeTemplateVar:
+        return candidateEVRefs
+    matching_template_var = get_gen_code_template_var(templateVars)
+    if matching_template_var is None:
+        return []
+
+    fullText, the_special_var_name = prepare_code_for_scope_checking(
+        fullText, templateVars, matching_template_var
+    )
+
+    response = are_positions_in_scope_with_variable(
+        fullText, [x[1] for x in candidateEVRefs], the_special_var_name
+    )
+
+    return [x for idx, x in enumerate(candidateEVRefs) if response[idx]]
+
+
+def generateCodeForReferenceFinding(
+    candidateEVRefs, fullText, onlyAfterGenCodeTemplateVar, templateVars
+):
+    position_offset = 0
+
+    if onlyAfterGenCodeTemplateVar:
+        matching_template_var = get_gen_code_template_var(templateVars)
+        if matching_template_var is None:
+            return "", position_offset, 0
+        # If SETTA_GENERATED_PYTHON is present, we only want to consider
+        # code that comes after it.
+        startPos = matching_template_var["startPos"]
+        keyword = matching_template_var["keyword"]
+        endPos = startPos + len(keyword)
+        template_str_len = endPos - startPos
+        before_text = fullText[:startPos]
+        fullText = fullText[endPos:]
+        position_offset -= len(before_text) + template_str_len
+
+    output = []
+    var_name_mapping = {}
+    visited_keywords = set()
+    for keyword, _ in candidateEVRefs:
+        # candidateEVRefs might contain multiple suggestions to the same keyword
+        # like in the case of fn(a=a), it'll suggest "a" in two positions
+        # but we only need to write the a=None declaration once
+        # so we keep track of keywords we've already visited
+        if keyword in visited_keywords:
+            continue
+        visited_keywords.add(keyword)
+        # Replace reference names like
+        # list_of_models[0]
+        # with a random valid variable name of the same length.
+        # If "[" is ever in the keyword,
+        # we know it will have a length of at least 4, e.g. x[0] has 4 characters.
+        # So we don't have to worry about clashes.
+        if "[" in keyword:
+            new_keyword = generate_unique_variable(fullText, keyword)
+            var_name_mapping[keyword] = new_keyword
+            keyword = new_keyword
+        output.append(f"{keyword}=None")
+
+    output = "\n".join(output)
+    # the plus 1 is for the newline between output and fullText
+    position_offset += len(output) + 1
+    if len(var_name_mapping) > 0:
+        fullText = multireplace(fullText, var_name_mapping)
+    return f"{output}\n{fullText}", position_offset, len(visited_keywords)
+
+
+findEVRefs = TaskDefinition(
+    name="findEVRefs",
+    return_message_type="findEVRefsReturn",
+    fn=_findEVRefs,
+    run_as=RunType.NONE,
+    server_dependencies=["lsp_writers"],
+)

setta/tasks/fns/parametersRequest.py

@@ -0,0 +1,71 @@
+from setta.code_gen.python.position_line_col import position_to_line_col
+from setta.tasks.task_runner import RunType
+
+from .textFieldAutocomplete import (
+    CodeCompletionContent,
+    get_code_and_cursor_position,
+    read_cache,
+)
+from .utils import TaskDefinition, send_document_open_request_with_diagnostics
+
+
+async def _parametersRequest(message, lsp_writers):
+    request_id = message.id
+    message = CodeCompletionContent.parse_obj(message.content)
+    cached = message.cached
+    if cached is None:
+        return {"content": {"data": None}}
+
+    (
+        gen_code_dict,
+        var_name,
+        _,
+        _,
+        exporter_obj,
+        fullNameToInfo,
+    ) = cached
+
+    (
+        evRefs,
+        code,
+        cursor_position,
+        ref_template_var_positions,
+    ) = await get_code_and_cursor_position(
+        message,
+        fullNameToInfo,
+        gen_code_dict,
+        var_name,
+        exporter_obj,
+        lsp_writers,
+    )
+    code = code[:cursor_position] + "()" + code[cursor_position + 2 :]
+    # move cursor into parentheses
+    cursor_position += 1
+    line, column = position_to_line_col(code, cursor_position)
+    code_id = await send_document_open_request_with_diagnostics(
+        lsp_writers["full"],
+        code,
+        exporter_obj,
+        ref_template_var_positions,
+        message.projectConfigName,
+        gen_code_dict["sanitized_full_name"],
+        exporter_obj.code_gen_template_var_section_details["section"]["id"],
+    )
+    await lsp_writers["full"].send_signature_help_request(
+        line,
+        column,
+        code_id,
+        request_id,
+        otherData={"evRefs": evRefs},
+    )
+    return None
+
+
+parametersRequest = TaskDefinition(
+    name="parametersRequest",
+    return_message_type="parametersRequestReturn",
+    fn=_parametersRequest,
+    read_cache=read_cache,
+    run_as=RunType.NONE,
+    server_dependencies=["lsp_writers"],
+)

setta/tasks/fns/textFieldAutocomplete.py

@@ -0,0 +1,210 @@
+import copy
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from setta.code_gen.create_runnable_scripts import generate_final_code_for_section
+from setta.code_gen.export_selected import get_gen_code_template_var
+from setta.code_gen.find_placeholders import tp
+from setta.code_gen.python.generate_code import (
+    construct_var_decl_with_trailing_whitespace,
+    var_declaration,
+)
+from setta.code_gen.python.position_line_col import position_to_line_col
+from setta.code_gen.utils import process_refs
+from setta.tasks.fns.textFieldInitializeCode import get_cache_key
+from setta.tasks.task_runner import RunType
+from setta.utils.constants import C
+
+from .findEVRefs import findEVRefsLocally
+from .utils import TaskDefinition, send_document_open_request_with_diagnostics
+
+
+class CodeCompletionContent(BaseModel):
+    projectConfigId: str
+    projectConfigName: str
+    sectionId: str
+    paramInfoId: str | None
+    fullText: str
+    position: int
+    candidateEVRefs: list
+    cached: Optional[Any] = None
+
+
+async def getEVRefsAndProcessThem(message, fullNameToInfo, exporter_obj, lsp_writers):
+    evRefs = await findEVRefsLocally(
+        message.sectionId,
+        message.paramInfoId,
+        message.candidateEVRefs,
+        [],
+        False,
+        message.fullText,
+        fullNameToInfo,
+        lsp_writers,
+    )
+
+    # 1. Create new variable declaration with new value
+    var_value, new_positions = process_refs(
+        message.fullText,
+        evRefs,
+        exporter_obj.get_ref_var_name,
+        cursor_position=message.position,
+    )
+    return evRefs, var_value, new_positions
+
+
+async def get_code_and_cursor_position(
+    message,
+    fullNameToInfo,
+    gen_code_dict,
+    var_name,
+    exporter_obj,
+    lsp_writers,
+):
+    evRefs, var_value, new_positions = await getEVRefsAndProcessThem(
+        message, fullNameToInfo, exporter_obj, lsp_writers
+    )
+    new_var_decl = var_declaration(var_name, var_value)
+
+    # 2. Compute relative cursor position (cursor position in the context of the variable declaration)
+    cursor_position = new_positions["cursor"]
+    cursor_position += len(new_var_decl) - len(
+        var_value
+    )  # shift by length of var declaration (like x = ...)
+
+    # 3. Get position of original variable declaration within generated code.
+    #    This will have to be the relative position, not the position adjusted after code generation
+    startPos, old_var_decl, chars_after_var_decl = gen_code_dict[
+        "var_name_to_decl_rel_position_dict"
+    ][tp(C.SETTA_GENERATED_PYTHON)][var_name]
+    endPos = startPos + len(old_var_decl)
+
+    # 4. Replace the old declaration with the new declaration.
+    gen_code = get_gen_code_template_var(
+        gen_code_dict["ref_template_var_positions"]["templateVars"]
+    )["value"]
+    gen_code = (
+        gen_code[:startPos]
+        + construct_var_decl_with_trailing_whitespace(
+            new_var_decl, chars_after_var_decl
+        )
+        + gen_code[endPos:]
+    )
+
+    # 5. Call generate_final_code_for_section with the new generated code as a replacement value
+    template_var_replacement_values = {tp(C.SETTA_GENERATED_PYTHON): gen_code}
+    var_name_to_decl_rel_position_dict = copy.deepcopy(
+        gen_code_dict["var_name_to_decl_rel_position_dict"]
+    )
+    var_name_to_decl_rel_position_dict[tp(C.SETTA_GENERATED_PYTHON)][var_name] = (
+        startPos,
+        new_var_decl,
+        chars_after_var_decl,
+    )
+    gen_code_details = exporter_obj.code_gen_template_var_section_details
+    gen_code_section = gen_code_details["section"]
+    gen_code_section_variant = gen_code_details["sectionVariant"]
+
+    (
+        code,
+        _,
+        var_name_to_decl_rel_position_dict,
+        ref_template_var_positions,
+    ) = await generate_final_code_for_section(
+        sectionId=message.sectionId,
+        code=gen_code_section_variant[
+            "code"
+        ],  # this is the code with the template vars still in place
+        codeLanguage=gen_code_section["codeLanguage"],
+        evRefs=gen_code_section_variant["evRefs"],
+        templateVars=gen_code_section_variant["templateVars"],
+        exporter_obj=exporter_obj,
+        lsp_writers=lsp_writers,
+        folder_path=lsp_writers["full"].project_code_folder(message.projectConfigName),
+        template_var_replacement_values=template_var_replacement_values,
+        var_name_to_decl_rel_position_dict=var_name_to_decl_rel_position_dict,
+        push_var_name=var_name,
+    )
+
+    # 6. Compute the cursor position using the value from step 2, plus the returned var_name_to_decl_rel_position_dict
+    var_decl_rel_position = var_name_to_decl_rel_position_dict[
+        tp(C.SETTA_GENERATED_PYTHON)
+    ][var_name][0]
+    gen_code_position = get_gen_code_template_var(
+        ref_template_var_positions["templateVars"]
+    )["startPos"]
+    cursor_position += var_decl_rel_position + gen_code_position
+
+    return evRefs, code, cursor_position, ref_template_var_positions
+
+
+async def _textFieldCompletion(message, lsp_writers):
+    request_id = message.id
+    message = CodeCompletionContent.parse_obj(message.content)
+    cached = message.cached
+    if cached is None:
+        return {"content": {"data": []}}
+
+    (
+        gen_code_dict,
+        var_name,
+        referencable_var_names,
+        generated_var_names,
+        exporter_obj,
+        fullNameToInfo,
+    ) = cached
+
+    (
+        _,
+        code,
+        cursor_position,
+        ref_template_var_positions,
+    ) = await get_code_and_cursor_position(
+        message,
+        fullNameToInfo,
+        gen_code_dict,
+        var_name,
+        exporter_obj,
+        lsp_writers,
+    )
+    line, column = position_to_line_col(code, cursor_position)
+
+    code_id = await send_document_open_request_with_diagnostics(
+        lsp_writers["full"],
+        code,
+        exporter_obj,
+        ref_template_var_positions,
+        message.projectConfigName,
+        gen_code_dict["sanitized_full_name"],
+        exporter_obj.code_gen_template_var_section_details["section"]["id"],
+    )
+    await lsp_writers["full"].send_autocomplete_request(
+        line,
+        column,
+        code_id,
+        request_id,
+        referencable_var_names,
+        generated_var_names,
+        cursor_offset=cursor_position - message.position,
+    )
+
+    return None
+
+
+def read_cache(cache, message):
+    message = message.content
+    message["cached"] = cache.get(
+        get_cache_key(
+            message["projectConfigId"], message["sectionId"], message["paramInfoId"]
+        )
+    )
+
+
+textFieldCompletion = TaskDefinition(
+    name="textFieldCompletion",
+    return_message_type="textFieldCompletionReturn",
+    fn=_textFieldCompletion,
+    read_cache=read_cache,
+    run_as=RunType.NONE,
+    server_dependencies=["lsp_writers"],
+)