Data processing method and device, computing equipment, storage medium and program product

Abstract

The invention provides a data processing method and device, computing equipment, a storage medium and a program product, and the method comprises the steps: determining a target task, and distributing the target task to a target client; in response to a code submission request sent by the target client, processing submission information carried in the code submission request by using a task association model, and determining an association task corresponding to the code submission request; under the condition that the associated task is the target task, performing construction and test inspection on the target task; under the condition that the inspection is passed, a target version program corresponding to the target task is released, and a version report corresponding to the target version program is generated and sent to an associated client; the standardization and traceability of version release are improved, and the information transparency of cross-team cooperation is enhanced; the automation level, the quality guarantee capability and the cooperation efficiency of the software research and development process are optimized, and efficient and reliable version management can be achieved.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a data processing method, a data processing apparatus, a data processing system, a computing device, a computer-readable storage medium, and a computer program product. Background Art

[0002] In the context of modern software development, task management, code submission, and version release constitute three crucial links. In traditional workflows, development teams have to perform these steps manually, which not only reduces work efficiency but also increases the risk of errors. Summary of the Invention

[0003] In view of this, the embodiments of the present application provide a data processing method to address the technical deficiencies in the prior art. The embodiments of the present application also provide a data processing apparatus, a data processing system, a computing device, a computer-readable storage medium, and a computer program product.

[0004] According to a first aspect of an embodiment of the present application, a data processing method is provided, including: Determine a target task, and assign the target task to a target client; In response to a code submission request sent by the target client, the task association model is used to process submission information carried in the code submission request to determine an associated task corresponding to the code submission request; In a case where the associated task is the target task, constructing and testing the target task; If the verification is passed, the target version program corresponding to the target task is released, and a version report corresponding to the target version program is generated and sent to the associated client.

[0005] According to a second aspect of an embodiment of the present application, there is provided a data processing device, including: A task assignment module is configured to determine a target task and assign the target task to a target client; a task association module configured to, in response to a code submission request sent by the target client, process submission information carried in the code submission request using a task association model, and determine an associated task corresponding to the code submission request; A task verification module is configured to construct and test the target task when the associated task is the target task; The version publishing module is configured to publish the target version program corresponding to the target task if the verification is passed, and generate and send a version report corresponding to the target version program to the associated client.

[0006] According to a third aspect of an embodiment of the present application, there is provided a data processing system, including: A task management unit, configured to determine a target task and assign the target task to a target client; A version control unit, configured to respond to a code submission request sent by the target client, process submission information carried in the code submission request using a task association model, and determine an associated task corresponding to the code submission request; A construction and testing unit, configured to construct and test the target task if the associated task is the target task; The task management unit is further configured to, if the verification is passed, publish the target version program corresponding to the target task, and generate and send a version report corresponding to the target version program to an associated client.

[0007] According to a fourth aspect of an embodiment of the present application, there is provided a computing device, including: a memory and a processor; The memory is used to store computer programs / instructions, and the processor is used to execute the computer programs / instructions. When the computer programs / instructions are executed by the processor, a data processing method is implemented.

[0008] According to a fifth aspect of an embodiment of the present application, a computer-readable storage medium is provided, which stores a computer program / instruction, and the computer program / instruction implements a data processing method when executed by a processor.

[0009] According to a sixth aspect of an embodiment of the present application, a computer program product is provided, comprising a computer program / instruction, which implements a data processing method when executed by a processor.

[0010] The data processing method provided in this application realizes closed-loop management of the entire process from task assignment, code submission, automated build and test to version release by intelligently identifying the association between code submission and target tasks. Specifically, after determining the target task and assigning it to the target client, the system can respond to the code submission request sent by the client, analyze the submission information using the task association model, and accurately identify the associated task corresponding to the submission. This mechanism improves the automation level of task binding and reduces manual configuration costs. On the premise that the associated task is confirmed to be the target task, the system automatically triggers the build and test inspection process for the target task, ensuring that the quality and impact scope of each submission can be verified in a timely manner, thereby improving the efficiency and stability of continuous integration. If the test inspection passes, the corresponding target version program is released, and a structured version report is automatically generated and pushed to the associated client, which not only improves the standardization and traceability of version releases, but also enhances the information transparency and delivery controllability of cross-team collaboration. It optimizes the automation level, quality assurance capability and collaborative efficiency of the software development process, and helps to achieve efficient and reliable version management. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] Figure 1 This is a flow chart of a data processing method provided by an embodiment of the present application; Figure 2 This is a processing flow chart of a data processing method provided in one embodiment of the present application; Figure 3 This is a structural diagram of a data processing system provided by an embodiment of the present application; Figure 4 This is a structural diagram of a data processing device provided by an embodiment of the present application; Figure 5 This is a structural block diagram of a computing device provided in one embodiment of the present application. DETAILED DESCRIPTION

[0012] The following description sets forth many specific details to facilitate a thorough understanding of the present application. However, the present application can be implemented in many other ways than those described herein, and those skilled in the art can make similar generalizations without violating the scope of the present application. Therefore, the present application is not limited to the specific implementations disclosed below.

[0013] The terms used in one or more embodiments of the present application are for the purpose of describing specific embodiments only and are not intended to limit one or more embodiments of the present application. The singular forms "a", "the" and "the" used in one or more embodiments of the present application and the appended claims are also intended to include plural forms, unless the context clearly indicates otherwise. It should also be understood that the term "and / or" used in one or more embodiments of the present application refers to and includes any or all possible combinations of one or more associated listed items.

[0014] It should be understood that although the terms "first," "second," and the like may be used to describe various information in one or more embodiments of the present application, such information should not be limited to these terms. These terms are merely used to distinguish information of the same type from one another. For example, "first" may also be referred to as "second," and similarly, "second" may also be referred to as "first," without departing from the scope of one or more embodiments of the present application.

[0015] The present application provides a data processing method, a data processing apparatus, a computing device, a computer-readable storage medium, and a computer program product, which are described in detail in the following embodiments.

[0016] Figure 1 A flowchart of a data processing method according to an embodiment of the present application is shown, which specifically includes the following steps: Step 102: Determine a target task, and assign the target task to a target client.

[0017] A target task can be understood as a unit of work defined during the software development process with clear objectives and deliverables, including but not limited to development tasks, maintenance tasks, and testing tasks. These tasks guide developers in performing specific code changes, feature implementations, or bug fixes. A target client can be understood as the terminal device that receives and processes the target task.

[0018] Specifically, create a target task (for example, the target task can be to fix a login page bug or implement a payment function), select a suitable developer (or team) based on factors such as task type (development / maintenance), skill matching, and load conditions, and push the target task to the development environment or work platform used by the developer (i.e., the target client).

[0019] In one or more implementations of this specification, a task allocation model is used to parse the initial task information in the task creation request to obtain the target task information, thereby creating a target task based on the target task information, and reasonably allocating the target task to the target client corresponding to the target user based on the target task information and user information. Specific implementation methods are as follows: Determining a target task and assigning the target task to a target client includes: In response to a task creation request, processing initial task information in the task creation request to determine target task information corresponding to the task creation request; The target task is created according to the target task information, and the target task information and user information are analyzed using a task allocation model to determine the target user corresponding to the target task, and the target task is allocated to the target client corresponding to the target user.

[0020] A task creation request can be understood as the user's action of creating a new task through a user interface or interface. Initial task information can be understood as the basic information entered by the user when creating a task, such as title, description, type, priority, etc. The task assignment model can be understood as the machine learning model used to assign target tasks to appropriate users.

[0021] Target task information can be understood as a complete task description generated by the task creation model (a machine learning-based model that identifies task types, estimated development cycles, recommended priorities, and required skill sets), including task priority, task type, required skills, and estimated development cycle. User information can be understood as a developer's historical performance data (code contribution rate, code submission frequency, task completion time, etc.), skill tags, current task load, and other information. Target users can be understood as the developers recommended by the task assignment model to undertake the target task.

[0022] Specifically, when a user submits a task creation form or calls a task creation interface in the project management system, a task creation request is sent to the server. For example, the user clicks "New Task" through the project management interface or triggers the task creation action through an application program interface, voice / text input, etc., thereby sending a task creation request to the server.

[0023] In actual applications, the task creator can fill out a task creation template in the project management system. The task creation template can enter information such as priority, task type, task description and attachments. The task creation template is a predefined task creation form used to standardize work item entry and ensure that the necessary information about task creation is collected in a structured manner. The task creation template is preset by the system administrator, and the specific template content is filled in by the task creator.

[0024] Based on the specific content filled in by the task creator in the task creation template, the initial task information of the target task is obtained. The task creation model is used to perform semantic analysis, keyword extraction, task classification, priority prediction, skill identification and other processing on the initial task information input by the user to supplement and improve the task information.

[0025] For example, the task creation model can use natural language processing technology to extract keywords: "Python", "OAuth2.0", "front-end", so as to infer the required skills for the target task, and predict the task type of the target task (including but not limited to development tasks, testing tasks, and demand analysis tasks), predict the estimated development cycle required for the target task based on the historical completion time, and predict the task priority of the target task (where p0 is urgent, and the urgency of p1, p2, and p3 decreases in sequence).

[0026] The task information output by the task creation model can be confirmed or modified by the user (manual adjustment is supported) as the basic data for subsequent task creation and allocation, thereby accurately determining the target task information corresponding to the task creation request.

[0027] Based on the target task information, a task record is formally created in the project management system, that is, a target task is created, a task identifier corresponding to the target task is generated (a unique number or label representing the target task), and the task status of the target task is recorded as pending assignment.

[0028] Collect developer information (i.e., user information), including but not limited to historical task completion status (code contribution rate, code submission frequency, unit test pass rate, task completion time, submission quality score), developer skill tags, current task volume, etc.; input the target task information and user information into the task allocation model. The task allocation model selects the most suitable developer based on the skills required for the target task, the current developer's load, etc. The specific allocation logic is to recommend developers based on skill matching and workload balance, and support manual intervention (such as manual assignment by the administrator), so as to push the target task to the terminal device or work interface used by the target user.

[0029] By receiving users' task creation requests and automatically analyzing the task content in combination with the task creation model, we can generate complete target task information, and use the task allocation model to realize intelligent task allocation based on the developer's skill tags and load conditions, thereby improving the efficiency and accuracy of task allocation and optimizing team resource scheduling.

[0030] The data processing method provided in the embodiments of this specification can ensure that high-priority tasks are handled by more experienced developers (determined by factors such as code contribution rate, defect repair ability, and completion time) when the target task information includes task priority. It can also balance the workload of the development team based on resource load balancing, avoid individual overload or idleness, thereby improving resource utilization. In addition, when target tasks are allocated based on skill matching, the learning curve or errors caused by unfamiliar fields are reduced, which can improve efficiency and task processing quality.

[0031] In one or more embodiments of the present specification, when a target task is determined, the task state of the target task is determined to be a pending assignment state, and the target task in the pending assignment state is assigned, that is, the target task is assigned to a target client.

[0032] Specifically, the above-mentioned data processing method is applied to a data processing system, which includes a project management unit and an artificial intelligence unit. By connecting the project management unit with the artificial intelligence unit (deployed with an artificial intelligence model, including the above-mentioned task allocation model), the task status is monitored and updated in real time, so that whenever the task status changes, the task status change is notified to the artificial intelligence unit.

[0033] In practice, project management units are used to track tasks, covering various stages such as to-do lists, in-progress status, and completed testing. Task owners, priorities, and other task details can be easily recorded and updated, ensuring that all project participants have a clear understanding of the project status.

[0034] Configure a webhook in the project management unit to ensure that any task status update events are delivered to the AI ​​service in real time. For example, in the above embodiment, when a target task is created, the task status of the target task is automatically determined to be pending assignment. Based on the pending assignment status of the target task, the task assignment model in the AI ​​unit is used to assign the target task.

[0035] Step 104: In response to the code submission request sent by the target client, the submission information carried in the code submission request is processed using a task association model to determine an associated task corresponding to the code submission request.

[0036] In fact, during the software development process, after completing a target task, developers usually submit code changes through a version control unit (which is used to manage code submission and branching strategies, support multi-person collaboration, ensure code quality through code review, and provide a clear contribution history). However, most current systems rely on developers to manually mark task identifiers (such as T1234) in submission information, which is prone to omissions, miswriting, or non-standard situations. In order to improve the automation level and data consistency of the R&D process, this embodiment provides a task automatic association mechanism that can automatically identify and match the corresponding task number when a code submission is detected, and update the relevant information of the associated task in the project management system.

[0037] Among them, the code submission request can be understood as the request triggered after the developer performs the code submission operation, which includes submission information, modified file list and other information; submission information can be understood as the information attached to the code submission, including submission instructions, modified file path and other information.

[0038] The task association model can be understood as an artificial intelligence model built based on natural language processing, which is used to analyze the content of submission information and identify its associated tasks. Associated tasks can be understood as project management tasks associated with this code submission.

[0039] Specifically, when the developer performs a code submission operation on the local client, it triggers the sending of a code submission request to the server. The server receives the code submission request, which carries submission information, and uses the task association model to perform semantic analysis on the submission information, such as extracting keywords and phrases. Through keyword matching, it determines which target task the code submission request is highly correlated with, and outputs the relevant task number.

[0040] In actual applications, if there are multiple matching tasks, the task with the highest similarity can be selected as the associated task corresponding to the code submission request. If the similarity is lower than the set threshold, it will be marked as "No associated task found" and prompt for manual confirmation.

[0041] It should be noted that when determining the associated tasks, additional information such as submission information, file change records, link addresses, submission metadata (submitter, submission time), etc. can be further synchronized to the project management unit, that is, these additional information can be added to the task panel of the corresponding associated tasks to seamlessly connect the code submission with the task details in the project management unit, which facilitates team collaboration and problem tracing.

[0042] When developers submit code in the target client, the system automatically identifies key semantic content in the submission information, matches related tasks using the task association model, and establishes a data association between the two. Automated keyword matching reduces the need for manual entry of task numbers, improves the traceability of submission records, and facilitates future review and auditing.

[0043] This method not only improves the automation level of the R&D process, but also enhances the collaboration between the project management unit and the version control unit, seamlessly connecting code submission with task details in the project management unit, facilitating team collaboration and problem tracing, and helping to improve task tracking efficiency and team collaboration quality.

[0044] In one or more embodiments of this specification, common tasks may be automatically associated based on the developer's corresponding historical submission records. The specific implementation is as follows: After responding to the code submission request sent by the target client, the method further includes: Determine the historical submission record corresponding to the target client, perform submission frequency statistics on the submitted tasks within the target time period in the historical submission record, and determine the associated task from the submitted tasks based on the statistical result.

[0045] Among them, historical submission records can be understood as the code submission records submitted by the target client in the past period of time; the target time period is a configurable time window, such as the last 7 days, the last 3 days, etc., which can be set according to actual conditions; submission frequency statistics can be understood as counting the number of times the target client submits each task in the target time period; related tasks are the tasks that are most likely related to this code submission request, inferred based on indicators such as submission frequency and time intensity.

[0046] Specifically, in response to a code submission request sent by a target client, the historical submission records of the target client within a target time period are extracted from the code submission log. By analyzing the historical submission information, the submission task associated with each code submission is determined, thereby counting the submission frequency of each submission task within the target time period, and determining the submission task with the highest submission frequency as the associated task, thereby realizing the use of frequently used tasks as associated tasks.

[0047] In actual applications, if multiple tasks are submitted with the same frequency, factors such as the most recent submission time and keyword matching degree are further considered to determine related tasks from the submitted tasks, which are not limited here.

[0048] The data processing method provided in the embodiments of this specification can automatically identify the historical submission records of the target client when receiving a code submission request from the target client, analyze its submission frequency within the target time period, and recommend the most likely related related tasks based on this, thereby improving the association efficiency.

[0049] In one or more embodiments of this specification, when using the task association model to determine the code submission request corresponding to the associated task, the determination is made through keyword extraction and similarity matching. The specific implementation is as follows: The task association model is used to process the submission information carried in the code submission request to determine the associated task corresponding to the code submission request, including: Extract keywords from the submission information carried in the code submission request to obtain submission keywords; The task association model is used to determine the keyword semantic vector of the submitted keyword, and the keyword semantic vector is matched with a task semantic vector library for similarity, and the associated task corresponding to the code submission request is determined based on the obtained matching result.

[0050] Among them, the submitted keywords can be understood as the key semantic words or phrases extracted from the submission information, which can be obtained through entity extraction using regular expressions; the keyword semantic vector can be understood as mapping the submitted keywords into vector representations in a high-dimensional space using a task association model, which is used to measure semantic similarity; the task semantic vector library can be understood as a set of semantic vectors storing target task identifiers and descriptions, supporting fast retrieval and matching.

[0051] Specifically, after the server receives a code submission request from the target client, it first preprocesses and extracts keywords from the submission information. For example, in the preprocessing stage, it identifies the language of the submission information, that is, detects the language of the submission information, and standardizes the submission information using the processing method corresponding to the language. For example, when the submission information is in Chinese, it uses Chinese language processing tools to analyze the submission information and filter out stop words (such as removing function words like "de" and "le"), and when the submission information is in English, it uses an English language processing toolkit to perform word form reduction (such as restoring "fixed" to "fix").

[0052] Based on the standardized processing, technical terms (such as "OAuth2", "K8s", etc.) can be captured through regular expressions to obtain the submitted keywords, and a task association model (such as pre-trained language models BERT, GPT, etc.) is used to convert the extracted submitted keywords into semantic vector representations of a unified dimension.

[0053] Calculate the similarity between the keyword semantic vector and those in the task semantic vector library to find the most matching associated task. Specifically, by semantically encoding the task descriptions of the tasks in the project association unit, a task semantic vector library is constructed, so that algorithms such as cosine similarity can be used to calculate the similarity between the keyword semantic vector and the task semantic vector, thus achieving fast matching.

[0054] For example, when the similarity between the keyword semantic vector and a certain task semantic vector in the task semantic vector library exceeds a set threshold (such as 0.85), precise matching is achieved, that is, the code submission request is automatically associated with the task corresponding to this task semantic vector, that is, the task corresponding to this task semantic vector is determined as the associated task; when the similarity is in the middle range (such as 0.6 - 0.85), a suggestion list is generated by obtaining a preset number of tasks for the user to confirm; and when the similarities between the keyword semantic vector and multiple task semantic vectors in the task semantic vector library are close (the similarity difference does not exceed 0.1), the associated graph analysis is further triggered to judge the primary and secondary relationships.

[0055] In practical applications, to improve the efficiency of task association, the modified file path in the code submission request (such as src / auth / directory modification) can be combined to implement context enhancement processing of the submission keywords, thereby narrowing the range of candidate tasks and performing the above-mentioned similarity matching processing within the range of candidate tasks.

[0056] That is, by similarity matching, matching results are obtained to determine the associated tasks that are most likely related to the code submission behavior, and complete the data binding between the task and the submission record.

[0057] The data processing method provided in the embodiments of this specification extracts and semantically encodes keywords in the submitted information, combines it with the task semantic vector library for similarity matching, and accurately identifies associated tasks related to the current submission behavior. Through automated association, it not only improves the automation level of task association, but also enhances the accuracy and continuity of task tracking, which helps to improve R&D efficiency and team collaboration quality.

[0058] In one or more embodiments of this specification, when there are multiple candidate tasks in the matching results, the dependency and priority relationship between the candidate tasks is determined through association graph analysis, thereby determining the primary and secondary relationships, and determining the primary task as the most relevant associated task. The specific implementation is as follows: Determining the associated task corresponding to the code submission request according to the obtained matching result includes: When the obtained matching results include at least two candidate tasks, triggering association graph analysis to determine the primary and secondary relationship between the at least two candidate tasks; The associated task corresponding to the code submission request is determined from the at least two candidate tasks according to the primary and secondary relationship.

[0059] Among them, candidate tasks can be understood as tasks that may be related to the code submission request, which are output after keyword extraction and semantic vector matching; the association graph can be understood as a knowledge graph that represents the relationship between tasks, including dependencies, parent-child, references and other structures between tasks; the primary and secondary relationship is used to determine which task is the primary task (that is, the task that is mainly affected by this code submission) and which are secondary tasks among multiple candidate tasks.

[0060] Specifically, if the matching results include at least two candidate tasks, a correlation graph analysis is triggered to determine the primary and secondary relationships between the at least two candidate tasks. For example, the correlation graph provides relationship data between tasks, including task dependencies (e.g., T1234 is a predecessor task of T5678), parent-child task structures (e.g., T9012 is a child task of T1234), and reference relationships (e.g., T5678 is referenced by multiple other tasks). Based on the structured relationship data provided by the correlation graph, the logical relationships between the candidate tasks are analyzed to determine which one is the primary target task for the submission.

[0061] According to the primary and secondary relationships, the primary task among at least two candidate tasks is used as the associated task for this code submission.

[0062] The data processing method provided in the embodiments of this specification can determine the primary and secondary relationships between them through association graph analysis when the system detects that a code submission may be associated with multiple target tasks, and select the most relevant main task as the final associated task for this submission, thereby improving the accuracy and intelligence of task matching, and enhancing the integrity and explainability of task tracking.

[0063] In one or more embodiments of this specification, in the task association model, there are two modes: rule matching and feature matching. That is, when a submitted keyword is obtained, the task identifier can be matched in the regular rule library based on the submitted keyword display, and the associated task can be determined based on the task identifier. The specific implementation is as follows: Extracting keywords from the submission information carried in the code submission request, and obtaining the submission keywords, further comprising: Based on the submission keyword, a corresponding task identifier is matched from a regular rule library, and the associated task corresponding to the code submission request is determined according to the task identifier.

[0064] Among them, the regular rule base can be understood as a set of preset structured text matching rules used to identify explicit identifiers such as task numbers.

[0065] Specifically, an extensible regular rule library is configured to identify whether the submitted keyword contains a clear task number (a task identifier) ​​or other task identification information. The submitted keyword is used as input and regular pattern matching is performed item by item.

[0066] During specific implementation, the regular rule library presets multiple task identification formats, including the #T\\d+ format (matching #T1234) and the #PROJ-\\d+ format (matching PROJ-456). It also supports custom extensions to adapt to the numbering and naming conventions of different organizations. After a successful match, the task identifier (such as T1234) is extracted, thereby determining that the task corresponding to the task identifier is an associated task.

[0067] For example, the submission information includes "Fix the login page jump failure problem (#T1234)", and the submission keywords obtained through keyword extraction include "login page", "jump failure", "fix", and "#T1234". When matching the submission keywords in the regular rule library, the task identifier T1234 is extracted, and the application program interface of the project management unit is called to determine the task corresponding to the task identifier in the project management unit as the associated task submitted this time.

[0068] In actual applications, when matching tasks based on submitted keywords, a dual-channel (rule channel and model channel) task identification architecture can be constructed. The rule channel is used to identify explicit task identifiers, and the model channel is used to identify implicit task associations (such as mapping "solving login timeout problems" to "authentication module optimization" tasks).

[0069] The data processing method provided in the embodiments of this specification performs structured analysis on keywords in the submission information. Combined with a preset regular rule library, the system can quickly identify explicit task identifiers and establish an accurate mapping relationship between code submissions and associated tasks.

[0070] Step 106: When the associated task is the target task, construct and test the target task.

[0071] Among them, building can be understood as the process of compiling and packaging source code into executable or deployable programs; testing and inspection not only includes various testing methods such as unit testing, integration testing, security scanning, etc. to verify the functional correctness and security of the built product, but also includes checking the pass status of the test.

[0072] Specifically, when the associated task is a target task, the target task is used to perform construction and testing to ensure that the target version of the program corresponding to the target task can be successfully released.

[0073] In actual applications, the target task can be divided into multiple subtasks, and each subtask is assigned to the corresponding target client. In this way, when the code submission request sent by the target client is associated with the target task, based on the target codes in the multiple code submission requests, the multiple target codes can be determined as the multiple associated codes corresponding to the target task; therefore, by constructing, testing and inspecting the multiple associated codes, the construction and testing of the target task are realized.

[0074] In fact, when the target task is assigned to the target client, the task status of the target task is updated to the processing status, and when the associated task is determined to be the target task, the task status of the target task is updated to the completed status, thereby triggering the continuous integration / continuous deployment (CI / CD) tool to build and test the target task.

[0075] In one or more embodiments of this specification, the target code in the code submission request is initially built and tested, and code test results are obtained to ensure the correctness of the target code in each code submission request. When the task status of the target task is updated to the completed state, the test pass status of the associated code corresponding to the target task is checked, and the target build process is triggered to facilitate the subsequent release of the target version program corresponding to the target task. The specific implementation method is as follows: In a case where the associated task is the target task, constructing and testing the target task includes: In a case where the associated task is the target task, performing initial construction and testing on the target code in the code submission request to obtain a code test result corresponding to the target code; When the task status of the target task is updated to a completed state, a code test result of the associated code corresponding to the target task is tested and a target construction process is performed on the target task.

[0076] Among them, the initial build can be understood as a build for the development and test environment, which is used to verify the availability of code changes; the target build can be understood as a build for production release, which must pass strict quality control and approval processes.

[0077] Code test results can be understood as the test report generated after the test execution is completed, including test pass rate, coverage, error information, etc.; test verification can be understood as the process of analyzing existing test results to determine whether they meet the release standards.

[0078] Specifically, during the development phase, developers submit code changes through code submission requests, and the code submission automatically triggers initial build, testing and other processes. The initial build is performed specifically for the target code in the code submission request, that is, compiling the source code, building intermediate products suitable for the test environment, and performing unit testing (verifying logical correctness), integration testing (ensuring that modules work together), security scanning (scanning for potential vulnerabilities) and other testing processes to obtain code test results corresponding to the target code.

[0079] Continuing with the above example, when the target codes corresponding to multiple subtasks of the target task are all submitted, the task status of the target task is updated to the completed status.

[0080] According to the state change event of the target task, the target construction process corresponding to the target task is started, and the code test results of the associated code corresponding to the target task are tested and verified.

[0081] Specifically, the code test results of the code submitted related to the target task (i.e., the code test results of the associated code) are collected, and the code test results are summarized and analyzed, such as checking whether there are any failed test items, whether the coverage meets the requirements, and whether there are any security vulnerabilities or performance issues; if the test passes, the target build process is triggered, and after the target build is completed, the artifacts that can be used for release (such as Docker images, RPM packages, executable files) are output.

[0082] The data processing method provided in the embodiment of this specification is that when the task associated with the code submission matches the target task, the system automatically executes the initial construction and testing process; and when the target task status is updated to "completed status", the test result verification and target construction process are further executed to ensure that the construction product meets the release conditions.

[0083] In one or more embodiments of this specification, before releasing the target version of the target task, the code test results are checked. Specifically, a data analysis model can be used to analyze the code test results, such as the test pass rate and security scan results, and output a risk score and modification suggestions. After the quality standards are met, the target task is determined to have passed the inspection. The specific implementation method is as follows: Testing and verifying the code test results of the associated code corresponding to the target task, including: Analyze the code test results using a data analysis model to generate test scores and modification suggestions; If the associated code is repaired according to the modification suggestion and it is determined that the test score is greater than a preset threshold, it is determined that the inspection is passed.

[0084] Among them, the data analysis model is used to evaluate the quality of code test results; the test score can be understood as a quality score generated by integrating various indicators (such as test coverage, defect repair rate, and test stability); modification suggestions can be understood as the optimization direction given by the data analysis model based on the test results, such as supplementing test cases, repairing uncovered paths, etc.

[0085] Specifically, when the task status of the target task is updated to the completed state, a comprehensive evaluation is performed on the code test results of the code associated with the target task, a quantitative test score is output, and improvement suggestions are provided.

[0086] After the developer fixes and resubmits the associated code based on the modification suggestions provided by the data analysis model, the system runs the test and evaluation process again. If the updated test score exceeds the preset threshold (used for quality assessment), the system determines that the test process of this task has "passed the inspection."

[0087] Specifically, developers review the modification suggestions prompted by the system and make targeted repairs, submit the repaired code, and trigger a new round of testing process. If it is still below the preset threshold, suggestions will continue to be returned until the quality standards are met.

[0088] In fact, when the task status of the target task is updated to completed, the system checks the completeness of the submission record (associated with the target task) and the test pass status. The test pass status includes checking the defect repair status associated with the target task. For example, if there are 100 defects and the repair rate is less than 95, it can be judged as passed. If only 50 defects are repaired, it can be judged that most defects have not been repaired and the test fails.

[0089] The data processing method provided in the embodiments of this specification generates test scores and modification suggestions by performing multi-dimensional analysis on the code test results. The modification suggestions help the development team quickly address key issues and avoid delayed releases. The quality score is re-evaluated after the developer completes the repair. Only when the test score reaches the preset threshold is it determined to be "passed" to ensure that only verified code can enter the production environment, and it can eliminate human errors such as forgetting to trigger the build or skipping the testing phase.

[0090] In one or more embodiments of this specification, the operating status of the data processing system is monitored in real time, alarm thresholds are set to respond to emergencies such as build failures and sudden drops in test pass rates, and relevant personnel are notified through alarm notifications. Specific implementation methods are as follows: After building and testing the target tasks, it also includes: In the event of a build failure, determining the number of build failures, and triggering an alarm notification when the number of build failures reaches a preset alarm threshold; When the target task is tested and it is determined based on the test result that the test pass rate has decreased, the alarm notification is triggered.

[0091] Among them, build failure can be understood as the failure of the build process to be successfully completed after a code submission, such as compilation errors, missing dependencies, etc.; the number of build failures can be understood as the number of consecutive or cumulative build failure events; the preset alarm threshold can be understood as the upper limit of the number of failures set by the system to trigger an alarm, such as 3 consecutive failures; the alarm notification can be understood as the notification information automatically sent by the system when abnormal behavior is detected, which is used to remind relevant personnel to intervene.

[0092] Specifically, the results of each code build are monitored. If a build fails, the number of failures is recorded, and an alarm notification is automatically issued when the number of failures exceeds the set threshold. The target task can be tested during the testing phase, and the test results can be used to identify whether there is a significant drop in the test pass rate, and trigger an alarm notification accordingly.

[0093] The data processing method provided in the embodiments of this specification can automatically identify potential quality risks by comparing the statistics of the number of build failures with the historical test pass rate, and trigger an alarm notification when the set threshold is reached, reminding relevant personnel to intervene in time; this method not only improves the automated monitoring capabilities of the R&D process, but also enhances the maintainability of the data processing system.

[0094] Step 108: If the verification passes, the target version program corresponding to the target task is released, and a version report corresponding to the target version program is generated and sent to the associated client.

[0095] Among them, the target version program can be understood as the final executable program or product built according to the target task that can be used for deployment and release; the version report can be understood as a comprehensive document containing version information, build details, test results, defect repair status, etc.; the associated client can be understood as the relevant personnel or system terminal that receives the version report, including but not limited to the project manager's corresponding client, operation and maintenance platform, etc.

[0096] Specifically, after confirming that the target task has passed all testing processes and met the preset quality standards, the release process of the official version will be automatically triggered.

[0097] In the above case of target build processing for the target task, the build product is the target version program, which can be an executable program, container image, installation package, etc. The target version program can be published to the generation environment, and a version report corresponding to the target version program can be generated and sent to the associated client; the automated process reduces manual operations and ensures rapid iteration of code from writing to release.

[0098] It should be noted that in the process from creating the target task to releasing the target version of the program, if the task status changes, the task status can be synchronized in conjunction with the project management unit, making it convenient for the associated client to view the task status of the target task through the task panel in the project management unit; and real-time data collection can be performed throughout the process, such as real-time collection of core indicators such as task completion rate and code submission frequency, and reports can be generated through data visualization tools to assist management in making strategic decisions. Management can quickly grasp project progress and risk points through visual dashboards.

[0099] In one or more embodiments of this specification, by scanning code base differences, parsing submission information, and combining test reports and other data, the change type is automatically determined and the corresponding version number and release notes are generated. The specific implementation is as follows: Generating and sending a version report corresponding to the target version program to the associated client, including: Analyze the associated codes corresponding to the target task from multiple change dimensions, determine the change result, and determine the change version type based on the change result; Determine the content template corresponding to the changed version type, instantiate the content target according to the changed result and generate version release notes, or Constructing a change feature vector based on the change result, the submission information, and the code test report, and processing the change feature vector using a change description model to generate the version release description; A target version number is generated according to the changed version type, a version report corresponding to the target version is generated according to the version number and the version release description, and the version report is sent to the associated client.

[0100] Change dimensions include, but are not limited to, changes to application programming interfaces (APIs), additions of new functional modules, security patches, and dependency updates. Change results correspond to the technical impact of a code change, such as whether a breaking change is introduced, whether a backwards-compatible functional module is added, or whether it only contains bug fixes or documentation improvements. Change version types can be understood as version types determined according to semantic versioning rules, including MAJOR (major version number), MINOR (minor version number), and PATCH (patch version number).

[0101] The content template can be understood as a preset version release notes format template, which is used to structure the output of version update content. The version release notes can be understood as natural language text describing the content of this version update, including new features, fixes, precautions, etc., without limitation here.

[0102] The change feature vector can be understood as a structured data representation constructed by integrating information such as code changes, submission information, and test reports. The change description model can be understood as a generative language model used to generate high-quality release notes. The version number can be understood as a version identifier that follows the semantic version naming rules, such as v2.3.0.

[0103] Conduct a comprehensive change analysis of the associated code involved in the target task to identify its impact on system functions, interfaces, architecture, and other aspects, and use this information to determine the appropriate version upgrade strategy. Change analysis includes, but is not limited to, API (Application Programming Interface) compatibility changes (deletion / renaming of public interfaces), the introduction of new functional modules (addition of independently runnable functional components), and the application of security patches (fixes for known vulnerabilities or permission issues). Based on the change analysis, obtain the change results and determine the version type based on the decision logic.

[0104] For example, when change analysis determines that the code change is used to delete a published API interface, the change result is determined to be a destructive change, thereby triggering a MAJOR version upgrade, that is, the version type is changed to MAJOR; when change analysis determines that the code change is used to introduce a new module or support a new protocol, the change result is determined to be a new functional module, thereby triggering a MINOR version upgrade, that is, the version type is changed to MINOR; when change analysis determines that the code change is used to fix a defect or add document comments, the change result is determined to be a defect fix or document improvement, thereby triggering a PATCH version upgrade, that is, the version type is changed to PATCH; when the code change result does not match the version type (such as when there is an API change but the MAJOR version is not upgraded), the manual review process is triggered.

[0105] Depending on the version type, the system can choose different ways to generate release notes. For example, for routine changes, predefined templates can be used to fill in the information; for complex changes, the change note model can be used to generate more readable and technically accurate notes.

[0106] During specific implementation, determine the predefined content template in Markdown or JSON format corresponding to the change version type, extract the entries in the change results to fill the template fields in the content template, that is, fill in the specific change entries through the placeholders, instantiate the content template, and generate the version release notes.

[0107] For major changes involving technical complexity (such as architectural refactoring), a large language model (i.e., the change description model) is used to generate natural language descriptions, with keyword constraints ensuring technical accuracy. Specifically, a multi-dimensional change feature vector is constructed from the resulting architectural change records, semantic keywords (such as "feat" and "fix") in the commit message, and code test reports. This change feature vector is then input into the change description model to generate a natural language description, i.e., the release notes.

[0108] It should be noted that bilingual release notes (both Chinese and English) can be automatically generated based on the target readership of the release log. The integrity of the release notes is ensured by a quality verification mechanism. A specific deployment rule checker verifies the integrity of the release notes, for example, that breaking changes must include a migration guide, security updates must be annotated with a CVE number, and new features must be linked to the requirements document.

[0109] After determining the change version type and version release notes, the system automatically generates a complete version report with the version number and pushes it to the associated clients.

[0110] In actual applications, the target version number is generated according to the semantic versioning rules. For example, when the version change type is MAJOR, the target version number generated is v2.0.0 (the previous version number is v1.xx), when the version change type is MINOR, the target version number generated is v1.2.0 (the previous version number is v1.1.x), and when the version change type is PATCH, the target version number generated is v1.1.1 (the previous version number is v1.1.0).

[0111] Generates a version report based on the generated target version number and version release notes. The report content includes but is not limited to the version number and release time, submission record summary, defect repair statistics, test result summary, version release notes, etc.; and the version report can be exported in multiple formats: Markdown / HTML (for easy reading), PDF (for easy archiving), and JSON (for easy system integration).

[0112] The data processing method provided in the embodiments of this specification identifies the change type and generates the corresponding version number by performing a comprehensive multi-dimensional scan of the code changes of the target task; based on different types of version updates, a predefined content template can be selected or a model can be called to generate version release notes, and finally a complete version report can be generated and pushed to the associated client.

[0113] In one or more embodiments of this specification, version planning management can be used to predict the future version release rhythm based on historical project progress data, that is, to generate the time point for the next version task. The specific implementation is as follows: After generating and sending a version report corresponding to the target version to the associated client, the method further includes: Based on the task data of the target task, a time series model is used to predict the generation time point of the next version task corresponding to the target task.

[0114] Task data includes but is not limited to structured data such as task creation time, completion time, priority, story points, and developer assignments. A time series model can be understood as a mathematical model trained on historical time series data to predict the occurrence of future events.

[0115] The next version task can be understood as the pending task that follows the current target task and is expected to be included in the next version. The generation time point can be understood as the specific time point when the next version task is predicted to begin planning or enter the development phase.

[0116] Specifically, in the case of releasing the target version of the program, the task data of the target task is the historical data for predicting future versions. The task data of the target task is collected, and the task data includes the completion time of the target task, the number of subtasks and the development cycle, etc., as well as the average productivity of the development team and potential influencing factors (such as holidays and personnel changes).

[0117] By inputting task data into a pre-trained time series prediction model and outputting the estimated generation time node of the next version of the task, version planning can be achieved.

[0118] In actual applications, traditional version release times mostly rely on manual experience or fixed cycle arrangements, which makes it difficult to dynamically adapt to the ever-changing R&D rhythm and task progress. It is necessary to build a unified time series model to predict the generation time point of the next version task, thereby achieving more scientific and accurate version scheduling decisions.

[0119] In one or more embodiments of this specification, by integrating multiple sources of information such as historical task completion data, historical version metadata, and defect repair cycles, the generation time point of the next version task can be reasonably predicted. The specific implementation method is as follows: Based on the task data of the target task, using a time series model to predict the generation time point of the next version task corresponding to the target task includes: Constructing task time series data corresponding to the target task based on the task completion time series, historical version data, and defect repair cycle data of the target task; The time series model is used to extract features from the task time series data to obtain basic time series features and high-order derivative features, and the generation time point of the next version task corresponding to the target task is predicted based on the basic time series features and the high-order derivative features.

[0120] Among them, the task completion time series can be understood as the sequence of target task completion moments arranged in chronological order; the historical version data includes metadata such as the release time of each version, the set of tasks included, and the scope of changes; the defect repair cycle data is used to describe the statistical information of the time taken from defect discovery to repair completion; the task timing data can be understood as the structured time series input constructed by combining the above three types of data for use in model analysis.

[0121] Basic time series features can be understood as basic statistical indicators directly extracted from the original task time series data; high-order derivative features can be understood as complex statistics or pattern recognition results further constructed based on basic time series features.

[0122] Specifically, multi-dimensional data related to the target task is collected from multiple task processing units and integrated into task time series data that can be used for time series modeling. Task completion time series comes from task management units (such as Jira), recording each task's creation time, status change time, and completion time. Historical version data comes from version control units (such as Git), recording each version release time, version number, list of included task identifiers, and code change statistics. Defect repair cycle data comes from quality management units (such as SonarQube), recording the time interval between defect discovery and repair.

[0123] Use a time series model to model and analyze task timing data, extract basic timing features and high-order derivative features, and predict the generation time node of the next version of the task based on these features.

[0124] In specific implementation, the basic time series features extracted include but are not limited to the number of days between version releases, the average weekly task throughput (in story points), the average defect repair time, etc.; high-order derivative features include trend decomposition, which uses the STL (Seasonal and Trend decomposition using Loess) algorithm to separate the trend items of the R&D rhythm from seasonal fluctuations (such as the quarterly sprint model), event marking, which marks the time nodes of key events (such as team structure adjustments and major technology upgrades), and lag variables, which construct the average release interval of the first three versions as a sliding window statistic.

[0125] The choice of time series model can be made on demand based on the usage scenario. For example, the time series model can be a Prophet model, which is suitable for R&D rhythms with obvious periodicity (such as monthly / quarterly sprints); the time series model can be a DeepAR probabilistic model, which is suitable for scenarios that require quantified uncertainty (such as outputting a release date range with an 80% confidence interval). In practical applications, the Stacking strategy (the "Stacking strategy" is an integrated learning method that improves prediction performance by combining multiple models. Its core idea is to input the outputs of multiple basic models as new features into a meta-learner, and finally the meta-learner outputs the prediction results) can be used through the integrated prediction layer to fuse the output results of multiple models, and use the ridge regression model to assign the corresponding prediction weights to each model to improve the overall prediction accuracy.

[0126] The data processing method provided in the embodiments of this specification integrates the completion time of the target task, historical version data and defect repair cycle to construct unified task timing data, and uses the time series model to extract basic and high-order features to predict the generation time node of the next version task; this method not only improves the intelligence and automation level of version planning, but also enhances the controllability and predictability of the R&D process.

[0127] The data processing method provided in the embodiments of this specification realizes closed-loop management of the entire process from task allocation, code submission, automated build testing to version release by intelligently identifying the relationship between code submission and target tasks. It not only improves the standardization and traceability of version release, but also enhances the information transparency and delivery controllability of cross-team collaboration; it optimizes the automation level, quality assurance capability and collaborative efficiency of the software development process, and helps to achieve efficient and reliable version management.

[0128] See also Figure 2 , Figure 2 A processing flow chart of a data processing method provided in an embodiment of the present application is shown, which specifically includes the following steps: Step 202: System initialization configuration.

[0129] Specifically, the system requires a series of basic configurations to ensure the normal operation of subsequent functions. First, it integrates project management tools (i.e., the task management unit in the above embodiment, such as Jira and GEP), version control systems (i.e., the version control unit in the above embodiment, such as GitHub and GitLab), and CI / CD tools (i.e., the build and test unit, such as Jenkins and DevOps).

[0130] Integration tools can be implemented using Git hooks, which trigger automated processes such as automatic builds and tests after code commits. For large-scale systems, tools can be used to handle asynchronous message queues. For small and medium-sized projects, synchronous processing can be simplified by directly calling APIs, avoiding complex configuration.

[0131] For project management tools, create an application-linked identity to obtain an API access token and set the necessary permissions. For version control systems, use OAuth (Open Authorization) tokens or deploy keys for secure and efficient read and write operations. Furthermore, configure a webhook to link code commits with the build process. This step lays a solid foundation for efficient system operation.

[0132] In practice, the project management system also needs to be connected to the AI ​​system to monitor and update task status in real time. Whenever a task status changes, a webhook immediately notifies the AI ​​system of these changes. For example, if a task is marked as completed, the system checks whether the associated submission has passed all testing stages and updates the corresponding task dashboard.

[0133] Save time and reduce errors by automatically updating task status without manual intervention.

[0134] Step 204: Task creation and assignment.

[0135] Use predefined task creation forms to standardize the work item entry process. Task creators fill in priority, type, and other information in the task creation template in the project management system, and use artificial intelligence analysis to estimate the development cycle to create formal target tasks.

[0136] The system collects developer information and intelligently recommends the most suitable developer for the target task based on their historical performance, skill tags, and current task requirements. Specifically, it uses clustering algorithms to identify developers' areas of expertise; applies classification models to predict the time and difficulty of tasks; and assigns tasks to appropriate developers based on resource load balancing, while also supporting manual adjustments. This step not only improves the scientific nature of task allocation but also promotes the efficient use of team resources.

[0137] Step 206: Associate the task and the submission ticket.

[0138] When the target task is assigned to a developer, the developer can view the task details (associated file list, related documents and historical comments) through the IDE (Integrated Development Environment) or web interface, and use branch management tools such as GitHub Pull Request to ensure the security of collaborative code. Developers can also edit task descriptions, add comments and view submission status in real time.

[0139] When a code submission request is received from a target client, the system uses natural language processing technology to analyze keywords in the submission information, automatically matching and associating the corresponding task identifiers. This process includes extracting keywords from the submission information, matching based on keywords, and updating the task panel in the project management system. Specifically, a pre-trained BERT or GPT model can be used to extract key context from the submission information. By analyzing keywords, phrases, and sentiment, the system can identify related tasks (e.g., "Fix login errors" is automatically associated with the T1234 task). When associated with a specific task, details such as the submission link and the list of changed files can be added to the task panel in the project management system.

[0140] In fact, when using the task association model to match code submission requests to corresponding associated tasks, the accuracy of the associated tasks is guaranteed through an adaptive optimization mechanism. Specifically, the developers' correction operations on the automatic association results are collected, and the task association model is continuously optimized through incremental training. That is, the differences in task associations before and after manual corrections are recorded, and comparative learning sample pairs are constructed (positive examples: manually confirmed associations, negative examples: system-mistaken associations). The model is fine-tuned and updated once a quarter, and the terminology library can be dynamically maintained. That is, new technical terms (such as "zero trust") are extracted from code review records, added to the domain dictionary after confirmation through the manual review process, and the named entity recognition rules are updated.

[0141] In practice, a degraded disaster recovery plan is implemented. This involves intelligently linking code submissions to corresponding tasks in primary mode based on semantic understanding. If the AI ​​service becomes unavailable, backup mode is activated, automatically switching to regular expression matching for basic task numbers. Mandatory manual review is implemented for high-risk scenarios, such as linking to historical tasks closed for more than 30 days, linking cross-project tasks (such as linking front-end submissions to back-end tasks), and linking the same task more than five times per day.

[0142] When it is determined that the code submission request corresponds to the associated task, the code review link can be automatically attached to the "Development Record" tab of the corresponding associated task in the project management system. When the submission information contains fix #PROJ-123, the task status of the corresponding associated task will be automatically advanced to "Testing to be verified". When the code is merged into the main branch, the subtask will be automatically closed and a version traceability link will be generated.

[0143] This mechanism greatly simplifies the association operations between tasks and submissions, and enhances the traceability and auditability of information.

[0144] Step 208: Automated testing and triggered build.

[0145] Once the associated task is confirmed as a target, the system automatically initiates the build and test process for that task. CI / CD tools are used to perform multiple phases of verification, including unit testing, integration testing, and security scanning. Specifically, hook functions are set up to automate each code commit, invoking the CI / CD tool to initiate the test and build process. This automated approach reduces the need for human intervention.

[0146] Step 210: Pre-release check.

[0147] Before final release, the system automatically executes a comprehensive quality assurance process, including but not limited to unit testing, integration testing, and security scanning. An AI system conducts in-depth analysis of test results, outputs risk scores, and provides improvement recommendations. Only after meeting stringent quality standards and passing comprehensive inspections is the code approved for final release. Multi-dimensional testing ensures that code quality meets launch standards. Systematic security scanning reduces the risk of potential vulnerabilities going unnoticed, thereby enhancing security. AI-generated improvement suggestions help the development team quickly address critical issues and avoid release delays.

[0148] AI-driven pre-release checks analyze data such as test pass rates, security scan results, and historical release failures. By analyzing the results of each test, they predict key pre-release risks and generate remediation recommendations, prioritizing improvements. This approach ensures release stability and security, reducing post-launch failure rates.

[0149] Step 212: Release process.

[0150] When the task status of the target task is marked as "Completed", the system checks the completeness of the submission record (associated with the task number) and the test pass status. After all tasks are completed and pass the test, the release process is triggered by default. By clicking a button, the CI / CD tool is called to perform the final build and a version report containing version information is generated and sent to relevant personnel.

[0151] Step 214: Intelligent version planning.

[0152] Based on historical data (such as completion rates and release times), a time series model is used to predict the cadence of future releases. This avoids the uncertainty associated with arbitrarily setting release schedules, and the historical data-driven forecasting model improves the accuracy of release schedules.

[0153] To ensure the reliability of the time series model, time series anomalies are detected. Specifically, a dynamic threshold alarm system is deployed to trigger an alert when the actual release dates of three consecutive versions exceed the predicted range and / or the weekly average task throughput fluctuation exceeds 2 standard deviations of the historical mean. The time series model is also retrained regularly, for example, by updating model parameters with the latest data every month, or by event-driven training of the time series model. For example, when an organizational structure adjustment or technology stack upgrade is detected, model retraining is immediately triggered.

[0154] Furthermore, the program automatically generates version numbers and update notes for the target version, reducing human error and saving time. Specifically, the change analysis module identifies changes in key dimensions (such as API compatibility and the introduction of new functional modules) and determines the version upgrade type (MAJOR, MINOR, or PATCH). High-quality release notes are generated using a template engine or large language model and pushed to relevant clients. This step enables intelligent version management, improving the efficiency and transparency of version releases.

[0155] The data processing system that applies this data processing method supports data-driven decision-making. Specifically, by collecting key R&D indicators such as task completion rate and code submission frequency in real time, a comprehensive data analysis system is established to support scientific decision-making in project management. The system automatically calculates task completion rate and daily / weekly code submission frequency, and automatically generates data reports containing charts based on test pass rate, failure cases, build time of each version, and release success rate. For example, data visualization tools are used to generate visual dashboards and automatically generate PDF or PPT reports containing chart trends for management to review and use, thereby supporting project reporting and strategy adjustments. Management can quickly grasp project progress and risk points through visual dashboards and formulate scientific resource allocation and release plans based on historical data analysis results. Regularly generated historical analysis reports provide a basis for the team to optimize the development process.

[0156] The data processing system has enhanced security and privacy protection, and has implemented strict security control measures at multiple levels to ensure the safe operation of the system and data compliance. API keys are securely stored to prevent the leakage of sensitive information, and security protocols such as OAuth2.0 are used to manage API keys. Strict permission management is used to prevent unauthorized access and ensure that only authorized users can operate relevant functional modules. Sensitive fields such as user passwords and task descriptions are encrypted before and after storage to prevent data from being illegally read or tampered with. In addition, the system regularly performs security audits and database backups to prevent accidental data loss and ensure data integrity and recoverability. Strict access control and encryption measures protect the system from external threats, and audit logs help track abnormal events and the source of operations.

[0157] The data processing system is capable of monitoring and alarming. The system integrates a variety of monitoring tools to track system performance indicators in real time, such as key indicators such as build status, test results, service performance (such as CPU usage, response time), and set intelligent alarm rules. For example, continuous build failures, a significant drop in test pass rate, and other situations trigger the notification mechanism. Once an anomaly is detected, the system will promptly send a notification containing a detailed description of the problem to the relevant personnel via email, SMS, or collaborative message to ensure that the problem is discovered and resolved at an early stage, effectively reducing system risks and improving overall stability and availability. This proactive monitoring and alarm mechanism can promptly detect and resolve system anomalies, reduce downtime, help maintain high system availability, deal with potential risks before problems escalate, ensure that project progress is not disrupted, and help to continuously ensure the efficient operation of the R&D process and the controllability of product quality.

[0158] This application also provides a data processing system embodiment, Figure 3 FIG. 1 shows a schematic diagram of a data processing system provided by an embodiment of the present application. Figure 3 As shown, the system includes: The task management unit 302 is used to determine a target task and assign the target task to a target client; The version control unit 304 is configured to respond to the code submission request sent by the target client, process the submission information carried in the code submission request using the task association model, and determine the associated task corresponding to the code submission request; A construction and testing unit 306 is configured to construct and test the target task if the associated task is the target task; The task management unit 302 is further configured to, if the verification is passed, publish the target version program corresponding to the target task, and generate and send a version report corresponding to the target version program to an associated client.

[0159] By integrating task management, version control, and build and test units, and incorporating natural language processing and machine learning technologies, the system automates task flow and intelligently links code submissions. Once all tasks are completed, AI automatically triggers the build and release process.

[0160] Corresponding to the above method embodiment, the present application also provides a data processing device embodiment, Figure 4 FIG. 1 shows a schematic diagram of the structure of a data processing device provided by an embodiment of the present application. Figure 4 As shown, the device includes: The task assignment module 402 is configured to determine a target task and assign the target task to a target client; The task association module 404 is configured to respond to the code submission request sent by the target client, process the submission information carried in the code submission request using the task association model, and determine the associated task corresponding to the code submission request; A task verification module 406 is configured to construct and test the target task if the associated task is the target task; The version publishing module 408 is configured to publish the target version program corresponding to the target task if the verification is passed, and generate and send a version report corresponding to the target version program to the associated client.

[0161] The device further comprises: The status change module is configured to determine that the task status of the target task is a pending status before allocating the target task to the target client; after allocating the target task to the target client, update the task status of the target task to a processing status, and when the associated task is the target task, update the task status of the target task to a completed status.

[0162] Optionally, the task assignment module 402 is further configured to: In response to a task creation request, processing initial task information in the task creation request to determine target task information corresponding to the task creation request; The target task is created according to the target task information, and the target task information and user information are analyzed using a task allocation model to determine the target user corresponding to the target task, and the target task is allocated to the target client corresponding to the target user.

[0163] Optionally, the task association module 404 is further configured to: Extract keywords from the submission information carried in the code submission request to obtain submission keywords; The task association model is used to determine the keyword semantic vector of the submitted keyword, and the keyword semantic vector is matched with a task semantic vector library for similarity, and the associated task corresponding to the code submission request is determined based on the obtained matching result.

[0164] Optionally, the task association module 404 is further configured to: When the obtained matching results include at least two candidate tasks, triggering association graph analysis to determine the primary and secondary relationship between the at least two candidate tasks; The associated task corresponding to the code submission request is determined from the at least two candidate tasks according to the primary and secondary relationship.

[0165] Optionally, the task association module 404 is further configured to: Based on the submission keyword, a corresponding task identifier is matched from a regular rule library, and the associated task corresponding to the code submission request is determined according to the task identifier.

[0166] Optionally, the task association module 404 is further configured to: Determine the historical submission record corresponding to the target client, perform submission frequency statistics on the submitted tasks within the target time period in the historical submission record, and determine the associated task from the submitted tasks based on the statistical result.

[0167] Optionally, the task verification module 406 is further configured to: In a case where the associated task is the target task, performing initial construction and testing on the target code in the code submission request to obtain a code test result corresponding to the target code; When the task status of the target task is updated to a completed state, a code test result of the associated code corresponding to the target task is tested and a target construction process is performed on the target task.

[0168] Optionally, the task verification module 406 is further configured to: Analyze the code test results using a data analysis model to generate test scores and modification suggestions; If the associated code is repaired according to the modification suggestion and it is determined that the test score is greater than a preset threshold, it is determined that the inspection is passed.

[0169] Optionally, the version publishing module 408 is further configured to: Analyze the associated codes corresponding to the target task from multiple change dimensions, determine the change result, and determine the change version type based on the change result; Determine the content template corresponding to the changed version type, instantiate the content target according to the changed result and generate version release notes, or Constructing a change feature vector based on the change result, the submission information, and the code test report, and processing the change feature vector using a change description model to generate the version release description; A target version number is generated according to the changed version type, a version report corresponding to the target version program is generated according to the version number and the version release description, and the version report is sent to the associated client.

[0170] The device further comprises: The prediction module is configured to predict the generation time point of the next version task corresponding to the target task based on the task data of the target task using a time series model.

[0171] Optionally, the prediction module is further configured to: Constructing task time series data corresponding to the target task based on the task completion time series, historical version data, and defect repair cycle data of the target task; The time series model is used to extract features from the task time series data to obtain basic time series features and high-order derivative features, and the generation time point of the next version task corresponding to the target task is predicted based on the basic time series features and the high-order derivative features.

[0172] The device further comprises: an alarm module configured to, in the event of a build failure, determine a number of build failures, and trigger an alarm notification when the number of build failures reaches a preset alarm threshold; When the target task is tested and it is determined based on the test result that the test pass rate has decreased, the alarm notification is triggered.

[0173] The above is a schematic scheme of a data processing device of this embodiment. It should be noted that the technical solution of the data processing device and the technical solution of the above-mentioned data processing method belong to the same concept. For details not described in detail in the technical solution of the data processing device, please refer to the description of the technical solution of the above-mentioned data processing method. In addition, the various components in the device embodiment should be understood as functional modules that must be established to implement each step of the program flow or each step of the method. Each functional module is not an actual functional division or separation definition. The device claim defined by such a group of functional modules should be understood as a functional module architecture that mainly implements the solution through the computer program recorded in the specification, and should not be understood as a physical device that mainly implements the solution through hardware.

[0174] Figure 5 The block diagram shows a structure of a computing device 500 according to an embodiment of the present application. The components of the computing device 500 include, but are not limited to, a memory 510 and a processor 520. The processor 520 is connected to the memory 510 via a bus 530, and a database 550 is used to store data.

[0175] Computing device 500 also includes an access device 540 that enables computing device 500 to communicate via one or more networks 560. Examples of such networks include a PSTN (Public Switched Telephone Network), a LAN (Local Area Network), a WAN (Wide Area Network), a PAN (Personal Area Network), or a combination of communication networks such as the Internet. Access device 540 may include one or more of any type of network interface (e.g., a NIC (Network Interface Controller)) whether wired or wireless, such as an IEEE 802.11 WLAN (Wireless Local Area Network) wireless interface, a Wi-MAX (Worldwide Interoperability for Microwave Access) interface, an Ethernet interface, a USB (Universal Serial Bus) interface, a cellular network interface, a Bluetooth interface, or NFC (Near Field Communication).

[0176] In one embodiment of the present application, the above components of the computing device 500 and Figure 5 Other components not shown in the figure may also be connected to each other, for example, via a bus. Figure 5 The computing device structure block diagram shown is for illustrative purposes only and is not intended to limit the scope of the present application. Those skilled in the art may add or replace other components as needed.

[0177] Computing device 500 can be any type of stationary or mobile computing device, including a mobile computer or mobile computing device (e.g., a tablet computer, personal digital assistant, laptop computer, notebook computer, netbook computer, etc.), a mobile phone (e.g., a smartphone), a wearable computing device (e.g., a smartwatch, smart glasses, etc.), or other types of mobile devices, or a stationary computing device such as a desktop computer or a PC (Personal Computer). Computing device 500 can also be a mobile or stationary server.

[0178] The processor 520 is configured to execute computer executable instructions of the data processing method.

[0179] The above is a schematic scheme of a computing device of this embodiment. It should be noted that the technical scheme of the computing device and the technical scheme of the above-mentioned data processing method are based on the same concept. For details not described in detail in the technical scheme of the computing device, please refer to the description of the technical scheme of the above-mentioned data processing method.

[0180] An embodiment of the present application further provides a computer-readable storage medium storing a computer program / instruction, which is used for a data processing method when executed by a processor.

[0181] The above is a schematic scheme of a computer-readable storage medium of this embodiment. It should be noted that the technical scheme of the storage medium and the technical scheme of the above-mentioned data processing method are based on the same concept. For details not described in detail in the technical scheme of the storage medium, please refer to the description of the technical scheme of the above-mentioned data processing method.

[0182] An embodiment of the present application further provides a computer program product, including a computer program / instruction, which is used for a data processing method when executed by a processor.

[0183] The above is a schematic solution of a computer program product of this embodiment. It should be noted that the technical solution of this computer program product and the technical solution of the above-mentioned data processing method are based on the same concept. For details not described in detail in the technical solution of the computer program product, please refer to the description of the technical solution of the above-mentioned data processing method.

[0184] The computer program / instructions include computer program code, which may be in source code form, object code form, executable file, or some intermediate form. The computer-readable medium may include any entity or device capable of carrying the computer program code, recording medium, USB flash drive, mobile hard drive, magnetic disk, optical disk, computer memory, ROM (Read-Only Memory), RAM (Random Access Memory), electric carrier signals, telecommunication signals, and software distribution media. It should be noted that the content of the computer-readable medium may be appropriately increased or decreased based on the requirements of legislation and patent practice within a jurisdiction. For example, in some jurisdictions, based on legislation and patent practice, computer-readable media does not include electric carrier signals and telecommunication signals.

[0185] It should be noted that for the aforementioned method embodiments, for ease of description, they are all expressed as a series of action combinations, but those skilled in the art should be aware that this application is not limited by the order of the actions described, because according to this application, certain steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in this specification are all preferred embodiments, and the actions and modules involved are not necessarily required by this application.

[0186] In the above embodiments, the description of each embodiment has its own focus. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0187] The preferred embodiments of the present application disclosed above are intended only to help illustrate the present application. The optional embodiments do not describe all details in detail, nor do they limit the invention to the specific embodiments described. Obviously, many modifications and variations can be made based on the content of this application. This application selects and describes these embodiments in detail in order to better explain the principles and practical applications of this application, so that those skilled in the art can better understand and utilize this application. This application is limited only by the claims and their full scope and equivalents.

Claims

1. A data processing method, characterized in that: include: Determine a target task, and assign the target task to a target client; In response to a code submission request sent by the target client, the task association model is used to process submission information carried in the code submission request to determine an associated task corresponding to the code submission request; In a case where the associated task is the target task, constructing and testing the target task; If the verification is passed, the target version program corresponding to the target task is released, and a version report corresponding to the target version program is generated and sent to the associated client.

2. The method according to claim 1, wherein Before allocating the target task to the target client, the method further includes: Determine that the task status of the target task is a pending assignment status; After allocating the target task to the target client, the method further includes: The task status of the target task is updated to a processing status, and if the associated task is the target task, the task status of the target task is updated to a completed status.

3. The method according to claim 1, wherein Determining a target task and assigning the target task to a target client includes: In response to a task creation request, processing initial task information in the task creation request to determine target task information corresponding to the task creation request; The target task is created according to the target task information, and the target task information and user information are analyzed using a task allocation model to determine the target user corresponding to the target task, and the target task is allocated to the target client corresponding to the target user.

4. The method according to claim 1, wherein The task association model is used to process the submission information carried in the code submission request to determine the associated task corresponding to the code submission request, including: Extract keywords from the submission information carried in the code submission request to obtain submission keywords; The task association model is used to determine the keyword semantic vector of the submitted keyword, and the keyword semantic vector is matched with a task semantic vector library for similarity, and the associated task corresponding to the code submission request is determined based on the obtained matching result.

5. The method according to claim 4, wherein Determining the associated task corresponding to the code submission request according to the obtained matching result includes: When the obtained matching results include at least two candidate tasks, triggering association graph analysis to determine the primary and secondary relationship between the at least two candidate tasks; The associated task corresponding to the code submission request is determined from the at least two candidate tasks according to the primary and secondary relationship.

6. The method according to claim 4, wherein Extracting keywords from the submission information carried in the code submission request, and obtaining the submission keywords, further comprising: Based on the submission keyword, a corresponding task identifier is matched from a regular rule library, and the associated task corresponding to the code submission request is determined according to the task identifier.

7. The method according to claim 1, wherein After responding to the code submission request sent by the target client, the method further includes: Determine the historical submission record corresponding to the target client, perform submission frequency statistics on the submitted tasks within the target time period in the historical submission record, and determine the associated task from the submitted tasks based on the statistical result.

8. The method according to claim 2, wherein In a case where the associated task is the target task, constructing and testing the target task includes: In a case where the associated task is the target task, performing initial construction and testing on the target code in the code submission request to obtain a code test result corresponding to the target code; When the task status of the target task is updated to a completed state, a code test result of the associated code corresponding to the target task is tested and a target construction process is performed on the target task.

9. The method according to claim 8, wherein Testing and verifying the code test results of the associated code corresponding to the target task, including: Analyze the code test results using a data analysis model to generate test scores and modification suggestions; If the associated code is repaired according to the modification suggestion and it is determined that the test score is greater than a preset threshold, it is determined that the inspection is passed.

10. The method according to claim 1, wherein Generating and sending a version report corresponding to the target version program to the associated client, including: Analyze the associated codes corresponding to the target task from multiple change dimensions, determine the change result, and determine the change version type based on the change result; Determine the content template corresponding to the changed version type, instantiate the content template according to the changed result and generate version release notes, or Constructing a change feature vector based on the change result, the submission information, and the code test report, and processing the change feature vector using a change description model to generate the version release description; A target version number is generated according to the changed version type, a version report corresponding to the target version program is generated according to the version number and the version release description, and the version report is sent to the associated client.

11. The method according to claim 1, wherein After generating and sending a version report corresponding to the target version to the associated client, the method further includes: Based on the task data of the target task, a time series model is used to predict the generation time point of the next version task corresponding to the target task.

12. The method according to claim 11, wherein Based on the task data of the target task, a time series model is used to predict the generation time point of the next version task corresponding to the target task, including: Constructing task time series data corresponding to the target task based on the task completion time series, historical version data, and defect repair cycle data of the target task; The time series model is used to extract features from the task time series data to obtain basic time series features and high-order derivative features, and the generation time point of the next version task corresponding to the target task is predicted based on the basic time series features and the high-order derivative features.

13. The method according to claim 1, wherein After building and testing the target tasks, it also includes: In the event of a build failure, determining the number of build failures, and triggering an alarm notification when the number of build failures reaches a preset alarm threshold; When the target task is tested and it is determined based on the test result that the test pass rate has decreased, the alarm notification is triggered.

14. A data processing device, characterized in that: include: A task assignment module is configured to determine a target task and assign the target task to a target client; a task association module configured to, in response to a code submission request sent by the target client, process submission information carried in the code submission request using a task association model, and determine an associated task corresponding to the code submission request; A task verification module is configured to construct and test the target task when the associated task is the target task; The version publishing module is configured to publish the target version program corresponding to the target task if the verification is passed, and generate and send a version report corresponding to the target version program to the associated client.

15. A data processing system, characterized in that: include: A task management unit, configured to determine a target task and assign the target task to a target client; A version control unit, configured to respond to a code submission request sent by the target client, process submission information carried in the code submission request using a task association model, and determine an associated task corresponding to the code submission request; A construction and testing unit, configured to construct and test the target task if the associated task is the target task; The task management unit is further configured to, if the verification is passed, publish the target version program corresponding to the target task, and generate and send a version report corresponding to the target version program to an associated client.

16. A computing device, characterized in that include: memory and processor; The memory is used to store computer programs / instructions, and the processor is used to execute the computer programs / instructions. When the computer programs / instructions are executed by the processor, the method according to any one of claims 1 to 13 is implemented.

17. A computer-readable storage medium, characterized in that The computer-readable storage medium stores a computer program / instruction, and when the computer program / instruction is executed by a processor, the method according to any one of claims 1 to 13 is implemented.

18. A computer program product, characterized in that The method comprises a computer program / instruction, which implements the method according to any one of claims 1 to 13 when executed by a processor.

Images