वर्कफ़्लो के वर्कफ़्लो¶

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

जब तुम एक पाइपलाइन विकसित कर रहे होते हो, तो अक्सर तुम खुद को अलग-अलग डेटा प्रकारों या विश्लेषण चरणों के लिए प्रोसेस के समान अनुक्रम बनाते हुए पाते हो। तुम इन प्रोसेस अनुक्रमों को कॉपी-पेस्ट करते रह सकते हो, जिससे डुप्लीकेट कोड बन जाता है जिसे बनाए रखना मुश्किल होता है; या तुम एक विशाल वर्कफ़्लो बना सकते हो जिसे समझना और बदलना कठिन हो।

Nextflow की सबसे शक्तिशाली विशेषताओं में से एक है छोटे, पुन: उपयोग योग्य वर्कफ़्लो मॉड्यूल से जटिल पाइपलाइन बनाने की क्षमता। यह मॉड्यूलर दृष्टिकोण पाइपलाइन को विकसित करना, परीक्षण करना और बनाए रखना आसान बनाता है।

सीखने के लक्ष्य¶

इस साइड क्वेस्ट में, हम यह जानेंगे कि वर्कफ़्लो मॉड्यूल कैसे विकसित करें जिन्हें अलग से परीक्षण और उपयोग किया जा सके, उन मॉड्यूल को एक बड़ी पाइपलाइन में कैसे जोड़ें, और मॉड्यूल के बीच डेटा प्रवाह कैसे प्रबंधित करें।

इस साइड क्वेस्ट के अंत तक, तुम यह कर पाओगे:

जटिल पाइपलाइन को तार्किक, पुन: उपयोग योग्य इकाइयों में विभाजित करना
प्रत्येक वर्कफ़्लो मॉड्यूल को स्वतंत्र रूप से परीक्षण करना
नई पाइपलाइन बनाने के लिए वर्कफ़्लो को मिलाना और मिलान करना
विभिन्न पाइपलाइन में सामान्य वर्कफ़्लो मॉड्यूल साझा करना
अपने कोड को अधिक रखरखाव योग्य और समझने में आसान बनाना

ये कौशल तुम्हें स्वच्छ, रखरखाव योग्य कोड संरचना बनाए रखते हुए जटिल पाइपलाइन बनाने में मदद करेंगे।

पूर्वापेक्षाएँ¶

इस साइड क्वेस्ट को शुरू करने से पहले तुम्हें:

Hello Nextflow ट्यूटोरियल या समकक्ष शुरुआती कोर्स पूरा करना चाहिए।
बुनियादी Nextflow अवधारणाओं और तंत्रों (प्रोसेस, चैनल, ऑपरेटर, मॉड्यूल) का उपयोग करने में सहज होना चाहिए।

0. शुरू करना¶

ट्रेनिंग codespace खोलो¶

अगर तुमने अभी तक नहीं किया है, तो Environment Setup में बताए अनुसार ट्रेनिंग वातावरण खोलना सुनिश्चित करो।

प्रोजेक्ट डायरेक्टरी में जाओ¶

उस डायरेक्टरी में जाओ जहाँ इस ट्यूटोरियल की फ़ाइलें हैं।

cd side-quests/workflows_of_workflows

तुम VSCode को इस डायरेक्टरी पर फ़ोकस करने के लिए सेट कर सकते हो:

code .

एडिटर प्रोजेक्ट डायरेक्टरी पर फ़ोकस के साथ खुलता है।

सामग्री की समीक्षा करो¶

तुम्हें एक modules डायरेक्टरी मिलेगी जिसमें प्रोसेस परिभाषाएँ हैं, एक workflows डायरेक्टरी जिसमें दो पहले से लिखे गए वर्कफ़्लो स्क्रिप्ट हैं, और एक main.nf फ़ाइल जिसे तुम धीरे-धीरे अपडेट करोगे:

Directory contents

├── main.nf
├── workflows/
│   ├── greeting.nf              # Standalone greeting workflow (to be made composable)
│   └── transform.nf             # Standalone transform workflow (to be made composable)
└── modules/
    ├── say_hello.nf             # Creates a greeting (from Hello Nextflow)
    ├── say_hello_upper.nf       # Converts to uppercase (from Hello Nextflow)
    ├── timestamp_greeting.nf    # Adds timestamps to greetings
    ├── validate_name.nf         # Validates input names
    └── reverse_text.nf          # Reverses text content

modules/ डायरेक्टरी में अलग-अलग प्रोसेस परिभाषाएँ हैं, और workflows/ डायरेक्टरी में दो पहले से लिखे गए वर्कफ़्लो स्क्रिप्ट हैं जिन पर तुम इस साइड क्वेस्ट में काम करोगे।

असाइनमेंट की समीक्षा करो¶

तुम्हारी चुनौती इन मॉड्यूल को दो अलग वर्कफ़्लो में जोड़ना है जिन्हें हम फिर एक मुख्य वर्कफ़्लो में जोड़ेंगे:

एक GREETING_WORKFLOW जो नामों को सत्यापित करता है, अभिवादन बनाता है, और टाइमस्टैम्प जोड़ता है
एक TRANSFORM_WORKFLOW जो टेक्स्ट को अपरकेस में बदलता है और उसे उलटता है

पूरी पाइपलाइन दोनों वर्कफ़्लो को एक डेटा प्रवाह में जोड़ती है:

Validate: जाँचो कि प्रत्येक नाम सही तरह से बना है
Greet: प्रत्येक वैध नाम के लिए एक अभिवादन बनाओ
Timestamp: रिकॉर्ड करो कि प्रत्येक अभिवादन कब बनाया गया
Uppercase: टाइमस्टैम्प वाले अभिवादन को अपरकेस में बदलो
Reverse: अपरकेस टेक्स्ट को उलटो

पहले तीन चरण GREETING_WORKFLOW के हैं, और अंतिम दो TRANSFORM_WORKFLOW के। उन्हें अलग, composable वर्कफ़्लो के रूप में बनाने से तुम प्रत्येक चरण को स्वतंत्र रूप से विकसित और परीक्षण कर सकते हो, इससे पहले कि उन्हें एक साथ जोड़ो।

तैयारी की जाँच सूची¶

क्या तुम शुरू करने के लिए तैयार हो?

मैं इस कोर्स का लक्ष्य और इसकी पूर्वापेक्षाएँ समझता/समझती हूँ
मेरा codespace चल रहा है
मैंने अपनी वर्किंग डायरेक्टरी उचित रूप से सेट की है
मैं असाइनमेंट समझता/समझती हूँ

अगर तुम सभी बॉक्स चेक कर सकते हो, तो तुम जाने के लिए तैयार हो।

1. Greeting Workflow को पाइपलाइन में जोड़ो¶

Greeting वर्कफ़्लो नामों को सत्यापित करता है और टाइमस्टैम्प वाले अभिवादन उत्पन्न करता है।

1.1. Greeting Workflow की समीक्षा करो और चलाओ¶

workflows/greeting.nf खोलो और कोड देखो:

workflows/greeting.nf
#!/usr/bin/env nextflow

include { VALIDATE_NAME } from '../modules/validate_name'
include { SAY_HELLO } from '../modules/say_hello'
include { TIMESTAMP_GREETING } from '../modules/timestamp_greeting'

workflow {
    main:
    names_ch = channel.of('Alice', 'Bob', 'Charlie')

    // प्रोसेस को जंजीर में जोड़ो: सत्यापित करो -> अभिवादन बनाओ -> टाइमस्टैम्प जोड़ो
    validated_ch = VALIDATE_NAME(names_ch)
    greetings_ch = SAY_HELLO(validated_ch)
    timestamped_ch = TIMESTAMP_GREETING(greetings_ch)

    publish:
    greetings = greetings_ch
    timestamped = timestamped_ch
}

output {
    greetings {
    }
    timestamped {
    }
}

यह एक पूर्ण, स्व-निहित वर्कफ़्लो है जिसकी संरचना 'Hello Nextflow' ट्यूटोरियल में देखी गई संरचनाओं के समान है। यह इनपुट नामों को hardcode करता है, तीन प्रोसेस को जंजीर में जोड़ता है, और दो आउटपुट publish करता है।

इसे चलाकर सत्यापित करो कि सब कुछ काम करता है:

nextflow run workflows/greeting.nf

कमांड आउटपुट

N E X T F L O W   ~  version 26.04.4
Launching `workflows/greeting.nf` [sharp_kirch] revision: 04c0a33f79
executor >  local (9)
[c5/9df3c8] VAL…TE_NAME (validating Alice) | 3 of 3 ✔
[e0/243874] SAY_HELLO (greeting Alice)     | 3 of 3 ✔
[c5/e40c8d] TIM…ing timestamp to greeting) | 3 of 3 ✔

Outputs:

  /workspaces/training/side-quests/workflows_of_workflows/results

  greetings:
    - Charlie-output.txt
    - Bob-output.txt
    - Alice-output.txt

  timestamped:
    - timestamped_Bob-output.txt
    - timestamped_Charlie-output.txt
    - timestamped_Alice-output.txt

इसे अन्य वर्कफ़्लो के साथ composable बनाने के लिए, कुछ चीज़ें बदलनी होंगी।

1.2. वर्कफ़्लो को composable बनाओ¶

एक वर्कफ़्लो को composable बनाने के लिए, तीन चीज़ें बदलनी होती हैं: वर्कफ़्लो को एक नाम मिलता है, इनपुट take: ब्लॉक में जाते हैं, और आउटपुट emit: ब्लॉक में जाते हैं (standalone publish:/output {} ब्लॉक की जगह, जो entry workflow में होने चाहिए)।

निम्नलिखित अनुभाग इन बदलावों को एक-एक करके कवर करते हैं।

1.2.1. वर्कफ़्लो को नाम दो¶

वर्कफ़्लो को एक नाम दो ताकि इसे parent workflow से import किया जा सके।

बाद मेंपहले

workflows/greeting.nf
workflow GREETING_WORKFLOW {

workflows/greeting.nf
workflow {

नाम के साथ, वर्कफ़्लो को अन्य स्क्रिप्ट में import किया जा सकता है।

1.2.2. `take:` के साथ इनपुट घोषित करो¶

Hardcoded चैनल घोषणा को एक take: ब्लॉक से बदलो जो घोषित करे कि वर्कफ़्लो किन इनपुट की अपेक्षा करता है। take: ब्लॉक main: से पहले जाता है, और names_ch = channel.of(...) लाइन हटा दी जाती है।

बाद मेंपहले

workflows/greeting.nf
workflow GREETING_WORKFLOW {
    take:
    names_ch // नामों के साथ इनपुट चैनल

    main:
    // प्रोसेस को जंजीर में जोड़ो: सत्यापित करो -> अभिवादन बनाओ -> टाइमस्टैम्प जोड़ो
    validated_ch = VALIDATE_NAME(names_ch)
    greetings_ch = SAY_HELLO(validated_ch)
    timestamped_ch = TIMESTAMP_GREETING(greetings_ch)

workflows/greeting.nf
workflow GREETING_WORKFLOW {
    main:
    names_ch = channel.of('Alice', 'Bob', 'Charlie')

    // प्रोसेस को जंजीर में जोड़ो: सत्यापित करो -> अभिवादन बनाओ -> टाइमस्टैम्प जोड़ो
    validated_ch = VALIDATE_NAME(names_ch)
    greetings_ch = SAY_HELLO(validated_ch)
    timestamped_ch = TIMESTAMP_GREETING(greetings_ch)

take: ब्लॉक केवल नाम से चैनल घोषित करता है। Parent workflow परिभाषित करता है कि इसमें क्या जाएगा।

1.2.3. `emit:` के साथ आउटपुट घोषित करो¶

publish: सेक्शन को हटाओ और output {} ब्लॉक को भी हटाओ, उन्हें एक emit: ब्लॉक से बदलो जो आउटपुट को नाम दे।

बाद मेंपहले

workflows/greeting.nf
    emit:
    greetings = greetings_ch // मूल अभिवादन
    timestamped = timestamped_ch // टाइमस्टैम्प वाले अभिवादन
}

workflows/greeting.nf
    publish:
    greetings = greetings_ch
    timestamped = timestamped_ch
}

output {
    greetings {
    }
    timestamped {
    }
}

emit: ब्लॉक नामित आउटपुट उजागर करता है जिन्हें parent workflow GREETING_WORKFLOW.out.greetings और GREETING_WORKFLOW.out.timestamped के माध्यम से एक्सेस कर सकते हैं।

1.2.4. परिणाम सत्यापित करो और परीक्षण करो¶

तीनों बदलावों के बाद, पूरी फ़ाइल इस तरह दिखनी चाहिए:

workflows/greeting.nf
#!/usr/bin/env nextflow

include { VALIDATE_NAME } from '../modules/validate_name'
include { SAY_HELLO } from '../modules/say_hello'
include { TIMESTAMP_GREETING } from '../modules/timestamp_greeting'

workflow GREETING_WORKFLOW {
    take:
    names_ch // नामों के साथ इनपुट चैनल

    main:
    // प्रोसेस को जंजीर में जोड़ो: सत्यापित करो -> अभिवादन बनाओ -> टाइमस्टैम्प जोड़ो
    validated_ch = VALIDATE_NAME(names_ch)
    greetings_ch = SAY_HELLO(validated_ch)
    timestamped_ch = TIMESTAMP_GREETING(greetings_ch)

    emit:
    greetings = greetings_ch // मूल अभिवादन
    timestamped = timestamped_ch // टाइमस्टैम्प वाले अभिवादन
}

अब इसे सीधे चलाने की कोशिश करो:

nextflow run workflows/greeting.nf

कमांड आउटपुट

N E X T F L O W   ~  version 26.04.4
Launching `workflows/greeting.nf` [intergalactic_leavitt] revision: 89ac88c6c2
No entry workflow specified

यह एक महत्वपूर्ण अवधारणा का परिचय देता है: entry workflow। Nextflow एक बिना नाम वाले workflow {} ब्लॉक को entry point के रूप में उपयोग करता है जब तुम किसी स्क्रिप्ट को सीधे चलाते हो। GREETING_WORKFLOW का नाम है, इसलिए Nextflow नहीं जानता कि इसे अपने आप कैसे चलाएं।

यह जानबूझकर है। Composable वर्कफ़्लो को entry workflow से कॉल किए जाने के लिए डिज़ाइन किया गया है, सीधे चलाने के लिए नहीं। समाधान यह है कि main.nf में एक entry workflow बनाई जाए जो GREETING_WORKFLOW को import और कॉल करे।

1.3. मुख्य वर्कफ़्लो अपडेट करो और परीक्षण करो¶

अब मुख्य वर्कफ़्लो को greeting वर्कफ़्लो कॉल करने के लिए अपडेट करो।

1.3.1. Greeting Workflow को include करो और कॉल करो¶

include स्टेटमेंट जोड़ो, वर्कफ़्लो बॉडी को GREETING_WORKFLOW कॉल करने के लिए अपडेट करो और publish: में channel.empty() placeholder को बदलो:

बाद मेंपहले

main.nf
#!/usr/bin/env nextflow

include { GREETING_WORKFLOW } from './workflows/greeting'

workflow {
    main:
    names = channel.of('Alice', 'Bob', 'Charlie')

    // greeting वर्कफ़्लो चलाओ
    GREETING_WORKFLOW(names)

    publish:
    greetings = GREETING_WORKFLOW.out.greetings
}

main.nf
#!/usr/bin/env nextflow

workflow {
    main:
    names = channel.of('Alice', 'Bob', 'Charlie')

    publish:
    greetings = channel.empty()
}

Entry workflow बिना नाम का रहता है ताकि Nextflow इसे पाइपलाइन entry point के रूप में उपयोग करे।

1.3.2. Output ब्लॉक अपडेट करो¶

Published greetings को greetings/ सबडायरेक्टरी में रूट करने के लिए path निर्देश जोड़ो:

बाद मेंपहले

main.nf
output {
    greetings {
        path 'greetings'
    }
}

main.nf
output {
    greetings {
    }
}

1.3.3. वर्कफ़्लो चलाओ¶

वर्कफ़्लो चलाओ और परीक्षण करो कि यह काम करता है:

nextflow run main.nf

कमांड आउटपुट

N E X T F L O W   ~  version 26.04.4
Launching `main.nf` [agitated_jones] revision: 6b0e98dd05
executor >  local (9)
[00/5ac4ce] GRE…DATE_NAME (validating Bob) | 3 of 3 ✔
[7d/dde45c] GRE…SAY_HELLO (greeting Alice) | 3 of 3 ✔
[fd/a044cc] GRE…ing timestamp to greeting) | 3 of 3 ✔

Outputs:

  /workspaces/training/side-quests/workflows_of_workflows/results

  greetings:
    - greetings/Bob-output.txt
    - greetings/Charlie-output.txt
    - greetings/Alice-output.txt

results/ के अंतर्गत नई सामग्री जोड़ी गई

results/
└── greetings
    ├── Alice-output.txt
    ├── Bob-output.txt
    └── Charlie-output.txt

सेक्शन 1.1 के standalone रन की छह फ़ाइलें (Alice-output.txt, timestamped_Alice-output.txt, आदि) अभी भी इस नई greetings/ सबडायरेक्टरी के साथ results/ में मौजूद हैं। यह अपेक्षित है: इस पाठ में कुछ भी उन्हें नहीं हटाता, और सेक्शन 2.1 उन्हें सीधे अपने इनपुट के रूप में पढ़ता है।

फ़ाइल सामग्री

results/greetings/Alice-output.txt

Hello, Alice!

Greeting फ़ाइलें results/greetings/ में publish होती हैं। मुख्य वर्कफ़्लो GREETING_WORKFLOW को कॉल करता है और इसके आउटपुट को सीधे publish: सेक्शन से जोड़ता है।

GREETING_WORKFLOW.out.timestamped यहाँ publish: से नहीं जुड़ा है। सेक्शन 2 से शुरू होकर, वह चैनल TRANSFORM_WORKFLOW का इनपुट बन जाता है, न कि अपने आप में एक published आउटपुट। इसकी तुलना सेक्शन 1.1 के standalone रन से करो, जहाँ timestamped को feed करने के लिए कुछ और नहीं था, इसलिए इसे सीधे publish किया गया था।

सारांश¶

इस अनुभाग में, तुमने कई महत्वपूर्ण अवधारणाएँ सीखी हैं:

Named Workflows: एक नामित वर्कफ़्लो (GREETING_WORKFLOW) बनाना जिसे import और पुन: उपयोग किया जा सके
Workflow Interfaces: एक composable वर्कफ़्लो बनाने के लिए take: के साथ स्पष्ट इनपुट और emit: के साथ आउटपुट परिभाषित करना
Entry Points: यह समझना कि Nextflow को स्क्रिप्ट चलाने के लिए एक बिना नाम वाले entry workflow की आवश्यकता है
Workflow Composition: किसी अन्य वर्कफ़्लो के भीतर एक नामित वर्कफ़्लो को import और उपयोग करना
Workflow Namespaces: .out namespace (GREETING_WORKFLOW.out.greetings) का उपयोग करके वर्कफ़्लो आउटपुट तक पहुँचना

अब तुम्हारे पास एक काम करने वाला greeting वर्कफ़्लो है जो:

इनपुट के रूप में नामों का एक चैनल लेता है
प्रत्येक नाम को सत्यापित करता है
प्रत्येक वैध नाम के लिए एक अभिवादन बनाता है
अभिवादन में टाइमस्टैम्प जोड़ता है
मूल और टाइमस्टैम्प वाले दोनों अभिवादन emit करता है, हालाँकि इस चरण में केवल मूल अभिवादन results/ में publish होते हैं

यह मॉड्यूलर दृष्टिकोण तुम्हें greeting वर्कफ़्लो को स्वतंत्र रूप से परीक्षण करने या बड़ी पाइपलाइन में एक घटक के रूप में उपयोग करने की अनुमति देता है।

2. Transformation Workflow को पाइपलाइन में जोड़ो¶

Transform वर्कफ़्लो टाइमस्टैम्प वाले अभिवादन पर टेक्स्ट परिवर्तन लागू करता है।

2.1. वर्कफ़्लो की समीक्षा करो और चलाओ¶

workflows/transform.nf खोलो और कोड देखो:

workflows/transform.nf
#!/usr/bin/env nextflow

include { SAY_HELLO_UPPER } from '../modules/say_hello_upper'
include { REVERSE_TEXT } from '../modules/reverse_text'

workflow {
    main:
    input_ch = channel.fromPath('results/timestamped_*.txt')

    // क्रम में परिवर्तन लागू करो
    upper_ch = SAY_HELLO_UPPER(input_ch)
    reversed_ch = REVERSE_TEXT(upper_ch)

    publish:
    upper = upper_ch
    reversed = reversed_ch
}

output {
    upper {
    }
    reversed {
    }
}

यह standalone वर्कफ़्लो greeting.nf द्वारा उत्पन्न results/ डायरेक्टरी से टाइमस्टैम्प वाली greeting फ़ाइलें पढ़ता है, उन्हें अपरकेस में बदलता है, फिर टेक्स्ट को उलटता है।

इसे चलाकर सत्यापित करो कि यह सेक्शन 1.1 के greeting परिणामों के साथ काम करता है:

nextflow run workflows/transform.nf

कमांड आउटपुट

N E X T F L O W   ~  version 26.04.4
Launching `workflows/transform.nf` [evil_meninsky] revision: 4e35790d32
executor >  local (6)
[7d/4ed7de] SAY…estamped_Alice-output.txt) | 3 of 3 ✔
[70/ddaafa] REV…imestamped_Bob-output.txt) | 3 of 3 ✔

Outputs:

  /workspaces/training/side-quests/workflows_of_workflows/results

  upper:
    - UPPER-timestamped_Bob-output.txt
    - UPPER-timestamped_Charlie-output.txt
    - UPPER-timestamped_Alice-output.txt

  reversed:
    - REVERSED-UPPER-timestamped_Charlie-output.txt
    - REVERSED-UPPER-timestamped_Alice-output.txt
    - REVERSED-UPPER-timestamped_Bob-output.txt

इसे GREETING_WORKFLOW के साथ composable बनाने के लिए, सेक्शन 1.2 के समान तीन बदलाव लागू होते हैं।

2.2. इसे composable बनाओ¶

सेक्शन 1.2 के समान तीन बदलाव लागू करो: वर्कफ़्लो को नाम दो, hardcoded इनपुट को take: से बदलो, और publish:/output {} को emit: से बदलो।

पूरी फ़ाइल इस तरह दिखनी चाहिए:

workflows/transform.nf
#!/usr/bin/env nextflow

include { SAY_HELLO_UPPER } from '../modules/say_hello_upper'
include { REVERSE_TEXT } from '../modules/reverse_text'

workflow TRANSFORM_WORKFLOW {
    take:
    input_ch // अभिवादन के साथ इनपुट चैनल

    main:
    // क्रम में परिवर्तन लागू करो
    upper_ch = SAY_HELLO_UPPER(input_ch)
    reversed_ch = REVERSE_TEXT(upper_ch)

    emit:
    upper = upper_ch // अपरकेस अभिवादन
    reversed = reversed_ch // उलटे अपरकेस अभिवादन
}

Transform वर्कफ़्लो अब composable है और मुख्य वर्कफ़्लो में import होने के लिए तैयार है।

2.3. मुख्य वर्कफ़्लो अपडेट करो और परीक्षण करो¶

अब मुख्य वर्कफ़्लो को transformation वर्कफ़्लो कॉल करने के लिए अपडेट करो।

2.3.1. Transformation Workflow को include करो और कॉल करो¶

Include स्टेटमेंट जोड़ो, टाइमस्टैम्प वाले अभिवादन पर chained TRANSFORM_WORKFLOW कॉल जोड़ो, और दो नए publish: एंट्री जोड़ो:

बाद मेंपहले

main.nf
#!/usr/bin/env nextflow

include { GREETING_WORKFLOW } from './workflows/greeting'
include { TRANSFORM_WORKFLOW } from './workflows/transform'

workflow {
    main:
    names = channel.of('Alice', 'Bob', 'Charlie')

    // greeting वर्कफ़्लो चलाओ
    GREETING_WORKFLOW(names)

    // transform वर्कफ़्लो चलाओ
    TRANSFORM_WORKFLOW(GREETING_WORKFLOW.out.timestamped)

    publish:
    greetings = GREETING_WORKFLOW.out.greetings
    upper = TRANSFORM_WORKFLOW.out.upper
    reversed = TRANSFORM_WORKFLOW.out.reversed
}

main.nf
#!/usr/bin/env nextflow

include { GREETING_WORKFLOW } from './workflows/greeting'

workflow {
    main:
    names = channel.of('Alice', 'Bob', 'Charlie')

    // greeting वर्कफ़्लो चलाओ
    GREETING_WORKFLOW(names)

    publish:
    greetings = GREETING_WORKFLOW.out.greetings
}

यह टाइमस्टैम्प वाले अभिवादन पर transformation वर्कफ़्लो चलाएगा।

2.3.2. Output ब्लॉक अपडेट करो¶

output {} ब्लॉक में upper और reversed एंट्री जोड़ो, प्रत्येक के लिए अपनी सबडायरेक्टरी के साथ path निर्देश:

बाद मेंपहले

main.nf
output {
    greetings {
        path 'greetings'
    }
    upper {
        path 'upper'
    }
    reversed {
        path 'reversed'
    }
}

main.nf
output {
    greetings {
        path 'greetings'
    }
}

यह अंतिम आउटपुट को उचित डायरेक्टरी में publish करेगा।

2.3.3. पूरी पाइपलाइन चलाओ¶

पाइपलाइन चलाओ और परीक्षण करो कि सब कुछ काम करता है:

nextflow run main.nf

कमांड आउटपुट

N E X T F L O W   ~  version 26.04.4
Launching `main.nf` [special_magritte] revision: 2a0e54fecd
executor >  local (15)
[e7/e051a5] GRE…TE_NAME (validating Alice) | 3 of 3 ✔
[ca/cf1b18] GRE…SAY_HELLO (greeting Alice) | 3 of 3 ✔
[e5/aa6be2] GRE…ing timestamp to greeting) | 3 of 3 ✔
[d2/7afc88] TRA…imestamped_Bob-output.txt) | 3 of 3 ✔
[5b/70f190] TRA…estamped_Alice-output.txt) | 3 of 3 ✔

Outputs:

  /workspaces/training/side-quests/workflows_of_workflows/results

  greetings:
    - greetings/Bob-output.txt
    - greetings/Charlie-output.txt
    - greetings/Alice-output.txt

  upper:
    - upper/UPPER-timestamped_Charlie-output.txt
    - upper/UPPER-timestamped_Bob-output.txt
    - upper/UPPER-timestamped_Alice-output.txt

  reversed:
    - reversed/REVERSED-UPPER-timestamped_Charlie-output.txt
    - reversed/REVERSED-UPPER-timestamped_Bob-output.txt
    - reversed/REVERSED-UPPER-timestamped_Alice-output.txt

results/ के अंतर्गत नई सामग्री जोड़ी गई

results/
├── greetings
│   ├── Alice-output.txt
│   ├── Bob-output.txt
│   └── Charlie-output.txt
├── reversed
│   ├── REVERSED-UPPER-timestamped_Alice-output.txt
│   ├── REVERSED-UPPER-timestamped_Bob-output.txt
│   └── REVERSED-UPPER-timestamped_Charlie-output.txt
└── upper
    ├── UPPER-timestamped_Alice-output.txt
    ├── UPPER-timestamped_Bob-output.txt
    └── UPPER-timestamped_Charlie-output.txt

results/ रूट में सेक्शन 1.1 और 2.1 के standalone रन की बची हुई फ़ाइलें (Alice-output.txt, timestamped_Alice-output.txt, UPPER-timestamped_Alice-output.txt, आदि) भी अभी भी मौजूद हैं। यह अपेक्षित है: इस पाठ में कहीं भी उन्हें हटाने का निर्देश नहीं दिया गया है।

फ़ाइल सामग्री

results/reversed/REVERSED-UPPER-timestamped_Alice-output.txt

!ECILA ,OLLEH ]54:84:81 31-90-6202[

पाइपलाइन end-to-end काम कर रही है: अभिवादन को अपरकेस किया गया है और उलटा किया गया है।

सारांश¶

अब तुम्हारे पास एक पूर्ण पाइपलाइन होनी चाहिए जो:

greeting वर्कफ़्लो के माध्यम से नामों को प्रोसेस करती है
टाइमस्टैम्प वाले अभिवादन को transform वर्कफ़्लो में भेजती है
अभिवादन के अपरकेस और उलटे दोनों संस्करण उत्पन्न करती है

सारांश¶

इस साइड क्वेस्ट में, हमने Nextflow में वर्कफ़्लो composition की शक्तिशाली अवधारणा का पता लगाया है, जो हमें छोटे, पुन: उपयोग योग्य घटकों से जटिल पाइपलाइन बनाने की अनुमति देती है।

यह मॉड्यूलर दृष्टिकोण monolithic पाइपलाइन की तुलना में कई फायदे प्रदान करता है:

प्रत्येक वर्कफ़्लो को स्वतंत्र रूप से विकसित, परीक्षण और डीबग किया जा सकता है
वर्कफ़्लो को विभिन्न पाइपलाइन में पुन: उपयोग किया जा सकता है
समग्र पाइपलाइन संरचना अधिक पठनीय और रखरखाव योग्य बन जाती है
एक वर्कफ़्लो में बदलाव जरूरी नहीं कि दूसरों को प्रभावित करें यदि interfaces सुसंगत रहें
Entry points को तुम्हारी पाइपलाइन के विभिन्न हिस्सों को चलाने के लिए कॉन्फ़िगर किया जा सकता है

किसी वर्कफ़्लो को कॉल करना प्रोसेस को कॉल करने जैसा है, लेकिन यह वास्तव में एक जैसा नहीं है। तुम N आकार का चैनल पास करके किसी वर्कफ़्लो को N बार नहीं चला सकते: तुम चैनल एक बार पास करते हो और वर्कफ़्लो आंतरिक रूप से उस पर iterate करता है।

अपने काम में इन तकनीकों को लागू करने से तुम अधिक परिष्कृत Nextflow पाइपलाइन बना पाओगे जो जटिल डेटा प्रोसेसिंग कार्यों को संभाल सकती हैं और साथ ही रखरखाव योग्य और scalable भी रहती हैं।

मुख्य पैटर्न¶

Workflow structure: हमने take: और emit: सिंटैक्स का उपयोग करके प्रत्येक वर्कफ़्लो के लिए स्पष्ट इनपुट और आउटपुट परिभाषित किए, घटकों के बीच अच्छी तरह से परिभाषित interfaces बनाए, और वर्कफ़्लो लॉजिक को main: ब्लॉक के अंदर लपेटा।

workflow EXAMPLE_WORKFLOW {
    take:
    // इनपुट चैनल यहाँ घोषित किए जाते हैं
    input_ch

    main:
    // वर्कफ़्लो लॉजिक यहाँ जाता है
    // यहाँ प्रोसेस कॉल किए जाते हैं और चैनल manipulate किए जाते हैं
    result_ch = SOME_PROCESS(input_ch)

    emit:
    // आउटपुट चैनल यहाँ घोषित किए जाते हैं
    output_ch = result_ch
}

Workflow imports: हमने दो स्वतंत्र वर्कफ़्लो मॉड्यूल बनाए और उन्हें include statements के साथ एक मुख्य पाइपलाइन में import किया।
- एक वर्कफ़्लो include करो
```
include { WORKFLOW_NAME } from './path/to/workflow'
```
- कई वर्कफ़्लो include करो
```
include { WORKFLOW_A; WORKFLOW_B } from './path/to/workflows'
```
- नाम संघर्ष से बचने के लिए alias के साथ include करो
```
include { WORKFLOW_A as WORKFLOW_A_ALIAS } from './path/to/workflow'
```
Entry points: Nextflow को यह जानने के लिए एक बिना नाम वाले entry workflow की आवश्यकता है कि execution कहाँ से शुरू करनी है। यह entry workflow तुम्हारे नामित वर्कफ़्लो को कॉल करता है।
- बिना नाम वाला वर्कफ़्लो (entry point)
```
workflow {
    // स्क्रिप्ट चलाने पर यह entry point है
    NAMED_WORKFLOW(input_ch)
}
```
- नामित वर्कफ़्लो (entry workflow से कॉल किया जाता है)
```
workflow NAMED_WORKFLOW {
    // entry workflow से कॉल किया जाना चाहिए
}
```
Managing data flow: हमने सीखा कि namespace notation (WORKFLOW_NAME.out.channel_name) का उपयोग करके वर्कफ़्लो आउटपुट तक कैसे पहुँचें और उन्हें अन्य वर्कफ़्लो को कैसे पास करें।
```
WORKFLOW_A(input_ch)
WORKFLOW_B(WORKFLOW_A.out.some_channel)
```

अतिरिक्त संसाधन¶

आगे क्या है?¶

Side Quests के मेनू पर वापस जाओ या अगले विषय पर जाने के लिए पृष्ठ के नीचे दाईं ओर बटन पर क्लिक करो।

वर्कफ़्लो के वर्कफ़्लो¶

सीखने के लक्ष्य¶

पूर्वापेक्षाएँ¶

0. शुरू करना¶

ट्रेनिंग codespace खोलो¶

प्रोजेक्ट डायरेक्टरी में जाओ¶

सामग्री की समीक्षा करो¶

असाइनमेंट की समीक्षा करो¶

तैयारी की जाँच सूची¶

1. Greeting Workflow को पाइपलाइन में जोड़ो¶

1.1. Greeting Workflow की समीक्षा करो और चलाओ¶

1.2. वर्कफ़्लो को composable बनाओ¶

1.2.1. वर्कफ़्लो को नाम दो¶

1.2.2. take: के साथ इनपुट घोषित करो¶

1.2.3. emit: के साथ आउटपुट घोषित करो¶

1.2.4. परिणाम सत्यापित करो और परीक्षण करो¶

1.3. मुख्य वर्कफ़्लो अपडेट करो और परीक्षण करो¶

1.3.1. Greeting Workflow को include करो और कॉल करो¶

1.3.2. Output ब्लॉक अपडेट करो¶

1.3.3. वर्कफ़्लो चलाओ¶

सारांश¶

2. Transformation Workflow को पाइपलाइन में जोड़ो¶

2.1. वर्कफ़्लो की समीक्षा करो और चलाओ¶

2.2. इसे composable बनाओ¶

2.3. मुख्य वर्कफ़्लो अपडेट करो और परीक्षण करो¶

2.3.1. Transformation Workflow को include करो और कॉल करो¶

2.3.2. Output ब्लॉक अपडेट करो¶

2.3.3. पूरी पाइपलाइन चलाओ¶

सारांश¶

सारांश¶

मुख्य पैटर्न¶

अतिरिक्त संसाधन¶

आगे क्या है?¶

1.2.2. `take:` के साथ इनपुट घोषित करो¶

1.2.3. `emit:` के साथ आउटपुट घोषित करो¶