Automatic encapsulation tool with guidance from exemplary commands

Abstract

Information received from a graphical user interface (GUI) and a list of user-managed command line patterns are received by an automatic wrapper system, where the automatic wrapper system is associated with an analytic workflow service. A module is generated by the automatic wrapper system that includes a parameter space having one or more parameters and options for use in the list of user-managed command line patterns, where content for each parameter is derived from the presence of the parameter in the list of user-managed command line patterns in combination with information received from the GUI.

Description

Technical Field

[0001] The present disclosure relates generally to analytical workflow services, and more particularly, to systems and methods for automatically wrapping code for execution by analytical workflow services. Background Art

[0002] Many open source code libraries or software are available to users, most of which can only be executed via a command line interface. There are no standards or basic usage requirements for these code libraries, resulting in cumbersome and confusing interactions when called by various users. Therefore, the speed of executing these code libraries is significantly reduced due to incompatibilities of different systems, custom languages, and the use of parameter descriptions and definitions. Summary of the invention

[0003] A system of one or more computers may be configured to perform a specific operation or action by installing software, firmware, hardware, or a combination thereof on the system, which in operation causes the system to perform an action. One or more computer programs may be configured to perform a specific operation or action by including instructions that, when executed by a data processing device, cause the device to perform the action. One embodiment includes a computer-implemented method. The computer-implemented method also includes: receiving information received from a GUI and a list of user-managed command line patterns by an automatic wrapper system, wherein the automatic wrapper system is associated with an analysis workflow service; and generating a module including a parameter space by the automatic wrapper system, wherein the parameter space has one or more parameters and options used in the list of user-managed command line patterns, wherein the content for each parameter is derived from the presence of the parameter in the list of user-managed command line patterns in combination with the information received from the GUI. Other embodiments of this aspect include corresponding computer systems, devices, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the method. Through the teachings of this article, the execution speed of command line code and the automatic packaging thereof are improved.

[0004] The method may include: converting, by the automatic packager system, each command line pattern in the list of user-managed command line patterns into an example snippet in the language of the analysis workflow service, the example snippet invoking the module in a manner that reproduces the command line pattern. The example snippet is combined with the document content of the information received from the GUI for easy viewing. The content for each parameter includes a short label, a display tag, a description, rich documentation, a type, an insertion mode, a default value, and optionality. The automatic packager system begins by parsing each command line pattern in the list of user-managed command line patterns into a command with parameter / option / value expressions, wherein the results of the parsing are experimental because different parsing methods may produce different meanings. The automatic packager system parses the information received from the GUI into an index that associates parameter and / or option symbols with associated content such as type and description, wherein the initial parsing of the list of user-managed command line patterns generates a set of information used to set parameters for parsing the list of user-managed command line patterns. The auto-wrapper system parses each parameter / option / value expression against the index, wherein parsing includes modifying the parsed result by reconstructing an expression, combining two expressions into one expression, or splitting one expression into two expressions based on content found in the index. The method may include converting, by the auto-wrapper system, each command line pattern in the list of user-managed command line patterns into an example snippet in the language of the analysis workflow service, the example snippet invoking the module in a manner that reproduces the command line pattern.

[0005] In one embodiment, the content for each parameter includes: a short label, a display tag, a description, rich documentation, a type, an insertion mode, a default value, and optionality. The automatic packager system begins by parsing each command line pattern in the list of user-managed command line patterns into a command with parameter / option / value expressions, wherein the results of the parsing are tentative because different parsing methods may produce different meanings. The automatic packager system parses the information received from the GUI into an index that associates parameter and / or option symbols with associated content such as type and description, wherein the initial parsing of the list of user-managed command line patterns generates a set of information that is used to set parameters for parsing the list of user-managed command line patterns. The automatic packager system parses each parameter, option, and value expression against the index, wherein parsing includes: modifying the parsing results by reconstructing an expression, combining two expressions into one expression, or splitting one expression into two expressions based on the content found in the index. Implementations of the described technology may include hardware, methods or processes, or computer software on a computer-accessible medium.

[0006] One embodiment includes a non-transitory computer-readable storage medium tangibly embodying a computer-readable program code having computer-readable instructions. The non-transitory computer-readable storage medium also includes: receiving, by an automatic packager system, information received from a GUI and a list of user-managed command line patterns, wherein the automatic packager system is associated with an analytical workflow service; and generating, by the automatic packager system, a module including a parameter space, the parameter space having one or more parameters and options used in the list of user-managed command line patterns, wherein content for each parameter is derived from the presence of the parameter in the list of user-managed command line patterns in combination with the information received from the GUI. Other embodiments of this aspect include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the method.

[0007] In one embodiment, the example snippets are combined with document content of information received from a GUI for ease of viewing.Implementations of the described techniques may include hardware, methods or processes, or computer software on a computer-accessible medium.

[0008] One embodiment includes a computing device, the computing device including: a processor; and a network interface, which is coupled to the processor to enable communication over a network. A storage device is coupled to the processor. An automatic packaging engine is stored in the storage device, wherein execution of the automatic packaging engine by the processor configures the computing device to perform actions, the actions comprising: receiving, by the computing device, information received from a GUI and a list of user-managed command line patterns, wherein the computing device is associated with an analysis workflow service; and generating, by the computing device, a module including a parameter space, the parameter space having one or more parameters and options used in the list of user-managed command line patterns, wherein the content for each parameter is derived from the presence of the parameter in the list of user-managed command line patterns in combination with the information received from the GUI. Other embodiments of this aspect include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the method.

[0009] In one embodiment, the execution of the automatic packaging engine by the processor further configures the computing device to perform the following actions: the computing device converts each command line pattern in the list of user-managed command line patterns into an example snippet in the language of the analysis workflow service, the example snippet calling the module in a manner that reproduces the command line pattern. The example snippet is combined with the document content of the information received from the GUI for easy viewing. The computing device begins by parsing each command line pattern in the list of user-managed command line patterns into a command with parameters, options, and value expressions, wherein the results of the parsing are experimental because different parsing methods may produce different meanings. The computing device parses the information received from the GUI into an index that associates parameter and / or option symbols with associated content such as type and description, wherein the initial parsing of the list of user-managed command line patterns generates a set of information used to set parameters for parsing the list of user-managed command line patterns. The computing device parses each parameter, option, and value expression against the index, wherein the parsing includes: modifying the parsing result by reconstructing an expression, combining two expressions into one expression, or splitting one expression into two expressions based on the content found in the index. Implementations of the described techniques may include hardware, a method or process, or computer software on a computer-accessible medium.

[0010] The technology described herein can be implemented in a variety of ways. Example implementations are provided below with reference to the following figures. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] The accompanying drawings are illustrative embodiments. They do not show all embodiments. In addition or alternatively, other embodiments may be used. Details that may be obvious or unnecessary may be omitted to save space or for more effective description. Some embodiments may be implemented with additional components or steps and / or without all components or steps shown. When the same number appears in different drawings, it refers to the same or similar components or steps.

[0012] Figure 1 An example architecture for implementing an automatic packager system according to one embodiment is shown.

[0013] Figure 2 A system diagram according to one embodiment is shown.

[0014] Figure 3 A command line user interface according to one embodiment is shown.

[0015] Figure 4 A graphical user interface according to one embodiment is shown.

[0016] Figure 5 A flow chart illustrating a method used by an automated packaging system according to one embodiment is shown.

[0017] Figure 6 is an example schematic diagram of a system according to one embodiment. DETAILED DESCRIPTION

[0018] Overview

[0019] In the following detailed description, many specific details are set forth by way of example in order to provide a thorough understanding of the relevant teachings. However, it should be appreciated that the present teachings may be practiced without these details. In other instances, well-known methods, procedures, components and / or circuits have been described at a relatively high level without detail in order to avoid unnecessarily obscuring aspects of the present teachings.

[0020] The present disclosure generally relates to systems and methods for a cloud-based system or web portal in which a user identifies a software tool for packaging. The user enters a specification of the environment required to execute the tool. The specification can be a containerized image, or a string that identifies a container image that can be obtained from a storage location or from a third party. After entering the specification of the environment, the user can enter one or more text sequences or command line calls, which are generally used to run the software tool in the specified environment. The text is read in and parsed into its call and parameters using one or more heuristics, and an initial version of a module for using the tool is generated. The module for a given tool includes a data record containing an environment specification, a data record specifying parameters that can be used with the tool, and a record specifying how a command line should be generated in the future to execute the software tool. The system generates one or more GUIs that allow the user to modify the value, type, description, flags, and other details of the command line call instructions contained in the module. Based on the input retrieved from the GUI, an index for creating a final version of the module is generated, which is provided to the analysis workflow service.

[0021] The modules thus created are used in an analysis workflow service to execute the software tool one or more times. The analysis workflow service may have a library of many modules generated by the operation of various embodiments or by other means. The analysis workflow service operates to coordinate the execution of the modules according to instructions provided by the user. The module content exported during the encapsulation process is used to instruct users of the analysis workflow service how to use the modules appropriately. The module content is also used to establish the required execution environment and formulate the execution command line each time the tool needs to be executed. A given tool can be run thousands of times.

[0022] Therefore, one or more of the methods discussed herein can avoid the need for time-consuming data processing by the user. This can have the technical effect of reducing the computing resources used by one or more devices within the system. Examples of such computing resources include, but are not limited to, processor cycles, network traffic, memory usage, storage space, and power consumption.

[0023] It should be understood that various aspects of the teachings herein are beyond the capabilities of the human mind. It should also be understood that the various embodiments of the present disclosure described herein may include information that is impossible to obtain manually by an entity such as a human user. Due to the amount of processing involved, the work done by the software tool cannot be done by a human user. The work of generating command lines done by the analysis workflow system each time a tool module is called cannot be reasonably done manually by a human user because there are too many such calls, which may occur at any time of the day or night, and they must be completed without error. The work done by the automatic packager system cannot be done by a human user with ordinary skills, because the information in the module must accurately match the complex requirements of the analysis workflow system, so ordinary users will generally not be able to create successful results.

[0024] Example Architecture

[0025] In order to better understand the features of the present disclosure, it may be helpful to discuss known architectures. To this end, Figure 1 An example architecture 100 for implementing an auto-packager system is shown. The architecture 100 includes a network 104 that allows one or more user devices, such as user device 102, to communicate with one or more clouds, such as cloud 106, and other elements, such as auto-packager system 108, connected to the network 104.

[0026] The network 104 may be, but is not limited to, a local area network (LAN), a virtual private network (VPN), a cellular network, the Internet, or a combination thereof. For example, the network 104 may include a mobile network that is communicatively coupled to a private network, which is sometimes referred to as an intranet that provides various auxiliary services (such as communication with various application storages, libraries, and the Internet). The network 104 allows the automatic encapsulator system 108 to receive data from the user device 102, parse the data, and present a graphical user interface (GUI) to the user for selection, modification, and updating of the data, for automatically generating modules associated with the analysis workflow service. The modules generated for this purpose may also be described as code encapsulators of tools. The analysis workflow service may exist without an automatic encapsulator system, and some exist in the prior art. Two examples are online services that provide access via a web browser application, with URLs of https: / / www.sevenbridges.com and https: / / terra.bio. In these systems, modules (or code encapsulators) are represented as files written in programming languages ​​such as common workflow language (CWL) or workflow definition language (WDL). Such a module can be created by a programmer with specialized skills.An embodiment of the present invention can be created using one of these services by constructing an automatic packager system to generate its results as a CWL or WDL.

[0027] For purposes of later discussion, one user device appears in the figure to represent some examples of computing devices that can be the source of container images, user-managed command-line modes, and information received from a GUI. Today, user devices typically take the form of laptops, desktop computers, smartphones, tablet computers, although they can be implemented in other form factors, including consumer and commercial electronic devices and servers.

[0028] Figure 2 A schematic diagram of a system 200 according to one embodiment is shown. The system 200 can be an implementation of the auto-wrapper system 108. The system 200 can include receiving information 202 received from the GUI and a list 204 of one or more user-managed command line patterns as input to the auto-wrapper system 208. The auto-wrapper system 208 can be part of the analysis workflow service 206.

[0029] The automatic packager system 208 can generate an index based on the information received from the GUI 202. Based on the index and the parsing results from the list 204 of user-managed command line patterns, the automatic packager system 208 can generate a parameter space including one or more parameters and options in the module 210. The automatic packager system 208 can convert the module content so that the module content is in the language of the analytical workflow service.

[0030] Figure 3 A command line user interface 300 is shown according to one embodiment. The command line user interface 300 may include a command line 302 and / or a command line 304. The command line 302 may be a place where a user enters the location of one or more container images. The command line 304 may then be used as a command line in which the user indicates a call string and their own parameters or values ​​parsed by the automatic packager system 108. As shown, the command bcftools may be used to call a variable call format (VCF) file, which may be used in bioinformatics to store genetic sequence variations.

[0031] Figure 4 A graphical user interface (GUI 400) according to one embodiment is shown. GUI 400 may include one or more GUI rows, such as GUI rows 420 and 432 representing each parameter, call, etc. As shown, GUI row 420 indicates that the parsed command line fragment 402 is parsed and detected as a call, wherein "bcftools annotate" is used as a phrase to be passed into the call. GUI row 422 indicates that the parsed command line fragment 404 is detected as a parameter (i.e., parameter 1), wherein --threads is used as a flag and the value is set to integer 9. In this case, the user can change the input type, modify the flag, modify the value, or add a description by pulling down. Similarly, the user can completely remove the row or parameter by pressing the dotted line with a circle on the right side of GUI row 420.

[0032] GUI line 424 indicates that the parsed command line segment 406 is detected as a parameter (i.e., parameter 2) with -e as a flag and the value is set to the floating point number 9.9. GUI line 426 indicates that the parsed command line segment 408 is detected as a parameter (i.e., parameter 3) with -c as a flag and the value is set to the string ID, REF. GUI line 428 indicates that the parsed command line segment 410 is detected as a parameter (i.e., parameter 4) with -a as a flag and the input file type has the option to add a value by clicking, for example, a circled +. GUI line 430 indicates that the parsed command line segment 412 is detected as a parameter (i.e., parameter 5) with -o as a flag and the input file type has the option to add a value. GUI line 432 indicates that the parsed command line segment 414 is detected as a parameter (i.e., parameter 6) with no flags and the input file type has the option to add a value and a description.

[0033] When modifying information received from the GUI of GUI 400, the user may choose to modify any of the one or more results that are populated. For example, the user may reconstruct one or more expressions, combine two expressions into one expression, or split one expression into two expressions. Descriptions may be added to any of GUI rows 420-432. Data input types may be changed for one or more of these rows. Values ​​as well as flags and / or parameters may be modified. Any changes within the scope of the scripts and coding used by the analytical workflow service may be considered.

[0034] An example of a parsing process according to an embodiment includes:

[0035] - Resolve elements by space.

[0036] - The elements are checked to find the first element that starts with a dash ("-") or contains an extension (eg ".txt", ".vcf", etc.). The previous element is then defined as a call.

[0037] - For the first element that begins with a dash ("-") or contains an extension (e.g. ".txt", ".vcf", etc.), the following can occur:

[0038] a. When the element starts with a dash ("-"):

[0039] i. When the subsequent element also starts with a dash ("-"): the new parameter is defined as a Boolean flag. Otherwise,

[0040] ii. When the subsequent element can be represented as an integer: create a new parameter where the flag is defined as the dashed element, the input type is defined as an integer, and the value is defined as the subsequent element. Otherwise,

[0041] iii. When the following element can be represented as a floating point number: create a new parameter where the flag is defined as the dashed element, the input type is defined as a floating point number, and the value is defined as the following element. Otherwise,

[0042] iv. When the subsequent element is identified as containing an extension: create a new parameter with the flag defined as the dashed element, the input type defined as file, and the value defined as the subsequent element. Otherwise,

[0043] v. When the subsequent element can be represented as a string: create a new parameter where the flag is defined as the dashed element, the input type is defined as string, and the value is defined as the subsequent element.

[0044] b. When the element contains an extension (e.g. ".txt", ".vcf", etc.): a new parameter can be defined as a location file without a flag.

[0045] - The auto-packager system 108 may proceed to the next element that is not part of the parameter definition.

[0046] Once the auto-packager system 108 assigns elements to parameters or calls, these definitions are graphically presented to the user as in the GUI 400 .

[0047] -The user can then change any parameter definition.

[0048] -After user confirmation, the automatic packager system 108 generates codes for each parameter and call.

[0049] In a complete example:

[0050] bcftools annotate --threads 9-e 9.9-c ID,REF-a samples.txt-oannotated.vcf cleaned.vcf

[0051] 1) The autopacker system 108 parses the element by space (| indicates the space found):

[0052] bcftools|annotate|--threads|9|-e9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0053] 2) The autopacker system 108 looks for the first element that starts with a dash ("-") or contains an extension:

[0054] bcftools|annotate|--threads|9|-e 9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0055] The call is defined as "bcftools annotate"

[0056] 3) The element starts with a dash and the following elements are valid integers:

[0057] bcftools|annotate|--threads|9|-e9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0058] Create a new parameter (param 1) with flag '--threads', type 'integer', and value '9'.

[0059] 4) Find the next element that starts with a dash and whose subsequent elements are valid floating point numbers:

[0060] bcftools|annotate|--threads|9|-e9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0061] Create a new parameter (parameter 2) with flag '-e', type 'float', and value '9.9'

[0062] 5) Find the next element that starts with a dash and whose subsequent elements are valid strings:

[0063] bcftools|annotate|--threads|9|-e9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0064] Create a new parameter with flag '-c', type 'string' and value 'ID,REF' (parameter 3)

[0065] 6) Find the next element that starts with a dash and the following elements have an extension:

[0066] bcftools|annotate|--threads|9|-e9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0067] Create a new parameter with flag "-a", type "file" and value "samples.txt" (parameter 4)

[0068] 7) Find the next element that starts with a dash and the following elements have an extension:

[0069] bcftools|annotate|--threads|9|-e9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0070] Create a new parameter (parameter 5) with flag "-o", type "file" and value "annotated.vcf"

[0071] 8) Find the next element with the extension:

[0072] bcftools|annotate|--threads|9|-e9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0073] A new parameter (parameter 6) is created with no flags, type "file" and value "cleaned.vcf." At this point, the elements have been defined by the autopackager system 108.

[0074] After the above draft is created by automatic packaging, the user can modify the determined content via the presented UI. The user can specify that the "-o" parameter has type "string" (or perhaps "output_path"), for example, because it does not provide an existing file, but provides the location where the file should be created. The user can also provide a description of what some or all parameters represent, as well as specify some parameters as optional.

[0075] The above description shows the processing of a single exemplary command line. When the user provides multiple example command lines, more accurate results can be generated. When multiple example commands are provided, each command is parsed as described above, thereby creating its own parameter space for the command. Then, these parameter spaces are merged using the coordination heuristic. Two parameter spaces can be merged by first associating their parameters in pairs according to their names (for named parameters) and according to the positions of their positional parameters. Secondly, the parameter differences representing the parsing conflicts are coordinated. This occurs when one parameter space has named parameters as flags and the other parameter space has unsigned parameters that take values. Then, the other parameter space is considered to be misparsed, and it is changed to replace the unsigned parameters with flag parameters plus positional parameters. Since this changes the position number of the positional parameters, the first step of associating parameters is repeated.

[0076] After the resolution conflicts have been reconciled, type conflicts are resolved by choosing the less restrictive type as appropriate. Thus, a parameter that is treated as an INT in one example but as a FLOAT in another example will be treated as a FLOAT, since integer values ​​are valid for FLOAT. The next step is to mark those parameters that are not found in both parameter spaces as optional.

[0077] When more than two examples are provided, they are merged in pairs until a parameter space has been created from the set.It will be appreciated that many different strategies for parsing one or more example commands may be selected as embodiments of the present invention.

[0078] Figure 5 Flowchart 500 shows a method used by an automatic packager system according to one embodiment. The automatic packager system 108 may begin at block 502, where the automatic packager system 108 receives an input, such as a Docker container. TM Containerized programs for images. Containerized programs can involve any source code, including libraries and dependencies required to run the code on any infrastructure. Important configuration files, libraries, and dependencies can be packaged with the code so that the code can run on the cloud. In some embodiments, a user can indicate a containerized image on the command line 302. The automatic packager system 108 can move to box 504, where the automatic packager system 108 receives a command string input from the command line 304.

[0079] In block 504, the automatic packager system 108 may receive one or more commands with any variations of parameters, their values, and associated properties. For example, the parameters may include one or more short tags, display tags, descriptions, rich documents, types, insertion modes, default values, etc. Similarly, the command string input may include one or more commands with parameters, options, and / or value expressions. The automatic packager system 108 may then move to block 506, where the automatic packager system 108 may parse the command string input.

[0080] At block 506, the automatic packager system 108 may parse the command string input according to one or more heuristics and one or more algorithms. For example, a dash or double dash may indicate to the system that there is the beginning of a parameter. In one example, the title or name of the parameter may then follow the dash. In this example, the value of the parameter or parameters may be followed by a blank space. The actual value may indicate to the system what value type is associated with the parameter. For example, if it is a floating point value, the floating point type may be the default setting for the parameter. Similarly, if an integer is the value being parsed, the INT type may be the default. When a string or character is detected, STR or CHAR may be set as the default value. When a time period or extension is detected, it may also mean that a file is being indicated. The automatic packager system 108 may then move to block 508.

[0081] In block 508, the auto-wrapper system 108 may present to the user one or more graphical user interfaces, such as the GUI 400. In one example, a graphical row for each parsed or detected command and parameter / value combination may be presented to the user. The auto-wrapper system 108 may convert each command line pattern in the list of user-managed command line patterns into one or more example snippets in the language of the analysis workflow service to reproduce the command line pattern.

[0082] The user may make any modification to the information received from a GUI such as GUI 400, including, for example, changing a value, input type, adding / modifying a description, removing a row, adding a row, updating parameters, and / or changing a call. In one example, the user may change GUI row 424 by correcting the input type to an integer and updating the value to 10. In another example, the user may remove one or more rows like GUI row 426 and GUI row 428 by selecting the circled dashed line and confirming the removal of the row. In another embodiment, the user may select a file to load for GUI row 430 by selecting the circled +.

[0083] At block 510, the auto-packager system 108 may create one or more indexes using the information received from the GUI at block 508. The indexes are generated by the auto-packager system 108 analyzing the information received from the GUI and associating parameter and option symbols with their associated content (e.g., type and description). The indexes may include selections, additions, changes, or modifications made with respect to the GUI 400.

[0084] In block 512, the auto-packager system 108 may generate a parameter space module, such as module 210, that may include one or more parameters and options used in the list of user-managed command line patterns. The content for the parameter may be derived from the presence of the parameter in the user-managed command line pattern in combination with information received from the GUI.

[0085] At block 514, the automatic wrapper system 108 may transmit the parameter space as data that may be used in the analytical workflow service. The parameter space may be transmitted as a wrapper function. The wrapper function may include any abstraction layer that wraps around a function or piece of data. The wrapper function may be used by the analytical workflow service to execute locally or on the cloud.

[0086] Figure 6 6 is an example schematic diagram of a system 600 according to one embodiment. The system 600 includes a processing circuit 602 coupled to a memory 604, a storage device 610, a user interface 606 (or GUI), and a network interface 612. In one embodiment, the components of the system 600 may be communicatively connected via a system bus 608.

[0087] Processing circuit 602 may be implemented as one or more hardware logic components and circuits. For example, but not limited to, illustrative types of hardware logic components that may be used include field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on a chip (SOCs), general purpose microprocessors, microcontrollers, digital signal processors (DSPs), etc., or any other hardware logic components that can perform calculations or other information manipulations.

[0088] The memory 604 may be volatile (eg, RAM, etc.), non-volatile (eg, ROM, flash memory, etc.), or a combination thereof. In one configuration, computer readable instructions for implementing one or more embodiments disclosed herein may be stored in the storage device 610 .

[0089] In another embodiment, the memory 604 is configured to store software. Software should be broadly interpreted to mean any type of instructions, whether referred to as software, firmware, middleware, microcode, hardware description language or other. Instructions may include code (e.g., in source code format, binary code format, executable code format, or any other suitable code format). The instructions, when executed by the processing circuit 602, cause the processing circuit 602 to perform the various processes described herein. Specifically, the instructions, when executed, cause the processing circuit 602 to receive information received from the GUI and command line patterns managed by the user, and automatically create a wrapper from them.

[0090] The storage device 610 may be a solid state device (SSD), a magnetic storage device, an optical storage device, etc., and may be implemented as, for example, flash memory or other memory technology, a CD-ROM, a digital versatile disk (DVD), or any other medium that may be used to store the desired information. The storage device 610 may store the auto-packager system instructions 614 executed according to the flowchart 500 as discussed, and the analysis workflow service instructions 616 executed according to the appropriate analysis workflow service. The network interface 612 allows the system 600 to communicate with a cloud server network, for example, to receive data, send data, etc.

[0091] It should be understood that the embodiments described herein are not limited to Figure 6 The specific architecture shown in , and other architectures may be equally used without departing from the scope of the disclosed embodiments.

[0092] in conclusion

[0093] The description of various embodiments of the present teachings has been presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope of the described embodiments. The terms used herein are selected to best explain the principles of the embodiments, practical applications, or technical improvements over existing technologies on the market, or to enable other persons of ordinary skill in the art to understand the embodiments disclosed herein.

[0094] Although the above has described what is considered to be the best state and / or other examples, it should be understood that various modifications may be made therein, and the subject matter disclosed herein may be implemented in various forms and examples, and the teachings may be applied to many applications, only some of which are described herein. The appended claims are intended to claim any and all applications, modifications and variations that fall within the true scope of the present teachings.

[0095] The components, steps, features, purposes, benefits and advantages discussed herein are merely illustrative. None of them or the discussion related to them is intended to limit the scope of protection. Although various advantages have been discussed herein, it will be understood that not all embodiments must include all advantages. Unless otherwise stated, all measurements, values, ratings, positions, sizes, dimensions and other specifications set forth in this specification (including in the appended claims) are approximate and not precise. They are intended to have a reasonable range consistent with the functions to which they are related and the practice of the field to which they belong.

[0096] Many other embodiments are also contemplated. These include embodiments with fewer, additional and / or different components, steps, features, objects, benefits and advantages. These also include embodiments in which components and / or steps are arranged and / or ordered in different ways.

[0097] Aspects of the present disclosure are described herein with reference to call flow diagrams and / or block diagrams of methods, devices (systems) and computer program products according to embodiments of the present disclosure. It will be understood that each step of the flow diagram and / or block diagram and the combination of blocks in the call flow diagram and / or block diagram can be implemented by computer-readable program instructions.

[0098] These computer-readable program instructions can be provided to a processor of a computer, a special-purpose computer, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device create a device for implementing the functions / actions specified in one or more boxes of the call flow processing and / or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium, which can guide the computer, programmable data processing device, and / or other equipment to work in a specific manner, so that the computer-readable storage medium in which the instructions are stored includes a product, which includes instructions for implementing various aspects of the functions / actions specified in one or more boxes of the call flow and / or block diagram.

[0099] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus, or other device to produce a computer-implemented process, whereby the instructions executed on the computer, other programmable apparatus, or other device implement the functions / actions specified in one or more boxes of the call flow processing and / or block diagram.

[0100] Flowcharts and block diagrams in the accompanying drawings show possible architectures, functions and operations of the systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each frame in the call flow process or block diagram can represent a module, segment or part of an instruction, which includes one or more executable instructions for realizing a specified logical function. In some alternative embodiments, the function noted in the frame may not occur in the order noted in the figure. For example, two frames shown in succession can actually be performed substantially simultaneously, or these frames can sometimes be performed in reverse order, depending on the function involved. It will also be noted that each frame of the block diagram and / or the call flow diagram and the combination of the frames in the block diagram and / or the call flow diagram can be realized by a dedicated hardware-based system that performs a specified function or action or performs a combination of special-purpose hardware and computer instructions.

[0101] Although the foregoing has been described in conjunction with exemplary embodiments, it should be understood that the term "exemplary" is meant only as an example, rather than the best or optimal. Except as immediately stated above, nothing stated or illustrated is intended or should be interpreted as causing any component, step, feature, object, benefit, advantage, or equivalent to be dedicated to the public, regardless of whether stated in the claims.

[0102] It should be understood that, unless a specific meaning is elaborated in addition herein, the terms and expressions used herein have the common meaning consistent with these terms and expressions about their corresponding respective investigation and research fields. Relational terms such as the first and second etc. can be used only to distinguish one entity or action from another, without requiring or implying any actual such relationship or order between these entities or actions. The term "includes", "comprising" or any other variation thereof is intended to cover non-exclusive inclusion, so that the process, method, article or device comprising a series of elements not only comprises these elements, but also may comprise other elements that are not clearly listed or are inherent to such process, method, article or device. In the absence of further constraints, the element with "one" or "an" in front does not exclude the presence of additional identical elements in the process, method, article or device comprising the element.

[0103] The abstract of the present disclosure is provided to allow the reader to quickly determine the nature of the technical disclosure. It should be understood that it is not used to interpret or limit the scope or meaning of the claims. In addition, in the aforementioned detailed description, it can be seen that in order to simplify the present disclosure, various features are grouped together in various embodiments. This method of disclosure should not be interpreted as reflecting the intention that the claimed embodiments have more features than the features explicitly recited in each claim. On the contrary, as reflected in the attached claims, the subject matter of the invention lies in less than all the features of a single disclosed embodiment. Therefore, the following claims are thereby incorporated into the detailed description, with each claim independently serving as a separately claimed subject matter.

Claims

1. A computer-implemented method comprising: receiving, by an automatic packager system, information received from a graphical user interface GUI and a list of user-managed command line patterns, wherein the automatic packager system is associated with an analysis workflow service; and A module is generated by the auto-packager system, the parameter space having one or more parameters and options for use in the list of user-managed command-line patterns, wherein content for each parameter is derived from the presence of the parameter in the list of user-managed command-line patterns in combination with the information received from the GUI.

2. The method according to claim 1, further comprising: Each command line pattern in the list of user-managed command line patterns is converted by the automatic wrapper system into an example snippet in a language of the analytical workflow service, the example snippet invoking the module in a manner that reproduces the command line pattern.

3. The method according to claim 1, further comprising: receiving, by the analytical workflow service, a set of actual parameter values ​​for an execution instance of the module; generating, by the analysis workflow service, a command line in which the actual parameter values ​​are incorporated using a format derived from the parameter space of the module; as well as Execute the generated command line.

4. The method according to claim 1, wherein: The content for each parameter includes short tag, display tag, description, rich documentation, type, insertion mode, default value, and optionality.

5. The method according to claim 1, wherein: The auto-wrapper system begins by parsing each command-line pattern in the list of user-managed command-line patterns into a command having parameters, options, and value expressions; as well as The result set of the analysis can be modified by presentation via a graphical user interface.

6. The method according to claim 5, wherein: The auto-packager system parses the information received from the GUI into an index associating parameter and / or option symbols with associated content such as type and description; as well as Initial parsing of the list of user-managed command-line patterns generates a set of information that is used to set parameters for analyzing the list of user-managed command-line patterns.

7. The method according to claim 6, wherein: The automatic wrapper system resolves each parameter, option, and value expression against an index; as well as The parsing of the automatic packager system includes modifying parsed results from the result set by reconstructing an expression, combining two expressions into one expression, or splitting one expression into two expressions according to content found in the index.

8. A non-transitory computer-readable storage medium tangibly embodying a computer-readable program code having computer-readable instructions, the computer-readable instructions, when executed, causing a computer device to perform a method comprising: receiving, by an automatic packager system, information received from a graphical user interface GUI and a list of user-managed command line patterns, wherein the automatic packager system is associated with an analysis workflow service; and A module is generated by the auto-packager system, the parameter space having one or more parameters and options for use in the list of user-managed command-line patterns, wherein content for each parameter is derived from the presence of the parameter in the list of user-managed command-line patterns in combination with the information received from the GUI.

9. The non-transitory computer-readable storage medium of claim 8, further comprising: Each command line pattern in the list of user-managed command line patterns is converted by the automatic wrapper system into an example snippet in a language of the analytical workflow service, the example snippet invoking the module in a manner that reproduces the command line pattern.

10. The non-transitory computer-readable storage medium of claim 8, further comprising: receiving, by the analytical workflow service, a set of actual parameter values ​​for an execution instance of the module; generating, by the analysis workflow service, a command line in which the actual parameter values ​​are incorporated using a format derived from the parameter space of the module; as well as Execute the generated command line.

11. The non-transitory computer-readable storage medium of claim 8, wherein: The content for each parameter includes short tag, display tag, description, rich documentation, type, insertion mode, default value, and optionality.

12. The non-transitory computer-readable storage medium of claim 8, wherein: The auto-wrapper system begins by parsing each command-line pattern in the list of user-managed command-line patterns into a command having parameters, options, and value expressions; as well as The result set of the analysis can be modified by presentation via a graphical user interface.

13. The non-transitory computer-readable storage medium of claim 12, wherein: The auto-packager system parses the information received from the GUI into an index associating parameter and / or option symbols with associated content such as type and description; as well as Initial parsing of the list of user-managed command-line patterns generates a set of information that is used to set parameters for analyzing the list of user-managed command-line patterns.

14. The non-transitory computer-readable storage medium of claim 13, wherein: The automatic wrapper system resolves each parameter, option, and value expression against an index; as well as The parsing of the automatic packager system includes modifying parsed results from the result set by reconstructing an expression, combining two expressions into one expression, or splitting one expression into two expressions according to content found in the index.

15. A computing device comprising: processor; a network interface coupled to the processor to enable communication over a network; a storage device coupled to the processor; an automatic packaging engine stored in the storage device, wherein execution of the automatic packaging engine by the processor configures the computing device to perform actions, the actions comprising: receiving, by the computing device, information received from a graphical user interface (GUI) and a list of user-managed command line patterns, wherein the computing device is associated with an analytical workflow service; and generating, by the computing device, a module comprising a parameter space having one or more parameters and options used in a list of the user-managed command line mode, Therein, the content for each parameter is derived from the presence of the parameter in the list of user-managed command line modes in combination with the information received from the GUI.

16. The computing device of claim 15, further comprising: Each command line pattern in the list of command line patterns managed by the user is converted, by the computing device, into an example snippet in a language of the analytical workflow service, the example snippet invoking the module in a manner that reproduces the command line pattern.

17. The computing device of claim 16, wherein: The processor is further configured to perform the following actions, including: receiving, by the analytical workflow service, a set of actual parameter values ​​for an execution instance of the module; generating, by the analytical workflow service, a command line in which the actual parameter values ​​are incorporated using a format derived from the parameter space of the module; and Execute the generated command line.

18. The computing device of claim 15, wherein: The content for each parameter includes short tag, display tag, description, rich documentation, type, insertion mode, default value, and optionality.

19. The computing device of claim 15, wherein: The computing device begins by parsing each command line pattern in the list of user-managed command line patterns into a command having parameters, options, and value expressions; as well as The result set of the analysis can be modified by presentation via a graphical user interface.

20. The computing device of claim 19, wherein: the computing device parsing the information received from the GUI into an index associating parameter and / or option symbols with associated content including a type and a description; as well as Initial parsing of the list of user-managed command-line patterns generates a set of information that is used to set parameters for analyzing the list of user-managed command-line patterns.

21. A computer program product comprising a computer-readable storage medium having instructions embodied therewith, the instructions being executable by a processor to cause the processor to perform the method according to any one of claims 1-7.

Images