भाग 4: Hello Modules

AI-सहायता प्राप्त अनुवाद - अधिक जानें और सुधार सुझाएं

यह section cover करता है कि अपने workflow की development और maintenance को अधिक efficient और sustainable बनाने के लिए अपने workflow code को कैसे organize करें। Specifically, हम demonstrate करेंगे कि modules कैसे use करें।

Nextflow में, एक module एक standalone code file है, जो अक्सर single process definition encapsulate करती है। Workflow में module use करने के लिए, तुम बस अपनी workflow code file में एक single-line include statement add करते हो; फिर तुम process को उसी तरह workflow में integrate कर सकते हो जैसे normally करते। यह multiple workflows में process definitions को reuse करना possible बनाता है बिना code की multiple copies produce किए।

जब हमने अपना workflow develop करना शुरू किया, हमने सब कुछ एक single code file में लिखा। अब हम processes को individual modules में move करेंगे।

यह हमारे code को अधिक shareable, flexible और maintainable बनाएगा।

इस section से कैसे शुरू करें

Course का यह section मानता है कि तुमने Hello Nextflow course के Parts 1-3 complete कर लिए हैं, लेकिन यदि तुम उन sections में covered basics से comfortable हो, तो तुम बिना कुछ special किए यहाँ से शुरू कर सकते हो।

---

0. Warmup: hello-modules.nf चलाएं

हम starting point के रूप में workflow script hello-modules.nf use करेंगे। यह इस training course के Part 3 में काम करके produce की गई script के equivalent है, सिवाय इसके कि हमने output destinations बदल दी हैं:

output {
    first_output {
        path 'hello_modules'
        mode 'copy'
    }
    uppercased {
        path 'hello_modules'
        mode 'copy'
    }
    collected {
        path 'hello_modules'
        mode 'copy'
    }
    batch_report {
        path 'hello_modules'
        mode 'copy'
    }
}

यह sure करने के लिए कि सब कुछ काम कर रहा है, कोई भी changes करने से पहले script को एक बार run करो:

nextflow run hello-modules.nf

Command output

 N E X T F L O W   ~  version 25.10.2

Launching `hello-modules.nf` [hopeful_avogadro] DSL2 - revision: b09af1237d

executor >  local (7)
[0f/8795c9] sayHello (3)       [100%] 3 of 3 ✔
[6a/eb2510] convertToUpper (3) [100%] 3 of 3 ✔
[af/479117] collectGreetings   [100%] 1 of 1 ✔

पहले की तरह, तुम्हें output files output block में specified directory में मिलेंगी (यहाँ, results/hello_modules/)।

Directory contents

results/hello_modules/
├── Bonjour-output.txt
├── COLLECTED-batch-output.txt
├── Hello-output.txt
├── Holà-output.txt
├── batch-report.txt
├── UPPER-Bonjour-output.txt
├── UPPER-Hello-output.txt
└── UPPER-Holà-output.txt

यदि यह तुम्हारे लिए काम किया, तो तुम अपने workflow code को modularize करना सीखने के लिए ready हो।

---

1. Modules store करने के लिए directory बनाएं

अपने modules को specific directory में store करना best practice है। तुम उस directory को कुछ भी कह सकते हो, लेकिन convention इसे modules/ कहना है।

mkdir modules

---

2. sayHello() के लिए module बनाएं

इसके simplest form में, existing process को module में turn करना little more than copy-paste operation है। हम module के लिए एक file stub बनाएंगे, relevant code copy करेंगे फिर इसे main workflow file से delete करेंगे।

फिर हमें बस एक include statement add करना होगा ताकि Nextflow जान सके कि runtime पर relevant code pull करना है।

2.1. New module के लिए file stub बनाएं

चलो sayHello.nf नामक module के लिए एक empty file बनाते हैं।

touch modules/sayHello.nf

यह हमें process code रखने के लिए एक जगह देता है।

2.2. sayHello process code को module file में move करें

Workflow file से पूरी process definition को module file में copy करो, #!/usr/bin/env nextflow shebang भी copy करना sure करो।

#!/usr/bin/env nextflow

/*
 * 'Hello World!' को एक फ़ाइल में प्रिंट करने के लिए echo का उपयोग करें
 */
process sayHello {

    input:
    val greeting

    output:
    path "${greeting}-output.txt"

    script:
    """
    echo '${greeting}' > '${greeting}-output.txt'
    """
}

एक बार यह हो जाए, workflow file से process definition delete करो, लेकिन shebang को जगह पर छोड़ना sure करो।

2.3. Workflow block से पहले include declaration add करें

Module से process include करने के लिए syntax काफी straightforward है:

Syntax: include declaration

include { <PROCESS_NAME> } from '<path_to_module>'

चलो इसे params block के ऊपर insert करते हैं और इसे appropriately fill out करते हैं।

AfterBefore

// Modules को include करें
include { sayHello } from './modules/sayHello.nf'

/*
* Pipeline पैरामीटर
*/
params {
    greeting: Path = 'data/greetings.csv'
    batch: String = 'batch'
}

/*
* Pipeline पैरामीटर
*/
params {
    greeting: Path = 'data/greetings.csv'
    batch: String = 'batch'
}

तुम देख सकते हो कि हमने process name, sayHello, और module code containing file का path, ./modules/sayHello.nf, fill in किया है।

2.4. Workflow चलाएं

हम पहले जैसे essentially same code और inputs के साथ workflow run कर रहे हैं, तो चलो -resume flag के साथ run करते हैं और देखते हैं क्या होता है।

nextflow run hello-modules.nf -resume

Command output

N E X T F L O W   ~  version 25.10.2

Launching `hello-modules.nf` [romantic_poisson] DSL2 - revision: 96edfa9ad3

[f6/cc0107] sayHello (1)       | 3 of 3, cached: 3 ✔
[3c/4058ba] convertToUpper (2) | 3 of 3, cached: 3 ✔
[1a/bc5901] collectGreetings   | 1 of 1, cached: 1 ✔

यह बहुत जल्दी run होना चाहिए क्योंकि सब कुछ cached है। तुम चाहो तो published outputs check कर सकते हो।

Nextflow ने recognize किया कि यह अभी भी same work है, भले ही code multiple files में split हो।

सीख

तुम जानते हो कि process को local module में extract कैसे करें और तुम जानते हो कि ऐसा करना workflow की resumability break नहीं करता।

आगे क्या?

More modules बनाने की practice करो। एक बार तुमने एक बना लिया, तो तुम एक million और बना सकते हो... लेकिन चलो अभी बस दो और बनाते हैं।

---

3. convertToUpper() process को modularize करें

3.1. New module के लिए file stub बनाएं

convertToUpper.nf नामक module के लिए एक empty file बनाओ।

touch modules/convertToUpper.nf

3.2. convertToUpper process code को module file में move करें

Workflow file से पूरी process definition को module file में copy करो, #!/usr/bin/env nextflow shebang भी copy करना sure करो।

#!/usr/bin/env nextflow

/*
 * अभिवादन को uppercase में बदलने के लिए text replacement tool का उपयोग करें
 */
process convertToUpper {

    input:
    path input_file

    output:
    path "UPPER-${input_file}"

    script:
    """
    cat '${input_file}' | tr '[a-z]' '[A-Z]' > 'UPPER-${input_file}'
    """
}

एक बार यह हो जाए, workflow file से process definition delete करो, लेकिन shebang को जगह पर छोड़ना sure करो।

3.3. params block से पहले include declaration add करें

params block के ऊपर include declaration insert करो और इसे appropriately fill out करो।

AfterBefore

// Modules को include करें
include { sayHello } from './modules/sayHello.nf'
include { convertToUpper } from './modules/convertToUpper.nf'

/*
* Pipeline पैरामीटर
*/
params {
    greeting: Path = 'data/greetings.csv'
    batch: String = 'batch'
}

// Modules को include करें
include { sayHello } from './modules/sayHello.nf'

/*
* Pipeline पैरामीटर
*/
params {
    greeting: Path = 'data/greetings.csv'
    batch: String = 'batch'
}

यह बहुत familiar लगने लगना चाहिए।

3.4. Workflow फिर से चलाएं

इसे -resume flag के साथ run करो।

nextflow run hello-modules.nf -resume

Command output

N E X T F L O W   ~  version 25.10.2

Launching `hello-modules.nf` [nauseous_heisenberg] DSL2 - revision: a04a9f2da0

[c9/763d42] sayHello (3)       | 3 of 3, cached: 3 ✔
[60/bc6831] convertToUpper (3) | 3 of 3, cached: 3 ✔
[1a/bc5901] collectGreetings   | 1 of 1, cached: 1 ✔

यह अभी भी पहले की तरह same output produce करना चाहिए।

दो हो गए, एक और बचा!

---

4. collectGreetings() process को modularize करें

4.1. New module के लिए file stub बनाएं

collectGreetings.nf नामक module के लिए एक empty file बनाओ।

touch modules/collectGreetings.nf

4.2. collectGreetings process code को module file में move करें

Workflow file से पूरी process definition को module file में copy करो, #!/usr/bin/env nextflow shebang भी copy करना sure करो।

#!/usr/bin/env nextflow

/*
 * Uppercase अभिवादनों को एक single output फ़ाइल में collect करें
 */
process collectGreetings {

    input:
    path input_files
    val batch_name

    output:
    path "COLLECTED-${batch_name}-output.txt", emit: outfile
    path "${batch_name}-report.txt", emit: report

    script:
    count_greetings = input_files.size()
    """
    cat ${input_files} > 'COLLECTED-${batch_name}-output.txt'
    echo 'There were ${count_greetings} greetings in this batch.' > '${batch_name}-report.txt'
    """
}

एक बार यह हो जाए, workflow file से process definition delete करो, लेकिन shebang को जगह पर छोड़ना sure करो।

4.3. params block से पहले include declaration add करें

params block के ऊपर include declaration insert करो और इसे appropriately fill out करो।

AfterBefore

// Modules को include करें
include { sayHello } from './modules/sayHello.nf'
include { convertToUpper } from './modules/convertToUpper.nf'
include { collectGreetings } from './modules/collectGreetings.nf'

/*
* Pipeline पैरामीटर
*/
params {
    greeting: Path = 'data/greetings.csv'
    batch: String = 'batch'
}

// Modules को include करें
include { sayHello } from './modules/sayHello.nf'
include { convertToUpper } from './modules/convertToUpper.nf'

/*
* Pipeline पैरामीटर
*/
params {
    greeting: Path = 'data/greetings.csv'
    batch: String = 'batch'
}

आखिरी वाला!

4.4. Workflow चलाएं

इसे -resume flag के साथ run करो।

nextflow run hello-modules.nf -resume

Command output

N E X T F L O W   ~  version 25.10.2

Launching `hello-modules.nf` [friendly_coulomb] DSL2 - revision: 7aa2b9bc0f

[f6/cc0107] sayHello (1)       | 3 of 3, cached: 3 ✔
[3c/4058ba] convertToUpper (2) | 3 of 3, cached: 3 ✔
[1a/bc5901] collectGreetings   | 1 of 1, cached: 1 ✔

यह अभी भी पहले की तरह same output produce करना चाहिए।

सीख

तुम जानते हो कि workflow में multiple processes को modularize कैसे करें।

बधाई हो, तुमने यह सारा काम किया और pipeline कैसे काम करती है उसमें absolutely कुछ भी नहीं बदला!

Jokes aside, अब तुम्हारा code अधिक modular है, और यदि तुम एक और pipeline लिखने का decide करते हो जो उन processes में से किसी को call करती है, तुम्हें relevant module use करने के लिए बस एक short include statement type करना होगा। यह code copy-paste करने से better है, क्योंकि यदि बाद में तुम module को improve करने का decide करते हो, तुम्हारी सभी pipelines improvements inherit करेंगी।

आगे क्या?

यदि तुम चाहो तो थोड़ा ब्रेक लो।

जब तुम ready हो, तो Part 5: Hello Containers पर move करो यह सीखने के लिए कि software dependencies को अधिक conveniently और reproducibly manage करने के लिए containers कैसे use करें।

---

Quiz

#

Nextflow में module क्या है?

एक configuration file

Single process definitions contain कर सकने वाली एक standalone file

एक workflow definition

एक channel operator

और जानें: 2. Create a module for sayHello()

#

Module files store करने के लिए आम तौर पर कौन सा convention use होता है?

Workflow के same directory में

bin/ directory में

modules/ directory में

lib/ directory में

और जानें: 1. Create a directory to store modules

#

Module use करने के लिए correct syntax क्या है?

import { SAYHELLO } from './modules/sayhello.nf'

require { SAYHELLO } from './modules/sayhello.nf'

include { SAYHELLO } from './modules/sayhello.nf'

load { SAYHELLO } from './modules/sayhello.nf'

और जानें: 2.3. Add an include declaration

#

Modules use करने पर -resume functionality का क्या होता है?

यह अब काम नहीं करती

इसे additional configuration की need होती है

यह पहले जैसी ही काम करती है

यह केवल local modules के लिए काम करती है

#

Modules use करने के benefits क्या हैं? (सभी लागू select करें)

Workflows में code reusability

आसान maintenance

Workflow code का बेहतर organization

तेज़ execution speed

जमा करें