Automated wrapping tool with guidance from example commands

Abstract

The information received from the graphical user interface (GUI) and the list of user-curated command line patterns is received by an automated wrapper system associated with the analytical workflow service. The automated wrapper system generates a module including a parameter space with one or more parameters and options used in the list of user-curated command line patterns, the content of each parameter being derived from a combination of the parameter's presence in the list of user-curated command line patterns and the information received from the GUI (Figure 2).

Description

[Technical Field]

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

[0002] Although many open source code bases or software are available to users, most of them can only be executed via a command line interface. These code bases do not have standard or basic usage requirements, which results in cumbersome and confusing interactions when invoked by various users. As a result, the execution speed of these code bases is significantly slowed down due to incompatibility between different systems and the use of customized languages ​​and parameter descriptions and definitions. Summary of the Invention

[0003] One or more computer systems can be configured to perform specific operations or actions by having installed thereon software, firmware, hardware, or a combination thereof that causes the system to perform the operations during operation. One or more computer programs can be configured to perform specific operations or actions by including instructions that, when executed by a data processing device, cause the device to perform the operations. One embodiment includes a computer-implemented method, comprising: receiving, by an automated wrapper system, information received from a graphical user interface (GUI) and a list of user-curated command line patterns, the automated wrapper system associated with an analytical workflow service; and generating, by the automated wrapper system, a module including a parameter space having one or more parameters and options used in the list of user-curated command line patterns, the content of each parameter being derived from the presence of the parameter in the list of user-curated command line patterns combined with the information received from the GUI. Other embodiments of this aspect include corresponding computer systems, devices, and computer programs stored on one or more computer storage devices, each configured to perform the operations of a method. The teachings herein improve the execution speed and automatic wrapping of command line code.

[0004] The method may further include converting, by the automated wrapper system, each command line pattern in the list of user-curated command line patterns into an example snippet in the language of the analysis workflow service that invokes the module to reproduce the command line pattern. The example snippet embodies document content to easily verify the information received from the GUI. The content of each parameter includes a short tag, a display label, a description, an enrichment document, a type, an insertion pattern, a default value, and optionality. The automated wrapper system begins by parsing each command line pattern in the list of user-curated command line patterns into a command with a parameter / option / value representation, where the results of the parsing are provisional and different parsing techniques may derive different meanings. The automated wrapper 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; and the initial parsing of the user-curated list of command line patterns generates a set of information used to set parameters for analyzing the user-curated list of command line patterns. An automated wrapper system resolves each parameter / option / value expression against an index, where resolution includes modifying the analysis result by reconstructing one expression, combining two expressions into one, or splitting one into two according to what is found in the index. The method may further include converting, by the automated wrapper system, each command line pattern in the user-curated list of command line patterns into an example snippet in the language of the analytical workflow service that invokes the module to reproduce the command line pattern.

[0005] In one embodiment, the content of each parameter includes a short tag, a display label, a description, an enrichment document, a type, an insertion pattern, a default value, and optionality. The automated wrapper system begins by parsing each command line pattern in the user-curated list of command line patterns into a command with a parameter / option / value representation, where the results of the parsing are provisional because different parsing techniques may derive different meanings. The automated wrapper system parses the information received from the GUI into an index that associates parameter and / or option symbols with associated content such as types and descriptions; and the initial parsing of the user-curated list of command line patterns generates a set of information used to set parameters for parsing the user-curated list of command line patterns. The automated wrapper system resolves each parameter, option, and value representation against an index, where resolving includes modifying the parsing result by reconstructing one representation, combining two representations into one, or splitting one into two, according to 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.

[0006] One embodiment includes a non-transitory computer-readable storage medium tangibly embodied with computer-readable program code having computer-readable instructions. The non-transitory computer-readable storage medium also includes receiving, by an automated wrapper system, information received from a graphical user interface (GUI) and a list of user-curated command line patterns, the automated wrapper system associated with an analytical workflow service; and generating, by the automated wrapper system, a module including a parameter space having one or more parameters and options used in the list of user-curated command line patterns, the content of each parameter being derived from the presence of the parameter in the list of user-curated command line patterns combined 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 operations of the method.

[0007] In one embodiment, the example snippets embody document content to facilitate easy review of information received from the GUI. Implementations of the described techniques may include hardware, a method or process, or computer software on a computer-accessible medium.

[0008] One embodiment includes a computing device including a processor and a network interface coupled to the processor to enable communication over a network. A storage device is coupled to the processor. An automatic wrapping engine is stored on the storage device, and execution of the automatic wrapping engine by the processor configures the computing device to perform operations including receiving, by the computing device, information received from a graphical user interface (GUI) and a list of user-curated command line patterns, the computing device being associated with an analytical workflow service; and generating, by the computing device, a module including a parameter space having one or more parameters and options used in the list of user-curated command line patterns, the content of each parameter being derived from the presence of the parameter in the list of user-curated command line patterns combined with the information received from the GUI. Other embodiments of this aspect include corresponding computer systems, apparatuses, and computer programs recorded on one or more computer storage devices, each configured to perform the operations of the method.

[0009] In one embodiment, execution of the automatic wrapping engine by a processor further configures the computing device to perform the operation of converting each command line pattern in the list of user-curated command line patterns into an example snippet in the language of the analytical workflow service that invokes the module to recreate the command line pattern. The example snippet embodies document content to easily verify information received from a GUI. The computing device begins by parsing each command line pattern in the list of user-curated command line patterns into a command with a representation of parameters, options, and values, where the results of the parsing are provisional because different parsing techniques may derive 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; and the initial parsing of the list of user-curated command line patterns generates a set of information used to set parameters for analyzing the list of user-curated command line patterns. The computing device resolves the representation of each parameter, option, and value against the index, where resolution includes modifying the analysis result by reconstructing one representation, combining two representations into one, or splitting one into two, according to what is 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 techniques described herein may be implemented in several ways. An example implementation is provided below with reference to the following figures: [Brief explanation of the drawings]

[0011] The drawings are of exemplary embodiments. The drawings do not depict all embodiments. Other embodiments may be used in addition or instead. Details that may be obvious or unnecessary may be omitted to save space or for a more effective illustration. Some embodiments may be practiced using additional components or steps, or without all of the components or steps shown, or both. When the same numeral appears in different drawings, it refers to the same or similar components or steps.

[0012] [Figure 1] FIG. 1 illustrates an exemplary architecture for implementing an automatic wrapper system according to one embodiment.

[0013] [Figure 2] FIG. 1 illustrates a system diagram according to one embodiment.

[0014] [Figure 3] FIG. 1 illustrates a command line user interface according to one embodiment.

[0015] [Figure 4] FIG. 1 illustrates a graphical user interface according to one embodiment.

[0016] [Figure 5] FIG. 1 illustrates a flowchart of a method used by an automated wrapping system according to one embodiment.

[0017] [Figure 6] FIG. 1 is an exemplary schematic diagram of a system according to one embodiment. DETAILED DESCRIPTION OF THE INVENTION

[0018] overview

[0019] In the following detailed description, by way of example, numerous specific details are set forth in order to provide a thorough understanding of the relevant teachings. However, it will be apparent that the present teachings may be practiced without such details. In other instances, well-known methods, procedures, components, or circuits, or combinations thereof, have been described in relatively broad terms and without detail in order to avoid unnecessarily obscuring aspects of the present teachings.

[0020] The present disclosure generally relates to a cloud-based system or web portal system and method in which a user specifies a software tool for wrapping. The user inputs a specification of the environment required to run the tool. The specification may be a containerized image or a string identifying a container image that may be obtained from a storage location or a third party. Following input of the environment specification, the user may input one or more strings of text or command line calls typically used to run the software tool in the specified environment. The text is read and parsed into calls and parameters using one or more heuristics to generate an initial version of a module for use with the tool. A module for a given tool includes data records containing the environment specification, data records specifying parameters available to the tool, and records specifying how future command lines should be generated to run the software tool. The system generates one or more GUIs that allow the user to modify values, types, descriptions, flags, and other details of the command line call instructions included in the module. An index is generated based on the input obtained from the GUIs and used to create the final version of the module, which is then provided to an analytical workflow service.

[0021] The modules created in this way are used in the analytical workflow service to execute the software tool one or more times. The analytical workflow service may have a library of numerous modules, generated either by operation of the various embodiments or by other means. The analytical workflow service operates to orchestrate the execution of the modules according to instructions provided by the user. The module content derived in the wrapping process is used to guide users of the analytical workflow service on how to properly use the modules. The module content is also used to set up the necessary execution environment and formulate the execution command line each time the tool needs to be executed. A given tool may be executed thousands of times.

[0022] Thus, one or more methods described herein may eliminate the need for time-consuming data processing by a user. This may have the technical effect of reducing computing resources used by one or more devices in a 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 aspects of the teachings herein are beyond the capabilities of the human mind. It should also be understood that various embodiments of the subject disclosure described herein may involve information that is impossible for an entity, such as a human user, to manually obtain. The work performed by a software tool cannot be performed by a human user due to the amount of processing involved. The work of an analytical workflow system generating a command line each time a tool module is invoked cannot be reasonably performed manually by a human user due to the sheer number of such invocations, the potential for invocations to occur at any time of the day or night, and the need for error-free execution. The work performed by an automated wrapper system is generally beyond the capabilities of a human user of ordinary skill in the art to produce successful results, because the information in the modules must precisely match the complex requirements of the analytical workflow system. Exemplary Architecture

[0024] To better understand the features of the present disclosure, it may be helpful to describe a known architecture. To that end, Figure 1 illustrates an exemplary architecture 100 for implementing an automated wrapper system. Architecture 100 includes a network 104 that enables one or more user devices, such as user device 102, to communicate with one or more clouds, such as cloud 106, and other elements connected to network 104, such as automated wrapper system 108.

[0025] The network 104 can 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 communicatively coupled to a private network, sometimes called an intranet, that provides various auxiliary services, such as various application stores, libraries, and communication with the Internet. The network 104 enables an automated wrapper system 108 to receive and analyze data from the user device 102 and present a graphical user interface (GUI) to the user for data selection, modification, and updating for the automated generation of modules associated with the analytical workflow service. The modules generated for this purpose may be described as the tool's code wrapper. Analytical workflow services can exist without an automated wrapper system, and some exist in the prior art. Two examples are online services that provide access via a web browser application at https: / / www.sevenbridges.com and https: / / terra.bio. In these systems, modules (or code wrappers) are represented as files written in a programming language such as Common Workflow Language (CWL) or Workflow Definition Language (WDL). Such modules may be created by programmers with special skills. An embodiment of the present invention may be created using one of these services by building an automated wrapper system and generating the results as CWL or WDL.

[0026] For later discussion, one user device is shown in the diagram to represent some examples of computing devices that can be sources of container images, user-curated command line patterns, and information received from the GUI. Today, user devices typically take the form of laptops, desktops, smartphones, and tablet computers, but may be implemented in other form factors, including consumer and business electronic devices and servers.

[0027] 2 is a diagram of a system 200 according to one embodiment. System 200 may be an implementation of automated wrapper system 108. System 200 may include receiving information from a GUI 202 and one or more user-curated lists 204 of command line patterns as input to automated wrapper system 208. Automated wrapper system 208 may be part of analytical workflow services 206.

[0028] The automated wrapper system 208 may generate an index based on information received from the GUI 202. Based on the index and analysis results from the user-curated list of command line patterns 204, the automated wrapper system 208 may generate a parameter space containing one or more parameters and options in the module 210. The automated wrapper system 208 may convert the module content to be in the language of the analytical workflow service.

[0029] 3 illustrates a command line user interface 300 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 where a user inputs the location of where one or more container images will be placed, and the command line 304 may be used as a command line where the user indicates a call string along with its own parameters or values ​​to be parsed by the automated wrapper system 108. As shown, the command bcftools may be used to call a Variant Call Format (VCF) file, which may be used in bioinformatics to store genetic sequence variations.

[0030] FIG. 4 illustrates a graphical user interface (GUI 400) according to one embodiment. GUI 400 may include one or more GUI lines, such as GUI lines 420-432, representing each parameter, call, etc. As shown, GUI line 420 indicates that parsed command line segment 402 was parsed and detected as a call with "bcftools annotate" as the phrase passed to the call. GUI line 422 indicates that parsed command line segment 404 was detected as a parameter (i.e., parameter 1) with --threads as a flag and value 9 set as an integer. In this case, the user can change the input type via dropdowns, modify flags, modify values, or add a description. Similarly, the user can delete a line or parameter entirely by pressing the circled dash on the right side of GUI line 420.

[0031] GUI line 424 shows that parsed command line segment 406 was detected as a parameter with -e as a flag and value 9.9 set as a float (i.e., parameter 2). GUI line 426 shows that parsed command line segment 408 was detected as a parameter with -c as a flag and value ID,REF set as a string (i.e., parameter 3). GUI line 428 shows that parsed command line segment 410 was detected as a parameter with -a as a flag of type INPUT FILE with the option to add a value, for example, by clicking the circled + (i.e., parameter 4). GUI line 430 shows that parsed command line segment 412 was detected as a parameter with -o as a flag of type INPUT FILE with the option to add a value (i.e., parameter 5). GUI line 432 shows that parsed command line segment 414 was detected as a parameter with no flags and an INPUT FILE type with the option to add a value and description (i.e., parameter 6).

[0032] When correcting information received from GUI 400, the user may choose to modify any of the entered results. The user may, for example, restructure one or more representations, combine two representations into one, or split one representation into two. Explanations may be added to any of GUI lines 420-432. Data input types may be changed for one or more lines. Values ​​may be corrected, as may flags and / or parameters. Any changes may be considered within the scope of the scripts and coding used by the analytical workflow service.

[0033] An example of an analysis procedure according to one embodiment is: - Parsing space-separated elements, Examining elements to find the first element that starts with a dash ("-") or contains an extension (e.g., ".txt", ".vcf", etc.) Includes. The previous element is then defined as the call. - For the first element that starts with a dash ("-") or contains an extension (e.g., ".txt", ".vcf", etc.), the following can occur: a. If the first element starts with a dash ("-"): i. If the following element also starts with a dash ("-"): the new parameter is defined as a Boolean flag. Otherwise, ii. If the following element can be represented as an integer: A new parameter is created with the flag defined as the dash element, the input type defined as an integer, and the value defined as the following element. Otherwise, iii. If the following element can be expressed as a float: A new parameter is created with the flag defined as the dash element, the input type defined as a float, and the value defined as the following element. Otherwise, iv. If a subsequent element is specified that contains an extension: A new parameter is created with the flag defined as the dash element, the input type defined as file, and the value defined as the subsequent element. Otherwise, v. If the following element can be represented as a string: A new parameter is created with the flag defined as the dash element, the input type defined as a string, and the value defined as the following element. b. If the first element contains an extension (eg, ".txt", ".vcf", etc.): A new parameter may be defined as a location-specified file with no flags. The automatic wrapper system 108 may proceed to the next element that is not part of the parameter definition. Once the automatic wrapper system 108 assigns elements to parameters or calls, these definitions are presented to the user graphically, such as in GUI 400. The user may then modify the parameter definitions. - Once the user confirms, the automatic wrapper system 108 generates code for each parameter and call.

[0034] One complete example is: bcftools annotate --threads 9 -e 9.9 -c ID,REF -a samples.txt -o annotated.vcf cleaned.vcf

[0035] 1) The automatic wrapper system 108 parses the elements by space delimiter (| indicates a space that is found).

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

[0037] 2) The automatic wrapper system 108 finds the first element that starts with a dash ("-") or contains an extension: bcftools|annotate|--threads|9|-e 9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0038] The call is defined as bcftools annotate.

[0039] 3) The element begins with a dash and the following elements are valid integers: bcftools|annotate|--threads|9|-e 9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0040] A new parameter with flag "--threads", type "integer", and value "9" is created (parameter 1).

[0041] 4) The next element is found that starts with a dash and is followed by a valid floating point number: bcftools|annotate|--threads|9|-e 9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0042] A new parameter is created with flag "-e", type "float", and value "9.9" (parameter 2).

[0043] 5) The next element is found that starts with a dash and is a valid string: bcftools|annotate|--threads|9|-e 9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0044] A new parameter with flag "-c", type "string", and value "ID,REF" is created (parameter 3).

[0045] 6) The next element is found that starts with a dash and the following element contains an extension: bcftools|annotate|--threads|9|-e 9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0046] A new parameter is created with the flag "-a", type "file", and value "samples.txt" (parameter 4).

[0047] 7) The next element is found that starts with a dash and the following element contains an extension: bcftools|annotate|--threads|9|-e 9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0048] A new parameter is created with flag "-o", type "file" and value "annotated.vcf" (parameter 5).

[0049] 8) The following element is found, including the extension: bcftools|annotate|--threads|9|-e 9.9|-c|ID,REF|-a|samples.txt|-o|annotated.vcf|cleaned.vcf

[0050] A new parameter is created (parameter 6) with no flags, type "file", and value "cleaned.vcf". At this point, the element is defined by the automatic wrapper system 108.

[0051] After the above draft is created by automatic wrapping, the user may modify the determined content through the presented UI. For example, the user can specify the "string" type (or possibly the "output_path" type) for the "-o" parameter to provide a location where a file should be created rather than supplying an existing file. The user can also provide an explanation of the meaning of some or all parameters and specify some parameters as optional.

[0052] The above description illustrates the processing of one example command line. More accurate results can be generated if the user provides multiple example command lines. When multiple example commands are provided, each command is parsed as described above to create its own parameter space. These parameter spaces are then merged using a reconciliation heuristic. To merge two parameter spaces, parameters may first be pairwise associated, either by name for named parameters or by position for positional parameters. Next, parameter mismatches that represent parsing conflicts are reconciled. This occurs when one parameter space has named parameters as flags and the other has them as non-flag parameters that take values. The other parameter space is then deemed misparsed and modified to replace non-flag parameters with flag and positional parameters. This changes the positional parameter numbers, so the first step of parameter association is redone.

[0053] After parsing conflicts are reconciled, type conflicts are resolved by choosing the least restrictive type if necessary. So if a parameter is considered an INT in one example, but a FLOAT in another, it will be considered a FLOAT because integer values ​​are valid in FLOAT. Parameters that are not found in both parameter spaces are then marked as optional.

[0054] If more than one example is provided, they are merged pairwise until a single parameter space is created from the collection. It should be appreciated that embodiments of the present invention may select many different strategies for parsing one or many command examples.

[0055] 5 illustrates a flowchart 500 of a method used by an automated wrapping system according to one embodiment. The automated wrapper system 108 may begin at block 502 where it receives input, such as a containerized program, such as a Docker™ image. The containerized program may relate to any source code, including libraries and dependencies necessary to run the code on any infrastructure. Key configuration files, libraries, and dependencies may be packaged with the code so that it can be executed on the cloud. In some embodiments, the containerized image may be presented by a user on command line 302. The automated wrapper system 108 may proceed to block 504 where it receives a command string input from command line 304.

[0056] At block 504, the automated wrapper system 108 may receive one or more commands with any variation of parameters, their values, and associated properties. For example, parameters may include one or more short tags, display labels, descriptions, enrichment documents, types, insertion patterns, default values, etc. Similarly, the command string input may include one or more commands with representations of parameters, options, and / or values. The automated wrapper system 108 may then move to block 506 where it may parse the command string input.

[0057] In block 506, the automatic wrapper 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 the start of a parameter. The title or name of the parameter may follow the dash, in one example. In this example, following the blank space may be the value of the parameter. 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, a Float type may default to the parameter. Similarly, if the value being parsed is an integer, an INT type may default. If a string or character is detected, a STR or CHAR may default. If a period or extension is detected, it may mean that a file is being indicated. The automatic wrapper system 108 may then move to block 508.

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

[0059] A user may make any modification to information received from a GUI, such as GUI 400, including, for example, changing values, input types, adding / modifying descriptions, deleting lines, adding lines, updating parameters, and / or changing calls. In one example, a user may modify GUI line 424 by modifying the input type to an integer and updating the value to 10. In another example, a user may delete one or more lines, such as GUI line 426 and GUI line 428, by selecting the circled dash to confirm the deletion of the line. In another embodiment, a user may select a file to load for GUI line 430 by selecting the circled +.

[0060] In block 510, the automated wrapper system 108 may create one or more indexes using the information received from the GUI received in block 508. The indexes are generated by the automated wrapper system 108 analyzing the information received from the GUI and associating parameter and option symbols with associated content, such as types and descriptions. The indexes may include selections, additions, changes, or modifications made with respect to the GUI 400.

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

[0062] In block 514, the automated wrapper system 108 may transform the parameter space to become data usable by the analytical workflow service. The parameter space may be transformed as a wrapper function. The wrapper function may include any layer of abstraction that wraps functionality or a piece of data. The wrapper function may be used by an analytical workflow service running locally or on the cloud.

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

[0064] The processing circuitry 602 may be implemented as one or more hardware logic components and circuits. For example, without limitation, exemplary types of hardware logic components that may be used include a field programmable gate array (FPGA), an application-specific integrated circuit (ASIC), an application-specific standard product (ASSP), a system-on-a-chip system (SOC), a general-purpose microprocessor, a microcontroller, a digital signal processor (DSP), or the like, or any other hardware logic component capable of performing calculations or other manipulations of information.

[0065] The memory 604 may be volatile (e.g., RAM, etc.), non-volatile (e.g., 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 610.

[0066] In another embodiment, memory 604 is configured to store software. Software shall be broadly construed to mean any type of instructions, whether referred to as software, firmware, middleware, microcode, hardware description language, or otherwise. The instructions may include code (e.g., code in source code format, binary code format, executable code format, or any other suitable format). The instructions, when executed by processing circuitry 602, cause processing circuitry 602 to perform various operations described herein. Specifically, the instructions, when executed, cause processing circuitry 602 to receive information received from a GUI and user-curated command line patterns and automatically create wrappers therefrom.

[0067] Storage 610 may be a solid-state device (SSD), magnetic storage, optical storage, etc., and may be implemented as, for example, flash memory or other memory technology, CD-ROM, DVD (Digital Versatile Disk), or any other medium that can be used to store desired information. Storage 610 may store automated wrapper system instructions 614 for execution according to flowchart 500 and analytical workflow service instructions 616 for execution according to an appropriate analytical workflow service as discussed. Network interface 612 enables system 600 to communicate with a cloud server network, for example, to receive data, transmit data, etc.

[0068] It should be understood that the embodiments described herein are not limited to the particular architecture illustrated in FIG. 6, and that other architectures may be used as well without departing from the scope of the disclosed embodiments. [Conclusion]

[0069] The description of various embodiments of the present teachings has been presented for purposes of illustration, but is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope of the described embodiments. The terms used herein have been selected to best explain the principles, practical applications, or technical improvements of the embodiments over technologies found in the market, or to enable others skilled in the art to understand the embodiments disclosed herein.

[0070] While the above describes what is believed to be the best mode and / or alternative examples, it is understood that various modifications can be made therein, that the subject matter disclosed herein can be embodied in various forms and examples, and that the teachings can be applied to many applications, only some of which are described herein. It is intended that the following claims claim all such applications, modifications, and variations that are within the true scope of the present teachings.

[0071] The components, steps, features, objects, benefits, and advantages described herein are merely exemplary. Neither they nor the descriptions associated therewith are intended to limit the scope of protection. While various advantages have been described herein, it will be understood that not all embodiments necessarily include all advantages. Unless otherwise specified, all measurements, values, ratings, positions, dimensions, sizes, and other specifications described herein, including the following claims, are approximate and not exact. They are intended to have a reasonable range consistent with the functions to which they relate and that which is customary in the art to which they pertain.

[0072] Many other embodiments are also contemplated, including those having fewer, additional, or different or combinations of components, steps, features, objects, benefits, and advantages, including those in which the components and / or steps are configured and / or ordered separately.

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

[0074] These computer-readable program instructions may be provided to a processor of a computer, special purpose computer, or other programmable data processing apparatus to create a machine, such that the instructions, when executed by the processor of the computer or other programmable data processing apparatus, create means for performing the functions / acts specified in one or more blocks of the call flow diagrams and / or block diagrams. These computer-readable program instructions may also be stored on a computer-readable storage medium that can instruct a computer, programmable data processing apparatus, or other device, or combination thereof, to function in a particular manner, such that the computer-readable storage medium on which the instructions are stored comprises an article of manufacture containing instructions that implement aspects of the functions / acts specified in one or more blocks of the call flow diagrams and / or block diagrams.

[0075] The computer-readable program instructions may also be loaded into 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, such that the instructions, which execute on the computer, other programmable apparatus, or other device, perform the functions / acts specified in one or more blocks of the call flow process and / or block diagram, to create a computer-implemented process.

[0076] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block of a call flow process or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may in fact be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending on the functionality involved. It should also be noted that each block of the block diagrams and / or call flow diagrams, and combinations of blocks in the block diagrams and / or call flow diagrams, may be implemented by a dedicated hardware-based system that performs the specified functions or operations or a combination of dedicated hardware and computer instructions.

[0077] While the foregoing has been described in conjunction with exemplary embodiments, it is understood that the term "exemplary" is intended to mean merely an example, not best or optimal. Except as noted immediately above, nothing described or illustrated is intended to, and should be construed as, providing the public with any component, step, feature, object, benefit, advantage, or equivalent, whether claimed or not.

[0078] It will be understood that the terms and expressions used herein have the ordinary meanings ascribed to such terms and expressions with respect to their respective fields of study and research, unless a specific meaning is otherwise stated herein. Relative terms such as first and second may be used solely to distinguish one entity or operation from another, without necessarily requiring or implying an actual relationship or order between the entities or operations. The terms "comprises," "comprising," or other variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that includes a list of elements does not include only those elements, but may also include other elements not inherent in or expressly listed within such process, method, article, or apparatus. An element preceded by "a" or "an" does not, in the absence of further constraints, exclude the presence of additional identical elements in the process, method, article, or apparatus that includes that element.

[0079] An Abstract of the Disclosure is provided to allow the reader to quickly ascertain the nature of the technical disclosure. It is submitted with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. In addition, the foregoing Detailed Description recognizes that various features are grouped together in various embodiments for the purpose of streamlining the disclosure. This method of disclosure is not to be interpreted as reflecting an intention that the claimed embodiments have more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive subject matter lies in less than all features of a single disclosed embodiment. Accordingly, the following claims are hereby incorporated into the Detailed Description, with each claim standing on its own as separately claimed subject matter.

Claims

1. receiving, by an automated wrapper system, information received from a graphical user interface (GUI) and a user-curated list of command line patterns, the automated wrapper system associated with an analytical workflow service; and generating, by the automated wrapper system, a module including a parameter space having one or more parameters and options used in the user-curated list of command line patterns, the content of each parameter being derived from the presence of the parameter in the user-curated list of command line patterns in combination with the information received from the GUI.

1. A computer-implemented method comprising:

2. 10. The method of claim 1, further comprising converting, by the automated wrapper system, each command line pattern in the user-curated list of command line patterns into an example snippet in a language of the analytical workflow service that invokes the module to reproduce the command line pattern.

3. 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 embodying the actual parameter values ​​using a format derived from the parameter space of the module; and Executing the generated command line. The method of claim 1 further comprising:

4. The method of claim 1 , wherein the content of each parameter includes a short tag, a display label, a description, an enrichment document, a type, an insertion pattern, a default value, and optionality.

5. The automated wrapper system begins by parsing each command line pattern in the user-curated list of command line patterns into a command having a representation of parameters, options, and values; The method of claim 1 , wherein the set of analysis results is modifiable by presentation via a graphical user interface.

6. The automated wrapper 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; 6. The method of claim 5, wherein an initial analysis of the user-curated list of command line patterns generates a set of information used to set parameters for analyzing the user-curated list of command line patterns.

7. the automated wrapper system resolves each parameter, option, and value expression against the index; The resolving step with the automated wrapper system includes modifying the analysis results from the result set by reconstructing one expression, combining two expressions into one, or splitting one expression into two expressions according to what is found in the index. The method of claim 6.

8. When executed, the computer device: receiving, by an automated wrapper system, information received from a graphical user interface (GUI) and a user-curated list of command line patterns, the automated wrapper system associated with an analytical workflow service; and generating, by the automated wrapper system, a module including a parameter space having one or more parameters and options used in the user-curated list of command line patterns, the content of each parameter being derived from the presence of the parameter in the user-curated list of command line patterns in combination with the information received from the GUI. A non-transitory computer-readable storage medium tangibly embodying computer-readable program code having computer-readable instructions for performing a method comprising:

9. 10. The non-transitory computer-readable storage medium of claim 8, further comprising converting, by the automated wrapper system, each command line pattern in the list of user-curated command line patterns into an example snippet in a language of the analytical workflow service that invokes the module to reproduce the command line pattern.

10. 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 embodying actual parameter values ​​using a format derived from the parameter space of the module; and Executing the generated command line. The non-transitory computer-readable storage medium of claim 8 , further comprising:

11. The non-transitory computer-readable storage medium of claim 8 , wherein the content of each parameter includes a short tag, a display label, a description, an enrichment document, a type, an insertion pattern, a default value, and optionality.

12. The automated wrapper system begins by parsing each command line pattern in the user-curated list of command line patterns into a command with a representation of parameters, options, and values; The non-transitory computer-readable storage medium of claim 8 , wherein the set of analysis results is modifiable by presentation via a graphical user interface.

13. The automated wrapper 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; 13. The non-transitory computer-readable storage medium of claim 12, wherein an initial analysis of the user-curated list of command line patterns generates a set of information used to set parameters for analyzing the user-curated list of command line patterns.

14. the automated wrapper system resolves each parameter, option, and value expression against the index; The resolving step with the automated wrapper system includes modifying the analysis results from the result set by reconstructing one expression, combining two expressions into one, or splitting one expression into two expressions according to what is found in the index.

14. The non-transitory computer-readable storage medium of claim 13.

15. processor; a network interface coupled to the processor to enable communication over a network; a storage device coupled to the processor; and an automatic wrapping engine stored on the storage device, wherein execution of the automatic wrapping engine by the processor comprises: receiving, by the computing device, information received from a graphical user interface (GUI) and a user-curated list of command line patterns, the computing device being associated with an analytical workflow service; and generating, by the computing device, a module including a parameter space having one or more parameters and options used in the list of user-curated command line patterns, the content of each parameter being derived from the presence of the parameter in the list of user-curated command line patterns in combination with the information received from the GUI; an automated wrapping engine that configures the computing device to perform operations including:

1. A computing device comprising:

16. 16. The computing device of claim 15, further comprising: converting, by the computing device, each command line pattern in the list of user-curated command line patterns into an example snippet in a language of the analytical workflow service that invokes the module to reproduce the command line pattern.

17. The processor: 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 embodying actual parameter values ​​using a format derived from the parameter space of the module; and Steps to execute the generated command line 20. The computing device of claim 16, further configured to perform operations including:

18. The computing device of claim 15 , wherein the content of each parameter includes a short tag, a display label, a description, an enrichment document, a type, an insertion pattern, a default value, and optionality.

19. The computing device begins by parsing each command line pattern in the user-curated list of command line patterns into a command having a representation of parameters, options, and values; The computing device of claim 15 , wherein the set of analysis results is modifiable by presentation via a graphical user interface.

20. the computing device parses the information received from the GUI into an index that associates parameter and / or option symbols with associated content, including type and description; 20. The computing device of claim 19, wherein an initial analysis of the user-curated list of command line patterns generates a set of information used to set parameters for analyzing the user-curated list of command line patterns.

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

Images