Code processing method, device, electronic device and storage medium based on large model

Abstract

This disclosure proposes a code processing method, apparatus, electronic device, and storage medium based on a large model, relating to the fields of artificial intelligence technology, particularly natural language processing, deep learning, and large model technology. The method comprises: obtaining a first dialogue text describing a code processing task; using at least one of a newly added code file and an existing code file as a target code file corresponding to the code processing task; inputting the first dialogue text into a large model, which outputs a code processing result for the target code file and a second dialogue text corresponding to the first dialogue text; and displaying the code processing result and target dialogue text on an interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

Description

Technical Field

[0001] The present disclosure relates to the field of artificial intelligence technology, in particular to the field of natural language processing, deep learning, and large model technology, and in particular to a code processing method, device, electronic device, storage medium, and computer program product based on a large model. Background Art

[0002] In related technologies, the code processing process mostly requires users to open the code file to be processed on the client and manually process the opened code file. The user operation is complicated and the code processing efficiency is low, resulting in a poor user experience in the code processing scenario. Summary of the Invention

[0003] The present disclosure proposes a code processing method, device, electronic device, storage medium and computer program product based on a large model.

[0004] According to a first aspect of the present disclosure, a code processing method based on a large model is proposed, including: obtaining a first dialogue text for describing a code processing task; using at least one of a newly added code file and an original code file as a target code file corresponding to the code processing task; inputting the first dialogue text into a large model, and having the large model output a code processing result of the target code file and a second dialogue text for the first dialogue text; displaying the code processing result and the target dialogue text on an interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

[0005] According to a second aspect of the present disclosure, a code processing device based on a large model is proposed, including: a first acquisition module, used to acquire a first dialogue text for describing a code processing task; a second acquisition module, used to use at least one of a newly added code file and an original code file as a target code file corresponding to the code processing task; a processing module, used to input the first dialogue text into the large model, and the large model outputs a code processing result of the target code file and a second dialogue text for the first dialogue text; a display module, used to display the code processing result and the target dialogue text on an interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

[0006] According to a third aspect of the present disclosure, an electronic device is proposed, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the large model-based code processing method proposed in the first aspect above.

[0007] According to a fourth aspect of the present disclosure, a non-transitory computer-readable storage medium storing computer instructions is proposed, wherein the computer instructions are used to enable the computer to execute the large model-based code processing method proposed in the first aspect above.

[0008] According to a fifth aspect of the present disclosure, a computer program product is proposed, comprising a computer program, which, when executed by a processor, implements the large model-based code processing method proposed in the first aspect.

[0009] It should be understood that the contents described in this section are not intended to identify the key or important features of the embodiments of the present disclosure, nor are they intended to limit the scope of the present disclosure. Other features of the present disclosure will become readily understood through the following description. BRIEF DESCRIPTION OF THE DRAWINGS

[0010] The accompanying drawings are used to better understand the present invention and do not constitute a limitation of the present invention.

[0011] Figure 1 This is a flowchart of a code processing method based on a large model according to an embodiment of the present disclosure;

[0012] Figure 2 This is a flowchart of a code processing method based on a large model according to another embodiment of the present disclosure;

[0013] Figure 3 This is a flowchart of a code processing method based on a large model according to another embodiment of the present disclosure;

[0014] Figure 4 This is a flowchart of a code processing method based on a large model according to another embodiment of the present disclosure;

[0015] Figure 5 This is a flowchart of a code processing method based on a large model according to another embodiment of the present disclosure;

[0016] Figure 6 This is a flowchart of a code processing method based on a large model according to another embodiment of the present disclosure;

[0017] Figure 7 This is a flowchart of a code processing method based on a large model according to another embodiment of the present disclosure;

[0018] Figure 8 Schematic diagram of a code processing method based on a large model according to an embodiment of the present disclosure;

[0019] Figure 9 A schematic diagram of an interactive interface according to an embodiment of the present disclosure;

[0020] Figure 10 This is a structural diagram of a code processing device based on a large model according to an embodiment of the present disclosure;

[0021] Figure 11 A schematic block diagram of an electronic device according to an embodiment of the present disclosure is shown. DETAILED DESCRIPTION

[0022] The following description of exemplary embodiments of the present disclosure is made in conjunction with the accompanying drawings, including various details of the embodiments of the present disclosure to facilitate understanding. These details should be considered as merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications may be made to the embodiments described herein without departing from the scope and spirit of the present disclosure. Similarly, for the sake of clarity and conciseness, descriptions of well-known functions and structures are omitted in the following description.

[0023] Artificial Intelligence (AI) is a discipline that studies and develops theories, methods, technologies, and application systems for simulating, extending, and expanding human intelligence. Currently, AI technology has been widely used due to its high degree of automation, high precision, and low cost.

[0024] NLP (Natural Language Processing) is a science that studies computer systems that can effectively implement natural language communication, especially the software systems therein. It is an important direction in the fields of computer science and artificial intelligence.

[0025] DL (Deep Learning) is a new research direction in the field of ML (Machine Learning). It is a science that learns the inherent laws and representation levels of sample data, enabling machines to have analytical and learning capabilities like humans and recognize data such as text, images, and sounds. It is widely used in speech and image recognition.

[0026] Large models refer to machine learning models with large parameter sizes and complexity. They require extensive computing resources and storage space for training and storage, and often require distributed computing and specialized hardware acceleration technologies. Large models possess stronger generalization and expressive capabilities. These include LLMs (Large Language Models). Large language models are deep learning models trained using large amounts of text data and can generate natural language text or understand the meaning of text. Large language models can handle a variety of natural language tasks, such as text classification, question-answering, and conversation, and are an important path to artificial intelligence.

[0027] Figure 1FIG. 1 is a flow chart of a code processing method based on a large model according to an embodiment of the present disclosure. Figure 1 As shown, the method includes:

[0028] S101: Obtain a first dialogue text for describing a code processing task.

[0029] It should be noted that the execution entity of the large model-based code processing method of the embodiments of the present disclosure may be a hardware device with data information processing capabilities and / or the necessary software to drive the operation of the hardware device. Optionally, the execution entity may include a workstation, server, computer, user terminal, and other intelligent device. User terminals include but are not limited to mobile phones, computers, intelligent voice interaction devices, smart appliances, and in-vehicle terminals.

[0030] It should be noted that there are not too many restrictions on the task types of code processing tasks. For example, they may include code adjustment tasks (such as code addition, deletion, and modification), code testing tasks (such as code unit testing), code verification tasks (such as code security verification), code repair tasks (such as code vulnerability repair), etc. Code security verification includes code vulnerability detection, etc.

[0031] It should be noted that the first dialogue text is a text composed of natural language, and there are no excessive restrictions on the first dialogue text. For example, it can be composed of at least one language such as Chinese, English, etc.

[0032] For example, the first conversation text may include "Help me add some logs and handle exceptions for minutes", "Write me a unit test code and improve the test coverage", "Help me perform unit testing on xx1", "Help me perform vulnerability scanning on xx1", "Help me perform vulnerability repair on xx1", etc. "xx1" is used to represent a code file.

[0033] In one embodiment, obtaining the first dialogue text describing the code processing task includes, in response to detecting an input operation on the dialogue text, extracting the first dialogue text from the input operation. For example, an input box for entering the dialogue text may be displayed on an interactive interface, and the user may enter the dialogue text within the input box. Accordingly, the client may extract the first dialogue text from the input operation in response to detecting the input operation on the dialogue text.

[0034] In one embodiment, obtaining the first dialogue text for describing the code processing task includes collecting user voice information and performing text recognition on the voice information to obtain the first dialogue text. For example, an icon for recording voice information may be displayed on an interactive interface, and the user may click the icon and speak. In response to the click of the icon, the client may collect the user's voice information and perform text recognition on the voice information to obtain the first dialogue text.

[0035] S102: Use at least one of the newly added code file and the original code file as a target code file corresponding to the code processing task.

[0036] It should be noted that the target code file refers to the code file to be processed by the code processing task. The target code file may include at least one of a newly added code file and an existing code file. The target code file is at least one. The newly added code file refers to the code file that is added during the processing of the code processing task and needs to be obtained through the newly added code file. The existing code file refers to the code file that existed before the code processing task was processed, such as any code file in the local storage space.

[0037] It is understandable that different code processing tasks may correspond to different target code files.

[0038] S103: Input the first dialogue text into the large model, and the large model outputs a code processing result of the target code file and a second dialogue text corresponding to the first dialogue text.

[0039] It should be noted that the large model can be implemented using any large model in the relevant technologies, without further limitation. For example, it can be a Transformer model, which is a neural network model based on the self-attention mechanism. For example, the large model can be a large language model. For example, the large model can be deployed on a server.

[0040] It should be noted that there are no excessive restrictions on the code processing results.

[0041] Exemplarily, taking the code adjustment task as an example, the code processing result includes the code adjustment result, such as the newly added code, the deleted code, the code before modification, the modified code, the position of the adjusted code in the code file, etc.

[0042] For example, taking a code testing task as an example, the code processing result includes code testing results, such as whether the code file passes the test, the test indicators of the code file, and the code testing log.

[0043] For example, taking the code verification task as an example, the code processing results include code verification results, such as whether the code file passes the verification, the verification indicators of the code file, whether there are vulnerabilities in the code file, the number of vulnerabilities in the code file, the risk level of the vulnerability, the code with vulnerabilities, the location of the code with vulnerabilities in the code file, the code verification log, etc.

[0044] Exemplarily, taking a code repair task as an example, the code processing result includes a code repair result, such as a code repair strategy, a code repair log, and the like.

[0045] Exemplarily, the code processing result includes an initial processing result and a final processing result. The initial processing result refers to the initial processing result of the code processing task, and the final processing result refers to the final processing result of the code processing task. The initial processing result and the final processing result may be different. For example, taking the code generation task as an example, the initial processing result may include the initial code, and the final processing result may include the final code.

[0046] In one embodiment, the method further includes determining a task type of the code processing task based on the first conversation text using the macro model, determining a target tool from a plurality of candidate tools based on the task type using the macro model, invoking the target tool using the macro model, and generating a code processing result using the target tool. It should be noted that the plurality of candidate tools includes the target tool, and there is at least one target tool. The candidate tools and target tools are not particularly limited and may, for example, include code generation tools, code testing tools, code verification tools, code repair tools, etc.

[0047] In one embodiment, the method further includes generating an initial processing result based on the first conversation text using a large model, and adjusting the initial processing result using the large model to obtain a final processing result.

[0048] Exemplarily, the method also includes, in response to the code processing task including a code generation task, calling a code generation tool through the big model, and generating initial code through the code generation tool, calling a code verification tool through the big model to verify the initial code, and in response to the verification result of the initial code indicating that the initial code has failed the verification, calling a code repair tool through the big model, and repairing the initial code through the code repair tool to obtain the final code.

[0049] Alternatively, in response to the verification result of the initial code indicating that the initial code fails the verification, the code generation tool is re-called through the large model, and candidate codes are generated through the code generation tool until the candidate codes pass the verification, and the candidate codes that pass the verification are used as the final codes.

[0050] It should be noted that the second dialogue text is a text composed of natural language, and there are no excessive restrictions on the second dialogue text. For example, it can be composed of at least one language such as Chinese, English, etc.

[0051] For example, the second dialogue text may include "Of course, I can help you add logging functionality and better exception handling in xx1. We will use xx2 to add logging and add xx3 around key operations to handle possible exceptions. The following are the modifications to xx1." "xx2" is used to represent the code generation tool, and "xx3" is used to represent the code block.

[0052] For example, the second dialogue text may include "The above are all the vulnerabilities I scanned and repaired for you. Finally, let's make a summary. In this task, a total of a files were detected, and c vulnerabilities were found in b files. We attempted to automatically repair d of them. Next, you can view the summary information in the chart below and use the repair results I gave by clicking the Accept button, or you can refer to the vulnerability details and repair suggestions to try to repair them manually."

[0053] In one embodiment, the method further includes obtaining task information of the code processing task based on the first dialogue text through the big model, adding the code processing results and / or task progress to the task information through the big model, and generating a second dialogue text based on the task information through the big model.

[0054] In some examples, the method further includes adding the second dialogue text to the task information.

[0055] It should be noted that there are not too many restrictions on task information. For example, it may include task type, file information of the target code file corresponding to the code processing task (such as file name), code processing results, task progress (such as unprocessed, processing, processed), target dialogue text, etc.

[0056] In some examples, a second dialogue text is generated based on task information using a large model, including processing the task type of the task based on the code using the large model, determining a target dialogue template from multiple candidate dialogue templates, and generating the second dialogue text based on the target dialogue template and the task information using the large model.

[0057] S104: Display the code processing result and the target dialogue text on the interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

[0058] It should be noted that the display areas of the code processing result and the target dialogue text on the interactive interface may be different. For example, the interactive interface includes a first display area and a second display area. The code processing result can be displayed in the first display area, and the target dialogue text can be displayed in the second display area. Figure 9 As shown, the first display area is located in the left area of ​​the interactive interface, and the second display area is located in the right area of ​​the interactive interface (such as a sidebar).

[0059] For example, taking the code adjustment task as an example, the interactive interface includes a coding area and a dialogue area. The code adjustment result can be displayed in the coding area, and the target dialogue text can be displayed in the dialogue area.

[0060] Exemplarily, the display style of the code adjustment result is a Diff (Differences) style, which helps the user to understand the code adjustment status more intuitively.

[0061] For example, the code processing results and / or target dialogue text can be displayed on the interactive interface in a streaming display mode. It should be noted that streaming display mode refers to displaying content in multiple, incremental steps, such as line by line. Compared to presenting the entire content to the user all at once, this allows for faster response to user code processing needs and optimizes the user experience in code processing scenarios.

[0062] The code processing method based on a large model proposed in the present disclosure obtains a first dialogue text used to describe a code processing task, uses at least one of a newly added code file and an existing code file as the target code file corresponding to the code processing task, inputs the first dialogue text into the large model, and outputs a code processing result for the target code file and a second dialogue text corresponding to the first dialogue text. The code processing result and the target dialogue text are displayed on an interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text. Thus, the newly added code file and / or the existing code file can be used as the code file to be processed, which can achieve automatic determination of the code file to be processed. The user only needs to perform a dialogue operation, without manually adding a new code file or specifying (e.g., selecting or opening) the code file to be processed on the client, thus simplifying user operations. In addition, the code processing result and the second dialogue text of the target code file can be obtained based on the first dialogue text through the large model, achieving automatic processing of the code processing task, improving code processing efficiency, and displaying the code processing result and the target dialogue text on the interactive interface, allowing the user to more intuitively understand the processing status of the code processing task and optimizing the user experience in the code processing scenario.

[0063] In the above embodiment, in step S102, at least one of the newly added code file and the original code file is used as the target code file corresponding to the code processing task, which can be combined with Figure 2 Further understanding, Figure 2 This is a flow chart of a code processing method based on a large model according to another embodiment of the present disclosure. Figure 2 As shown, the method includes:

[0064] S201: Obtain a first dialogue text for describing a code processing task.

[0065] The relevant contents of step S201 can be found in the above embodiment and will not be repeated here.

[0066] S202 : In response to the code processing task meeting the set conditions, a new code file is added, and the new code file is used as a target code file.

[0067] It should be noted that there are no excessive restrictions on the setting conditions.

[0068] In one embodiment, the method further includes determining that the code processing task meets the set conditions in response to the task type of the code processing task being a set type. Thus, when the task type of the code processing task is the set type, a new code file can be added and the new code file is used as the code file to be processed.

[0069] Exemplarily, the method further includes determining that the code processing task meets a set condition in response to the code processing task including at least one of generating test code and adding a new code template. Thus, if the code processing task includes generating test code and / or adding a new code template, a new code file may be added and treated as the code file to be processed.

[0070] S203 : In response to the code processing task not meeting the set condition, determining a target code file from a plurality of original code files.

[0071] In one embodiment, determining the target code file from the plurality of existing code files includes determining a search parameter for the target code file based on the first conversation text, and determining the target code file from the plurality of existing code files based on the search parameter. Thus, the search parameter can be determined based on the first conversation text to determine the target code file from the plurality of existing code files.

[0072] It should be noted that there are no excessive restrictions on the search parameters, and they may include, for example, the identifier, storage path, file type, etc. of the target code file.

[0073] In some examples, determining a search parameter for the target code file based on the first conversation text includes extracting the search parameter from the first conversation text.

[0074] In some examples, determining a search parameter for the target code file based on the first dialog text includes performing a semantic analysis on the first dialog text using a large model to obtain the search parameter.

[0075] S204: Input the first dialogue text into the large model, and the large model outputs a code processing result of the target code file and a second dialogue text corresponding to the first dialogue text.

[0076] S205: Display the code processing result and the target dialogue text on the interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

[0077] The relevant contents of steps S204-S205 can be found in the above embodiment and will not be repeated here.

[0078] The code processing method based on a large model proposed in the present disclosure adds a new code file in response to a code processing task meeting a set condition, and uses the newly added code file as a target code file. In response to a code processing task not meeting the set condition, the target code file is determined from multiple existing code files. In this way, it is possible to identify whether the code processing task meets the set condition to determine whether a new code file needs to be added. For example, when the code processing task meets the set condition, a new code file is added and used as a code file to be processed. When the code processing task does not meet the set condition, the code file to be processed is determined from multiple existing code files.

[0079] Based on any of the above embodiments, the method further includes displaying the target code file on the interactive interface in response to the target code file not being displayed on the interactive interface, and continuing to display the target code file on the interactive interface in response to the target code file already being displayed on the interactive interface. Thus, the code file to be processed can be automatically displayed on the interactive interface, eliminating the need for the user to manually open the code file to be processed on the client, thereby simplifying user operations.

[0080] Based on any of the above embodiments, displaying the code processing results on the interactive interface includes displaying the code adjustment results in the display area of ​​the target code file on the interactive interface in response to the code processing results including the code adjustment results. Thus, the code adjustment results can be displayed in the display area of ​​the target code file on the interactive interface, allowing the user to more intuitively understand the code adjustment status.

[0081] For example, in response to the code processing result of the target code file A including the generated code block 1, the code block 1 may be displayed in green in the display area of ​​the target code file A on the interactive interface.

[0082] For example, in response to the code processing result of the target code file B including the deleted code block 2, the code block 2 may be displayed in red in the display area of ​​the target code file B on the interactive interface.

[0083] In the above embodiment, regarding the display of the code processing result on the interactive interface in step S104, it can be combined with Figure 3 Further understanding, Figure 3 This is a flow chart of a code processing method based on a large model according to another embodiment of the present disclosure. Figure 3 As shown, the method includes:

[0084] S301: Obtain a first dialogue text for describing a code processing task.

[0085] S302: Use at least one of the newly added code file and the original code file as a target code file corresponding to the code processing task.

[0086] S303: In response to the target code file not being displayed on the interactive interface, display the target code file on the interactive interface.

[0087] S304 : In response to the target code file being displayed on the interactive interface, continue to display the target code file on the interactive interface.

[0088] S305: Input the first dialogue text into the large model, and the large model outputs a code processing result of the target code file and a second dialogue text corresponding to the first dialogue text.

[0089] The relevant contents of steps S301-S305 can be found in the above embodiment and will not be repeated here.

[0090] S306 : In response to the code processing result including the code adjustment result, based on the position of the code adjustment result in the target code file, determining a target display area of ​​the code adjustment result on the interactive interface.

[0091] S307: Display the code adjustment result in the target display area.

[0092] It should be noted that the target display area of ​​the code adjustment result on the interactive interface can be located within the display area of ​​the target code file on the interactive interface, or outside the display area of ​​the target code file on the interactive interface, and no further restrictions are made here.

[0093] In one embodiment, based on the position of the code adjustment result in the target code file, the target display area of ​​the code adjustment result on the interactive interface is determined, including obtaining the position of the candidate code snippet in the target code file, and the mapping relationship between the candidate code snippet and the candidate display area on the interactive interface, and obtaining the candidate display area having a mapping relationship with the position of the code adjustment result in the target code file as the target display area.

[0094] In one embodiment, based on the position of the code adjustment result in the target code file, determining a target display area for the code adjustment result on the interactive interface includes obtaining, based on the position of the code adjustment result in the target code file, a candidate code segment in the target code file adjacent to the code adjustment result as the target code segment, and determining an area surrounding the display area of ​​the target code segment on the interactive interface as the target display area. It should be noted that the surrounding area is not excessively limited and may, for example, include a left area, a right area, etc.

[0095] It should be noted that there are no excessive restrictions on the location of the code adjustment result in the target code file, for example, the code line number may be included.

[0096] S308: Display the target dialogue text on the interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

[0097] The relevant contents of step S308 can be found in the above embodiment and will not be repeated here.

[0098] The large-model-based code processing method proposed in this disclosure determines a target display area for the code adjustment result on an interactive interface based on the position of the code adjustment result in the target code file, and displays the code adjustment result within the target display area. This allows the target display area for the code adjustment result to be determined based on its position within the code file to be processed, thereby increasing the flexibility of displaying the code adjustment result.

[0099] In the above embodiment, regarding the display of the code processing result and the target dialogue text on the interactive interface in step S104, it can be combined with Figure 4 Further understanding, Figure 4 This is a flow chart of a code processing method based on a large model according to another embodiment of the present disclosure. Figure 4 As shown, the method includes:

[0100] S401: Obtain a first dialogue text for describing a code processing task.

[0101] S402: Use at least one of the newly added code file and the original code file as a target code file corresponding to the code processing task.

[0102] S403: Input the first dialogue text into the large model, and the large model outputs the code processing result of the target code file and the second dialogue text for the first dialogue text.

[0103] The relevant contents of steps S401-S403 can be found in the above embodiment and will not be repeated here.

[0104] S404: In response to there being multiple code processing tasks, the code processing results and target dialogue text corresponding to the same code processing task are displayed in association on the interactive interface.

[0105] It should be noted that the code processing result corresponding to the code processing task refers to the code processing result of the target code file corresponding to the code processing task.

[0106] For example, the code processing tasks include code processing tasks 1 to 3. Taking code processing task 1 as an example, the code processing result corresponding to code processing task 1 and the target dialogue text corresponding to code processing task 1 can be displayed in association on the interactive interface. Taking code processing task 2 as an example, the code processing result corresponding to code processing task 2 and the target dialogue text corresponding to code processing task 2 can be displayed in association on the interactive interface. Taking code processing task 3 as an example, the code processing result corresponding to code processing task 3 and the target dialogue text corresponding to code processing task 3 can be displayed in association on the interactive interface.

[0107] It should be noted that there are no excessive restrictions on the specific manner of associating and displaying the code processing results and target dialogue text corresponding to the same code processing task.

[0108] Exemplarily, the associated display of the code processing result and target dialogue text corresponding to the same code processing task includes, in response to detecting a first operation on the code processing result corresponding to the i-th code processing task, displaying the target dialogue text corresponding to the i-th code processing task on the interactive interface. It should be noted that the first operation is not particularly limited and may, for example, include a mouse hover operation, a click operation, etc.

[0109] Exemplarily, the code processing results and target dialogue text corresponding to the same code processing task are displayed in association, including displaying the code processing result corresponding to the i-th code processing task on the interactive interface in response to detecting a first operation on the target dialogue text corresponding to the i-th code processing task.

[0110] Exemplarily, the code processing result and the target dialogue text corresponding to the same code processing task are displayed in association, including establishing a hyperlink between the code processing result and the target dialogue text corresponding to the same code processing task.

[0111] Exemplarily, the code processing results and target dialogue text corresponding to the same code processing task are displayed in association, including displaying the target dialogue text corresponding to the i-th code processing task in the surrounding area of ​​the display area of ​​the code processing result corresponding to the i-th code processing task on the interactive interface.

[0112] The large-model-based code processing method proposed in this disclosure associates the code processing results and target dialogue text corresponding to multiple code processing tasks on the interactive interface. This allows users to easily distinguish between the code processing results and target dialogue text corresponding to multiple code processing tasks, simplifying user operations and optimizing the user experience in code processing scenarios.

[0113] Based on any of the above embodiments, the method further includes, in response to there being multiple code processing tasks, generating a task list based on the task information of each of the multiple code processing tasks, and displaying the task list on the interactive interface. Thus, in the case of multiple code processing tasks, the task list can be generated and displayed taking into account the task information of each of the multiple code processing tasks, thereby facilitating a more intuitive understanding of the task information of each of the multiple code processing tasks and optimizing the user experience in the code processing scenario.

[0114] Exemplarily, the i-th list item of the task list may be generated based on the task information of the i-th code processing task (such as the first dialogue text and task progress), wherein the i-th list item is used to represent the i-th code processing task.

[0115] In the above embodiment, regarding the display of the code processing result and the target dialogue text on the interactive interface in step S104, it can be combined with Figure 5 Further understanding, Figure 5 This is a flow chart of a code processing method based on a large model according to another embodiment of the present disclosure. Figure 5 As shown, the method includes:

[0116] S501: Obtain a first dialogue text for describing a code processing task.

[0117] S502: Use at least one of the newly added code file and the original code file as a target code file corresponding to the code processing task.

[0118] S503: Input the first dialogue text into the large model, and the large model outputs the code processing result of the target code file and the second dialogue text for the first dialogue text.

[0119] S504 : In response to there being multiple code processing tasks, generate a task list based on task information of each of the multiple code processing tasks.

[0120] S505: Display the task list on the interactive interface.

[0121] The relevant contents of steps S501-S505 can be found in the above embodiment and will not be repeated here.

[0122] S506 : In response to detecting a selection operation on a code processing task in the task list, obtaining the code processing task selected by the selection operation.

[0123] S507: Display the code processing result and target dialogue text corresponding to the selected code processing task on the interactive interface.

[0124] It should be noted that there are not too many restrictions on the selection operation, for example, it may include a click operation, a mouse hover operation, etc.

[0125] Exemplarily, the i-th list item of the task list can be generated based on the task information of the i-th code processing task, wherein the i-th list item is used to represent the i-th code processing task, and in response to detecting a selection operation for the i-th list item in the task list, the i-th code processing task can be selected as the code processing task selected by the selection operation.

[0126] For example, a task list can be displayed on the interactive interface, where the task list includes 10 list items. In response to detecting a selection operation on the third list item in the task list, the third code processing task is selected as the code processing task selected by the selection operation, and the code processing result and target dialogue text corresponding to the third code processing task are displayed on the interactive interface.

[0127] The large-model-based code processing method proposed in this disclosure, in response to detecting a selection operation on a code processing task in a task list, obtains the code processing task selected by the selection operation and displays the code processing result and target dialogue text corresponding to the selected code processing task on an interactive interface. Thus, a user's selection operation on a code processing task in the task list triggers the display of the code processing result and target dialogue text. Specifically, the code processing result and target dialogue text corresponding to the user-selected code processing task are displayed on the interactive interface, enabling personalized display of the code processing result and target dialogue text, thereby optimizing the user experience in code processing scenarios.

[0128] Figure 6 This is a flow chart of a code processing method based on a large model according to another embodiment of the present disclosure. Figure 6 As shown, the method includes:

[0129] S601: Obtain a first dialogue text for describing a code processing task.

[0130] S602: Use at least one of the newly added code file and the original code file as a target code file corresponding to the code processing task.

[0131] S603: Input the first dialogue text into the large model, and the large model outputs a code processing result of the target code file and a second dialogue text corresponding to the first dialogue text.

[0132] S604: Display the code processing result and the target dialogue text on the interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

[0133] The relevant contents of steps S601-S604 can be found in the above embodiment and will not be repeated here.

[0134] S605: Display the target page component on the interactive interface, wherein there is a corresponding relationship between the target page component and the code processing result.

[0135] S606: In response to detecting a setting operation for a target page component, determining whether a code processing result corresponding to the target page component is effective or invalid.

[0136] It should be noted that there are no excessive restrictions on setting operations, for example, they may include click operations.

[0137] In one embodiment, the target page component includes a first page component, and there is a one-to-one correspondence between the first page component and the code processing result. In response to detecting a setting operation for the target page component, it is determined whether the code processing result corresponding to the target page component is effective or invalid, including determining that the code processing result corresponding to the first page component is effective in response to detecting a setting operation for the first page component.

[0138] For example, the first page component includes icons such as "adopt", "accept", and "agree". Figure 9 As shown, the first page component is the "Adopt" icon.

[0139] In one embodiment, the target page component includes a second page component, and there is a one-to-one correspondence between the second page component and the code processing result. In response to detecting a setting operation for the target page component, it is determined whether the code processing result corresponding to the target page component is effective or invalid, including responding to detecting a setting operation for the second page component and determining that the code processing result corresponding to the second page component is invalid.

[0140] For example, the second page component includes icons such as "abandon" and "reject". Figure 9 As shown, the second page component is a "discard" icon.

[0141] In one embodiment, the target page component includes a third page component, and in response to detecting a setting operation on the target page component, determining whether a code processing result corresponding to the target page component is valid or invalid includes determining that each code processing result is valid in response to detecting the setting operation on the third page component. It is understood that there is a corresponding relationship between the third page component and each code processing result.

[0142] For example, the third page component includes icons such as "Adopt All", "Accept All", and "Agree All". Figure 9 As shown, the third page component is the "Adopt All" icon.

[0143] In one embodiment, the target page component includes a fourth page component, and in response to detecting a setting operation on the target page component, determining whether a code processing result corresponding to the target page component is valid or invalid includes, in response to detecting the setting operation on the fourth page component, determining that each code processing result is invalid. It is understood that there is a corresponding relationship between the fourth page component and each code processing result.

[0144] For example, the fourth page component includes icons such as "abandon all" and "reject all". Figure 9 As shown, the fourth page component is the "Discard All" icon.

[0145] In one embodiment, after determining that the code processing result is effective, the process further includes, in response to the target code file being a newly added code file, saving the target code file; in response to the code processing result including a code adjustment result, updating the target code file based on the code adjustment result; and in response to the code processing result including a code repair strategy, repairing the target code file according to the code repair strategy. Thus, after determining that the code processing result is effective, the newly added code file can be saved, and / or the code file to be processed can be updated based on the code adjustment result, and / or the code file to be processed can be repaired based on the code repair strategy.

[0146] In some examples, based on the code adjustment result, the target code file is updated, including: in response to the code adjustment result including newly added code, storing the newly added code to the target code file; in response to the code adjustment result including deleted code, deleting the deleted code from the target code file; in response to the code adjustment result including the code before modification and the code after modification, replacing the code before modification in the target code file with the modified code; in response to the code adjustment result indicating deletion of the target code file, deleting the target code file.

[0147] In one embodiment, after determining that the code processing result is invalid, the method further includes deleting the target code file in response to the target code file being a newly added code file, and maintaining the target code file unchanged in response to the target code file being an existing code file. Thus, after determining that the code processing result is invalid, the newly added code file can be deleted and / or the existing code file can be maintained unchanged.

[0148] The code processing method based on a large model proposed in this disclosure displays a target page component on an interactive interface, wherein a corresponding relationship exists between the target page component and the code processing result. In response to detecting a setting operation for the target page component, the code processing result corresponding to the target page component is determined to be effective or ineffective. Thus, the effectiveness or ineffectiveness of the code processing result can be determined based on the user's setting operation for the target page component. That is, the effectiveness of the code processing result can be determined based on user feedback, and the effectiveness of the code processing result can be personalized, thereby optimizing the user experience in the code processing scenario.

[0149] Figure 7 This is a flow chart of a code processing method based on a large model according to another embodiment of the present disclosure. Figure 7 As shown, the method includes:

[0150] S701: Obtain a first dialogue text for describing a code processing task.

[0151] S702: Use at least one of the newly added code file and the original code file as a target code file corresponding to the code processing task.

[0152] The relevant contents of steps S701-S702 can be found in the above embodiment and will not be repeated here.

[0153] S703: Input the first dialogue text into the large model, and perform intent recognition on the first dialogue text through the large model to obtain the user intent.

[0154] It should be noted that the intent recognition of the first dialogue text through the large model can be implemented by using any intent recognition method in the relevant technology, and no excessive restrictions are made here.

[0155] S704: Split the original task described in the first dialogue text based on the user intention using the large model to obtain N code processing tasks, where N is a positive integer.

[0156] In one embodiment, the original task described in the first dialogue text is split based on user intent using a large model to obtain N code processing tasks, including splitting the original task into N code processing tasks of a single task category based on user intent using a large model.

[0157] For example, the first dialogue text is "Write a unit test code for me and perform a unit test on xx1". The big model can be used to identify the intent of the first dialogue text and obtain the user's intention to generate unit test code and perform a unit test on xx1. The big model can also split the original task described in the first dialogue text based on the user's intention to obtain code processing tasks 1 and 2. Code processing task 1 is a code adjustment task for generating unit test code, and code processing task 2 is a code testing task for performing a unit test on xx1.

[0158] S705 , processing the i-th code processing task through the large model to obtain a code processing result and a second dialogue text corresponding to the i-th code processing task, where i is a positive integer not greater than N.

[0159] In one embodiment, the processing process of the large model for multiple code processing tasks is parallel, that is, the large model can generate the code processing results corresponding to the multiple code processing tasks and the second dialogue texts of the multiple code processing tasks in parallel.

[0160] It should be noted that the relevant content of step S705 can refer to the relevant content of step S103, which will not be repeated here.

[0161] S706: Display the code processing result and the target dialogue text on the interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

[0162] The relevant contents of step S706 can be found in the above embodiment and will not be repeated here.

[0163] The large-model-based code processing method proposed in this disclosure uses the large model to perform intent recognition on a first conversation text to obtain user intent. Based on the user intent, the large model then splits the original task described in the first conversation text into N code processing tasks, where N is a positive integer. The large model then processes the i-th code processing task to obtain a code processing result corresponding to the i-th code processing task and a second conversation text, where i is a positive integer not greater than N. Thus, the large model can be used to perform intent recognition on the first conversation text to perform task splitting, obtaining multiple code processing tasks. These multiple code processing tasks can then be processed using the large model. This method is suitable for complex code processing task processing scenarios, as users only need to perform conversation operations, eliminating the need for them to split tasks themselves. This simplifies user operations and optimizes the user experience in code processing scenarios.

[0164] Based on any of the above embodiments, Figure 8 As shown, the client can obtain the first dialogue text and the target code file, and send the first dialogue text to the server.

[0165] The server can input the first dialogue text into the big model, perform intent recognition on the first dialogue text through the big model to obtain user intent, split the original task described in the first dialogue text based on the user intent through the big model to obtain N code processing tasks, call the target tool through the big model to process the i-th code processing task, obtain the code processing result and the second dialogue text corresponding to the i-th code processing task, and send the code processing result and the second dialogue text output by the big model to the client.

[0166] The client may display the code processing result, the second dialog text and the target page component on the interactive interface, and in response to detecting a setting operation for the target page component, determine whether the code processing result corresponding to the target page component is effective.

[0167] In the technical solutions disclosed herein, the collection, storage, use, processing, transmission, provision and disclosure of user personal information involved comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0168] According to an embodiment of the present disclosure, the present disclosure also provides a large model-based code processing device for implementing the above-mentioned large model-based code processing method.

[0169] Figure 10 4 is a block diagram of a code processing device based on a large model according to an embodiment of the present disclosure.

[0170] like Figure 10 As shown, the code processing device 1000 based on the large model includes: a first acquisition module 1001, a second acquisition module 1002, a processing module 1003 and a display module 1004.

[0171] A first acquisition module 1001 is used to acquire a first dialogue text for describing a code processing task;

[0172] A second acquisition module 1002 is configured to use at least one of the newly added code file and the original code file as a target code file corresponding to the code processing task;

[0173] A processing module 1003 is configured to input the first dialogue text into a large model, and the large model outputs a code processing result of the target code file and a second dialogue text corresponding to the first dialogue text;

[0174] The display module 1004 is configured to display the code processing result and the target dialogue text on an interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text.

[0175] In one embodiment of the present disclosure, the display module 1004 is further used to: in response to the target code file not being displayed on the interactive interface, display the target code file on the interactive interface; in response to the target code file being displayed on the interactive interface, continue to display the target code file on the interactive interface.

[0176] In one embodiment of the present disclosure, the display module 1004 is further configured to: in response to the code processing result including a code adjustment result, display the code adjustment result in a display area of ​​the target code file on the interactive interface.

[0177] In one embodiment of the present disclosure, the display module 1004 is further used to: in response to the code processing result including a code adjustment result, determine the target display area of ​​the code adjustment result on the interactive interface based on the position of the code adjustment result in the target code file; and display the code adjustment result in the target display area.

[0178] In one embodiment of the present disclosure, the display module 1004 is further configured to: in response to the number of code processing tasks being multiple, display the code processing results and target dialogue text corresponding to the same code processing task in an associated manner on the interactive interface.

[0179] In one embodiment of the present disclosure, the display module 1004 is further used to: in response to the number of code processing tasks being multiple, generate a task list based on the task information of each of the multiple code processing tasks; and display the task list on the interactive interface.

[0180] In one embodiment of the present disclosure, the display module 1004 is further used to: in response to detecting a selection operation for a code processing task in the task list, obtain the code processing task selected by the selection operation; and display the code processing result and target dialogue text corresponding to the selected code processing task on the interactive interface.

[0181] In one embodiment of the present disclosure, the display module 1004 is further used to: display a target page component on the interactive interface, wherein there is a corresponding relationship between the target page component and the code processing result; in response to detecting a setting operation for the target page component, determine whether the code processing result corresponding to the target page component is effective or invalid.

[0182] In one embodiment of the present disclosure, after determining that the code processing result is effective, the processing module 1003 is further used to: in response to the target code file being a newly added code file, save the target code file; in response to the code processing result including a code adjustment result, update the target code file based on the code adjustment result; in response to the code processing result including a code repair strategy, repair the target code file according to the code repair strategy.

[0183] In one embodiment of the present disclosure, after determining that the code processing result is invalid, the processing module 1003 is further used to: in response to the target code file being a newly added code file, delete the target code file; in response to the target code file being an original code file, maintain the target code file unchanged.

[0184] In one embodiment of the present disclosure, the second acquisition module 1002 is further used to: in response to the code processing task meeting the set conditions, add a new code file and use the newly added code file as the target code file; in response to the code processing task not meeting the set conditions, determine the target code file from multiple original code files.

[0185] In one embodiment of the present disclosure, the second acquisition module 1002 is further configured to: in response to the code processing task including at least one of generating test code and adding a new code template, determine that the code processing task meets the set condition.

[0186] In one embodiment of the present disclosure, the second acquisition module 1002 is further configured to: determine a search parameter for the target code file based on the first conversation text; and determine the target code file from a plurality of the original code files based on the search parameter.

[0187] In one embodiment of the present disclosure, the processing module 1003 is further used to: perform intent recognition on the first dialogue text through the large model to obtain user intent; split the original task described in the first dialogue text based on the user intent through the large model to obtain N code processing tasks, where N is a positive integer; process the i-th code processing task through the large model to obtain a code processing result and a second dialogue text corresponding to the i-th code processing task, where i is a positive integer not greater than N.

[0188] The code processing device based on a large model proposed in the present disclosure obtains a first dialogue text used to describe a code processing task, uses at least one of a newly added code file and an existing code file as the target code file corresponding to the code processing task, inputs the first dialogue text into the large model, and the large model outputs a code processing result for the target code file and a second dialogue text corresponding to the first dialogue text. The code processing result and the target dialogue text are displayed on an interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text. Thus, the newly added code file and / or the existing code file can be used as the code file to be processed, which can achieve automatic determination of the code file to be processed. The user only needs to perform a dialogue operation, without manually adding a new code file or specifying (e.g., selecting or opening) the code file to be processed on the client, thus simplifying user operations. In addition, the code processing result and the second dialogue text of the target code file can be obtained based on the first dialogue text through the large model, achieving automatic processing of the code processing task, improving code processing efficiency, and displaying the code processing result and the target dialogue text on the interactive interface, allowing the user to more intuitively understand the processing status of the code processing task and optimizing the user experience in the code processing scenario.

[0189] According to embodiments of the present disclosure, the present disclosure also provides an electronic device, a readable storage medium, and a computer program product.

[0190] Figure 11 A schematic block diagram of an example electronic device 1100 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital assistants, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are provided as examples only and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0191] like Figure 11 As shown, the device 1100 includes a computing unit 1101, which can perform various appropriate actions and processes according to a computer program stored in a read-only memory (ROM) 1102 or a computer program loaded from a storage unit 1108 into a random access memory (RAM) 1103. Various programs and data required for the operation of the device 1100 can also be stored in the RAM 1103. The computing unit 1101, the ROM 1102, and the RAM 1103 are connected to each other via a bus 1104. An input / output (I / O) interface 1105 is also connected to the bus 1104.

[0192] Various components in device 1100 are connected to I / O interface 1105, including an input unit 1106, such as a keyboard, mouse, etc.; an output unit 1106, such as various types of displays, speakers, etc.; a storage unit 1108, such as a magnetic disk, optical disk, etc.; and a communication unit 1109, such as a network card, modem, wireless communication transceiver, etc. The communication unit 1109 allows device 1100 to exchange information / data with other devices via a computer network such as the Internet and / or various telecommunication networks.

[0193] The computing unit 1101 can be a variety of general-purpose and / or specialized processing components with processing and computing capabilities. Some examples of the computing unit 1101 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various dedicated artificial intelligence (AI) computing chips, various computing units that run machine learning model algorithms, digital signal processors (DSPs), and any appropriate processors, controllers, microcontrollers, etc. The computing unit 1101 performs the various methods and processes described above, such as the code processing method based on the large model. For example, in some embodiments, the code processing method based on the large model can be implemented as a computer software program, which is tangibly contained in a machine-readable medium, such as the storage unit 1108. In some embodiments, part or all of the computer program can be loaded and / or installed on the device 1100 via the ROM 1102 and / or the communication unit 1109. When the computer program is loaded into the RAM 1103 and executed by the computing unit 1101, one or more steps of the code processing method based on the large model described above can be performed. Alternatively, in other embodiments, the computing unit 1101 may be configured to execute the large model-based code processing method in any other appropriate manner (for example, by means of firmware).

[0194] Various embodiments of the systems and techniques described herein can be implemented in digital electronic circuit systems, integrated circuit systems, field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), system-on-chip systems (SOCs), programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments can include being implemented in one or more computer programs that are executable and / or interpreted on a programmable system that includes at least one programmable processor, which can be a special purpose or general purpose programmable processor that can receive data and instructions from a storage system, at least one input device, and at least one output device, and transmit data and instructions to the storage system, the at least one input device, and the at least one output device.

[0195] The program code for implementing the method of the present disclosure can be written in any combination of one or more programming languages. Such program code can be provided to a processor or controller of a general-purpose computer, a special-purpose computer, or other programmable data processing device so that when the program code is executed by the processor or controller, the functions / operations specified in the flow chart and / or block diagram are implemented. The program code can be executed entirely on the machine, partially on the machine, as a stand-alone software package, partially on the machine and partially on a remote machine, or entirely on a remote machine or server.

[0196] In the context of the present disclosure, a machine-readable medium can be a tangible medium that can contain or store a program for use by or in conjunction with an instruction execution system, device or equipment. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or equipment, or any suitable combination of the foregoing. A more specific example of a machine-readable storage medium can include an electrical connection based on one or more lines, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

[0197] To initiate interaction with a user account, the systems and techniques described herein can be implemented on a computer having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user account; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user account can provide input to the computer. Other types of devices can also be used to initiate interaction with the user account; for example, feedback provided to the user account can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user account can be received in any form (including acoustic input, voice input, or tactile input).

[0198] The systems and techniques described herein can be implemented in a computing system that includes back-end components (e.g., as a data server), or a computing system that includes middleware components (e.g., an application server), or a computing system that includes front-end components (e.g., a user account computer with a graphical user account interface or a web browser through which a user account can interact with embodiments of the systems and techniques described herein), or a computing system that includes any combination of such back-end components, middleware components, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: a local area network (LAN), a wide area network (WAN), and the Internet.

[0199] A computer system may include a client and a server. The client and server are generally remote from each other and typically interact through a communication network. The client-server relationship arises through computer programs running on the respective computers and having a client-server relationship with each other. The server may be a cloud server, a server in a distributed system, or a server integrated with a blockchain.

[0200] According to an embodiment of the present disclosure, the present disclosure further provides a computer program product, including a computer program, wherein when the computer program is executed by a processor, the steps of the large model-based code processing method described in the above embodiment of the present disclosure are implemented.

[0201] It should be understood that the various forms of the processes shown above can be used to reorder, add, or delete steps. For example, the steps described in this disclosure can be performed in parallel, sequentially, or in a different order, as long as the desired results of the technical solutions disclosed in this disclosure can be achieved. This is not limited herein.

[0202] The above specific embodiments do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art will appreciate that various modifications, combinations, sub-combinations, and substitutions may be made based on design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure shall be included within the scope of protection of this disclosure.

Claims

1. A code processing method based on a large model, comprising: Obtaining a first dialogue text for describing a code processing task; Using at least one of the newly added code file and the original code file as the target code file corresponding to the code processing task; Inputting the first dialogue text into a large model, and having the large model output a code processing result of the target code file and a second dialogue text corresponding to the first dialogue text; The code processing result and the target dialogue text are displayed on the interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text; wherein, Displaying the code processing result and the target dialogue text on the interactive interface includes: In response to the number of code processing tasks being multiple, displaying the code processing results and target dialogue text corresponding to the same code processing task in association on the interactive interface; The method further comprises: Displaying a target page component on the interactive interface, wherein there is a corresponding relationship between the target page component and the code processing result; In response to detecting a setting operation for the target page component, it is determined whether a code processing result corresponding to the target page component is valid or invalid.

2. The method according to claim 1, wherein The method further comprises: In response to the object code file not being displayed on the interactive interface, displaying the object code file on the interactive interface; In response to the object code file being displayed on the interactive interface, continue to display the object code file on the interactive interface.

3. The method according to claim 2, wherein: Displaying the code processing result on the interactive interface includes: In response to the code processing result including a code adjustment result, the code adjustment result is displayed in a display area of ​​the target code file on the interactive interface.

4. The method according to claim 1, wherein Displaying the code processing result on the interactive interface includes: In response to the code processing result including a code adjustment result, determining a target display area of ​​the code adjustment result on the interactive interface based on a position of the code adjustment result in the target code file; The code adjustment result is displayed in the target display area.

5. The method according to claim 1, wherein The method further comprises: In response to the number of code processing tasks being multiple, generating a task list based on task information of each of the multiple code processing tasks; The task list is displayed on the interactive interface.

6. The method according to claim 5, wherein: Displaying the code processing result and the target dialogue text on the interactive interface includes: In response to detecting a selection operation for a code processing task in the task list, obtaining the code processing task selected by the selection operation; The code processing result and target dialogue text corresponding to the selected code processing task are displayed on the interactive interface.

7. The method according to claim 1, wherein After determining that the code processing result is effective, the method further includes: In response to the target code file being a newly added code file, saving the target code file; In response to the code processing result including a code adjustment result, updating the target code file based on the code adjustment result; In response to the code processing result including a code repair strategy, the target code file is repaired according to the code repair strategy.

8. The method according to claim 1, wherein After determining that the code processing result is invalid, the method further includes: In response to the target code file being a newly added code file, deleting the target code file; In response to the target code file being an original code file, the target code file is maintained unchanged.

9. The method according to any one of claims 1 to 8, wherein The step of using at least one of the newly added code file and the original code file as the target code file corresponding to the code processing task includes: In response to the code processing task meeting the set conditions, adding a code file, and using the newly added code file as the target code file; In response to the code processing task not meeting a set condition, the target code file is determined from a plurality of original code files.

10. The method according to claim 9, wherein: The method further comprises: In response to the code processing task including at least one of generating a test code and adding a new code template, it is determined that the code processing task meets the set condition.

11. The method according to claim 9, wherein Determining the target code file from a plurality of original code files includes: determining a search parameter for the target code file based on the first conversation text; Based on the search parameter, the target code file is determined from a plurality of original code files.

12. The method according to any one of claims 1 to 8, wherein The method further comprises: Performing intent recognition on the first conversation text using the large model to obtain user intent; Splitting the original task described in the first dialogue text based on the user intent using the large model to obtain N code processing tasks, where N is a positive integer; The i-th code processing task is processed by the large model to obtain a code processing result and a second dialogue text corresponding to the i-th code processing task, wherein i is a positive integer not greater than N.

13. A code processing device based on a large model, comprising: A first acquisition module, configured to acquire a first dialogue text describing a code processing task; A second acquisition module is configured to use at least one of the newly added code file and the original code file as a target code file corresponding to the code processing task; a processing module, configured to input the first dialogue text into a large model, and have the large model output a code processing result of the target code file and a second dialogue text corresponding to the first dialogue text; A display module is configured to display the code processing result and target dialogue text on an interactive interface, wherein the target dialogue text includes at least one of the first dialogue text and the second dialogue text; wherein, The display module is further used for: In response to the number of code processing tasks being multiple, displaying the code processing results and target dialogue text corresponding to the same code processing task in association on the interactive interface; Displaying a target page component on the interactive interface, wherein there is a corresponding relationship between the target page component and the code processing result; In response to detecting a setting operation for the target page component, it is determined whether a code processing result corresponding to the target page component is valid or invalid.

14. The device according to claim 13, wherein The display module is further used for: In response to the object code file not being displayed on the interactive interface, displaying the object code file on the interactive interface; In response to the object code file being displayed on the interactive interface, continue to display the object code file on the interactive interface.

15. The device according to claim 14, wherein The display module is further used for: In response to the code processing result including a code adjustment result, the code adjustment result is displayed in a display area of ​​the target code file on the interactive interface.

16. The device according to claim 13, wherein The display module is further used for: In response to the code processing result including a code adjustment result, determining a target display area of ​​the code adjustment result on the interactive interface based on a position of the code adjustment result in the target code file; The code adjustment result is displayed in the target display area.

17. The device according to claim 13, wherein The display module is further used for: In response to the number of code processing tasks being multiple, generating a task list based on task information of each of the multiple code processing tasks; The task list is displayed on the interactive interface.

18. The device according to claim 17, wherein The display module is further used for: In response to detecting a selection operation for a code processing task in the task list, obtaining the code processing task selected by the selection operation; The code processing result and target dialogue text corresponding to the selected code processing task are displayed on the interactive interface.

19. The device according to claim 13, wherein After determining that the code processing result is effective, the processing module is further configured to: In response to the target code file being a newly added code file, saving the target code file; In response to the code processing result including a code adjustment result, updating the target code file based on the code adjustment result; In response to the code processing result including a code repair strategy, the target code file is repaired according to the code repair strategy.

20. The apparatus according to claim 13, wherein After determining that the code processing result is invalid, the processing module is further configured to: In response to the target code file being a newly added code file, deleting the target code file; In response to the target code file being an original code file, the target code file is maintained unchanged.

21. The device according to any one of claims 13 to 20, wherein: The second acquisition module is further configured to: In response to the code processing task meeting the set conditions, adding a code file, and using the newly added code file as the target code file; In response to the code processing task not meeting a set condition, the target code file is determined from a plurality of original code files.

22. The device according to claim 21, wherein The second acquisition module is further configured to: In response to the code processing task including at least one of generating a test code and adding a new code template, it is determined that the code processing task meets the set condition.

23. The device according to claim 21, wherein The second acquisition module is further configured to: determining a search parameter for the target code file based on the first conversation text; Based on the search parameter, the target code file is determined from a plurality of the original code files.

24. The device according to any one of claims 13 to 20, wherein: The processing module is further configured to: Performing intent recognition on the first conversation text using the large model to obtain user intent; Splitting the original task described in the first dialogue text based on the user intent using the large model to obtain N code processing tasks, where N is a positive integer; The i-th code processing task is processed by the large model to obtain a code processing result and a second dialogue text corresponding to the i-th code processing task, wherein i is a positive integer not greater than N.

25. An electronic device comprising: at least one processor; as well as a memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to perform the method according to any one of claims 1 to 12.

26. A non-transitory computer-readable storage medium storing computer instructions, wherein: The computer instructions are used to cause the computer to execute the method according to any one of claims 1-12.

Images