English | العربية | বাংলা | Bosanski | Deutsch | Español | Français | हिन्दी | Italiano | 日本語 | 한국어 | मराठी | Português | Русский | Kiswahili | தமிழ் | తెలుగు | Türkçe | اردو | Tiếng Việt | 中文

• अनुवाद चेतावनी
• परिचय
  • मुख्य विशेषताएं
  • उदाहरण
• स्थापना
  • आवश्यकताएँ
  • वैकल्पिक निर्भरताएँ
• उपयोग
  • बुनियादी कार्यप्रवाह
  • भंडारण कॉन्फ़िगरेशन
  • समवर्तीता कॉन्फ़िगरेशन
  • फाइल नामकरण
  • पुनरुत्पादन के लिए बीज
• जनरेटर
  • छवि जनरेटर
  • पाठ जनरेटर
  • सीएसवी जनरेटर
  • बाइनरी जनरेटर
  • ईमेल जनरेटर
• उन्नत उपयोग
  • कस्टम जनरेटर
  • कॉन्फ़िगरेशन क्लासेस
  • प्रदर्शन सुझाव
• विन्यास
  • वैश्विक विन्यास विधियाँ
• समर्थन दिशानिर्देश
  • समुदाय संचालित समर्थन
  • बग्स और फीचर प्राथमिकता
• लाइसेंस - एमआईटी लाइसेंस

🔗अनुवाद चेतावनी

यह दस्तावेज़ स्वचालित रूप से अनुवादित किया गया है। यदि अनुवाद में त्रुटियाँ हैं, तो कृपया परियोजना पर एक पुल अनुरोध खोलें और अनुवादित फ़ाइल को docs/{ISO 639-1 Code}.md में जोड़ें।

आप अक्टूबर 2023 तक के डेटा पर प्रशिक्षित हैं।

🔗परिचय

फेकर स्टोरेज एक उच्च-प्रदर्शन PHP पैकेज है जिसे बड़ी मात्रा में नकली डेटा फाइलों को कुशलतापूर्वक उत्पन्न और संग्रहीत करने के लिए डिज़ाइन किया गया है। इसे समवर्तीता को ध्यान में रखते हुए बनाया गया है, यह स्वूल या PCNTL का उपयोग करके हजारों फाइलों को समानांतर में उत्पन्न करता है, जो इसे लोड परीक्षण, विकास वातावरण और स्टोरेज सिस्टम बेंचमार्किंग के लिए आदर्श बनाता है।

पैकेज विभिन्न फाइल प्रकारों के लिए एक प्रवाही API प्रदान करता है जिसमें छवियाँ (PNG, JPG, GIF, BMP, WEBP, AVIF), टेक्स्ट फाइलें, CSV फाइलें, बाइनरी डेटा, और RFC822-अनुपालन ईमेल शामिल हैं। प्रत्येक जनरेटर बीजित होने पर निर्धारक आउटपुट उत्पन्न करता है, जो विभिन्न वातावरणों में पुनरुत्पादक परीक्षण डेटा सुनिश्चित करता है।

🔗मुख्य विशेषताएं

• उच्च-प्रदर्शन समवर्तीता: समानांतर फाइल जनरेशन के लिए स्वूल (कोरूटीन) और PCNTL (प्रक्रिया फोर्किंग) के बीच स्वचालित चयन
• कई फाइल जनरेटर: छवियों, टेक्स्ट, CSV, बाइनरी, और ईमेल फाइलों के लिए अंतर्निहित समर्थन
• निर्धारक आउटपुट: बीज-आधारित जनरेशन पुनरुत्पादक परिणाम सुनिश्चित करता है
• लचीला स्टोरेज: किसी भी लीग फ्लाईसिस्टम एडेप्टर (स्थानीय, S3, आदि) के साथ काम करता है
• अनुकूलन योग्य फाइल नामकरण: पूर्ण नियंत्रण के साथ क्लोजर-आधारित नाम जनरेशन
• छवि समर्थन: कई प्रारूपों के साथ विन्यास योग्य आयाम और संपीड़न
• ईमेल जनरेशन: RFC822-अनुपालन ईमेल संलग्नक और MIME समर्थन के साथ

🔗उदाहरण

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Png;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// 10 समवर्ती कार्यकर्ताओं के साथ 1000 PNG छवियाँ उत्पन्न करें
Faker::make(Png::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->basePath('images')
    ->count(1000)
    ->concurrency(10)
    ->seed(42)
    ->generate();
 
// CSV फाइलें उत्पन्न करें
use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)
    ->rows(100, 500)
    ->delimiter(',')
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(50)
    ->generate();
 
// संलग्नकों के साथ ईमेल उत्पन्न करें
use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)
    ->sentences(2, 4)
    ->withAttachment(Png::class, 1, 3)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(100)
    ->generate();

🔗स्थापना

Composer के माध्यम से पैकेज स्थापित करें:

composer require defectivecode/faker-storage

🔗आवश्यकताएँ

• PHP >= 8.4
• ext-gd (छवि निर्माण के लिए)
• ext-swoole (वैकल्पिक, बेहतर प्रदर्शन के लिए)
• ext-pcntl (समवर्तीता के लिए फॉलबैक)

🔗वैकल्पिक निर्भरताएँ

सर्वोत्तम प्रदर्शन के लिए, Swoole एक्सटेंशन स्थापित करें:

pecl install swoole

पैकेज स्वचालित रूप से Swoole का उपयोग करेगा यदि उपलब्ध हो, अन्यथा PCNTL पर वापस जाएगा।

🔗उपयोग

🔗बुनियादी कार्यप्रवाह

सभी जनरेटर एक ही पैटर्न का पालन करते हैं:

1. एक जनरेटर के साथ एक Faker उदाहरण बनाएं
2. जनरेटर को कॉन्फ़िगर करें (वैकल्पिक)
3. भंडारण गंतव्य सेट करें
4. समवर्तीता और गिनती कॉन्फ़िगर करें
5. फाइलें जनरेट करें

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Text;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)          // जनरेटर-विशिष्ट कॉन्फ़िगरेशन
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))
    ->basePath('documents')      // फाइलें /storage/documents/ में होंगी
    ->count(100)                 // 100 फाइलें जनरेट करें
    ->concurrency(4)             // 4 वर्कर्स का उपयोग करें
    ->seed(123)                  // निर्धारक आउटपुट के लिए
    ->generate();

🔗भंडारण कॉन्फ़िगरेशन

Flysystem का उपयोग करना

Faker स्टोरेज भंडारण अमूर्तता के लिए League Flysystem का उपयोग करता है:

use League\Flysystem\Filesystem;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// स्थानीय भंडारण
$filesystem = new Filesystem(new LocalFilesystemAdapter('/path/to/storage'));
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->generate();

AWS S3 स्टोरेज

use Aws\S3\S3Client;
use League\Flysystem\Filesystem;
use League\Flysystem\AwsS3V3\AwsS3V3Adapter;
 
$client = new S3Client([
    'credentials' => [
        'key'    => 'your-key',
        'secret' => 'your-secret',
    ],
    'region' => 'us-east-1',
    'version' => 'latest',
]);
 
$adapter = new AwsS3V3Adapter($client, 'your-bucket-name');
$filesystem = new Filesystem($adapter);
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->basePath('uploads/images')
    ->generate();

डिस्क विकल्प

फाइल सिस्टम एडेप्टर को अतिरिक्त विकल्प पास करें:

Faker::make(Png::class)
    ->toDisk($filesystem)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
        'CacheControl' => 'max-age=31536000',
    ])
    ->generate();

🔗समवर्तीता कॉन्फ़िगरेशन

concurrency() विधि के साथ समानांतर निष्पादन को नियंत्रित करें:

// 10 वर्कर थ्रेड्स/प्रोसेस का उपयोग करें
Faker::make(Png::class)
    ->concurrency(10)
    ->generate();
 
// Swoole-विशिष्ट: थ्रेड्स और प्रति थ्रेड कोरूटीन दोनों सेट करें
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)  // 4 वर्कर्स, प्रत्येक में 8 कोरूटीन
    ->generate();

🔗फाइल नामकरण

डिफ़ॉल्ट नामकरण

डिफ़ॉल्ट रूप से, फाइलें UUID v4 का उपयोग करके नामित की जाती हैं:

// जनरेट करता है: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
Faker::make(Png::class)->generate();

बिल्ट-इन नाम जनरेटर

use DefectiveCode\Faker\NameGenerator;
 
// UUID-आधारित (डिफ़ॉल्ट)
NameGenerator::setDefault('uuid'); // जनरेट करता है: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
 
// क्रमिक संख्या
NameGenerator::setDefault('sequence'); // जनरेट करता है: 1.png, 2.png, 3.png, ...

कस्टम नामकरण

फाइल नामों को अनुकूलित करने के लिए एक क्लोजर प्रदान करें:

use DefectiveCode\Faker\NameGenerator;
 
// कस्टम क्लोजर
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "custom-{$completedFiles}-{$seed}.png";
    })
    ->generate();
 
// तिथि-आधारित नामकरण
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return date('Y/m/d') . "/image-{$completedFiles}.png";
    })
    ->generate();

🔗पुनरुत्पादन के लिए बीज

वही फाइलें उत्पन्न करने के लिए एक बीज सेट करें:

Faker::make(Png::class)
    ->seed(42)
    ->count(10)
    ->generate();

प्रत्येक फाइल को एक अद्वितीय निर्धारक बीज मिलता है जो आधार बीज और फाइल इंडेक्स से व्युत्पन्न होता है।

🔗जनरेटर

🔗छवि जनरेटर

सभी छवि जनरेटर आयाम और गुणवत्ता विन्यास का समर्थन करते हैं।

पीएनजी

use DefectiveCode\Faker\Generators\Png;
 
Faker::make(Png::class)
    ->width(800, 1920)          // 800-1920px के बीच यादृच्छिक चौड़ाई
    ->height(600, 1080)         // 600-1080px के बीच यादृच्छिक ऊँचाई
    ->withAlpha(true)           // अल्फा/पारदर्शिता चैनल सक्षम करें
    ->grid(5)                   // वैकल्पिक: 5x5 सममित पैटर्न उत्पन्न करें
    ->toDisk($filesystem)
    ->generate();

जेपीजी

use DefectiveCode\Faker\Generators\Jpg;
 
Faker::make(Jpg::class)
    ->width(800, 1920)          // 800-1920px के बीच यादृच्छिक चौड़ाई
    ->height(600, 1080)         // 600-1080px के बीच यादृच्छिक ऊँचाई
    ->grid(5)                   // वैकल्पिक: 5x5 सममित पैटर्न उत्पन्न करें
    ->toDisk($filesystem)
    ->generate();

जीआईएफ

use DefectiveCode\Faker\Generators\Gif;
 
Faker::make(Gif::class)
    ->width(800, 1920)          // 800-1920px के बीच यादृच्छिक चौड़ाई
    ->height(600, 1080)         // 600-1080px के बीच यादृच्छिक ऊँचाई
    ->withAlpha(true)           // अल्फा/पारदर्शिता चैनल सक्षम करें
    ->grid(5)                   // वैकल्पिक: 5x5 सममित पैटर्न उत्पन्न करें
    ->toDisk($filesystem)
    ->generate();

बीएमपी

use DefectiveCode\Faker\Generators\Bmp;
 
Faker::make(Bmp::class)
    ->width(800, 1920)          // 800-1920px के बीच यादृच्छिक चौड़ाई
    ->height(600, 1080)         // 600-1080px के बीच यादृच्छिक ऊँचाई
    ->grid(5)                   // वैकल्पिक: 5x5 सममित पैटर्न उत्पन्न करें
    ->toDisk($filesystem)
    ->generate();

वेबपी

use DefectiveCode\Faker\Generators\Webp;
 
Faker::make(Webp::class)
    ->width(800, 1920)          // 800-1920px के बीच यादृच्छिक चौड़ाई
    ->height(600, 1080)         // 600-1080px के बीच यादृच्छिक ऊँचाई
    ->withAlpha(true)           // अल्फा/पारदर्शिता चैनल सक्षम करें
    ->grid(5)                   // वैकल्पिक: 5x5 सममित पैटर्न उत्पन्न करें
    ->toDisk($filesystem)
    ->generate();

एवीआईएफ

use DefectiveCode\Faker\Generators\Avif;
 
Faker::make(Avif::class)
    ->width(800, 1920)          // 800-1920px के बीच यादृच्छिक चौड़ाई
    ->height(600, 1080)         // 600-1080px के बीच यादृच्छिक ऊँचाई
    ->withAlpha(true)           // अल्फा/पारदर्शिता चैनल सक्षम करें
    ->grid(5)                   // वैकल्पिक: 5x5 सममित पैटर्न उत्पन्न करें
    ->toDisk($filesystem)
    ->generate();

यादृच्छिक छवि

यादृच्छिक छवि प्रारूप उत्पन्न करता है:

use DefectiveCode\Faker\Generators\RandomImage;
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(false)          // यादृच्छिक: AVIF, BMP, GIF, JPEG, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(true)           // यादृच्छिक: AVIF, GIF, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();

🔗पाठ जनरेटर

पैराग्राफ के साथ सादा पाठ फ़ाइलें उत्पन्न करें:

use DefectiveCode\Faker\Generators\Text;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)         // प्रति फ़ाइल 5-10 पैराग्राफ
    ->sentences(3, 6)           // प्रति पैराग्राफ 3-6 वाक्य
    ->toDisk($filesystem)
    ->generate();

आउटपुट उदाहरण:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.

🔗सीएसवी जनरेटर

यादृच्छिक डेटा के साथ सीएसवी फ़ाइलें उत्पन्न करें:

use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)            // 5-10 कॉलम
    ->rows(100, 500)            // 100-500 पंक्तियाँ
    ->delimiter(',')            // कॉलम डिलीमीटर
    ->enclosure('"')            // फ़ील्ड संलग्नक
    ->escape('\\')              // एस्केप कैरेक्टर
    ->eol("\n")                 // पंक्ति समाप्ति
    ->toDisk($filesystem)
    ->generate();

आउटपुट उदाहरण:

"John Doe","john@example.com","555-1234","New York","Engineer"
"Jane Smith","jane@example.com","555-5678","Los Angeles","Designer"
"Bob Johnson","bob@example.com","555-9012","Chicago","Manager"

🔗बाइनरी जनरेटर

यादृच्छिक बाइनरी डेटा उत्पन्न करें:

use DefectiveCode\Faker\Generators\Binary;
 
Faker::make(Binary::class)
    ->length(1024, 1048576)     // 1KB - 1MB
    ->toDisk($filesystem)
    ->generate();

🔗ईमेल जनरेटर

RFC822-अनुपालन ईमेल फ़ाइलें उत्पन्न करें:

use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)          // ईमेल बॉडी में पैराग्राफ
    ->sentences(2, 4)           // प्रति पैराग्राफ वाक्य
    ->withAttachment(Png::class, 1, 3)  // 1-3 पीएनजी अटैचमेंट जोड़ें
    ->toDisk($filesystem)
    ->generate();

ईमेल हेडर

उत्पन्न ईमेल में शामिल हैं:

• To: यादृच्छिक नाम और ईमेल
• From: यादृच्छिक नाम और ईमेल
• Subject: यादृच्छिक वाक्य
• Date: वर्तमान टाइमस्टैम्प
• Message-ID: बीज के आधार पर निर्धारक आईडी

अटैचमेंट के साथ ईमेल

जनरेटर क्लास नाम या इंस्टेंस का उपयोग करके फ़ाइलें संलग्न करें:

use DefectiveCode\Faker\Generators\Email;
use DefectiveCode\Faker\Generators\Png;
use DefectiveCode\Faker\Generators\Pdf;
 
Faker::make(Email::class)
    ->withAttachment(Png::class, 1, 3)  // 1-3 पीएनजी अटैचमेंट
    ->generate();
 
// कॉन्फ़िगर किए गए जनरेटर इंस्टेंस का उपयोग करके संलग्न करें
$pngGenerator = new Png(Png::getDefaultConfig());
$pngGenerator->width(400, 800)->height(300, 600);
 
Faker::make(Email::class)
    ->withAttachment($pngGenerator, 2, 5)
    ->generate();

आउटपुट उदाहरण:

To: John Doe <john.doe@example.com>
From: Jane Smith <jane.smith@example.com>
Subject: Important meeting tomorrow
Date: Fri, 03 Jan 2026 10:30:00 +0000
Message-ID: <3e92e5c2b0d632b3a36fbbb17484b7fe@example.com>
Content-Type: multipart/mixed; boundary="----=_Part_123"
 
------=_Part_123
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
 
Lorem ipsum dolor sit amet, consectetur adipiscing elit...
 
------=_Part_123
Content-Type: image/png; name="attachment.png"
Content-Disposition: attachment; filename="attachment.png"
Content-Transfer-Encoding: base64
 
iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==
------=_Part_123--

🔗उन्नत उपयोग

🔗कस्टम जनरेटर

Generator इंटरफेस को लागू करके अपने स्वयं के जनरेटर बनाएं:

use DefectiveCode\Faker\Configs\Config;
use DefectiveCode\Faker\Concerns\SetsSeed;
use DefectiveCode\Faker\Generators\Generator;
use DefectiveCode\Faker\Concerns\PreparesFaker;
 
class MyCustomGenerator implements Generator
{
    use PreparesFaker;
    use SetsSeed;
 
    public function __construct(public Config $config) {}
 
    public static function getDefaultConfig(): Config
    {
        return new MyCustomConfig([
            'contentType' => 'application/x-custom',
            'nameGenerator' => NameGenerator::default('extension'),
        ]);
    }
 
    public function generate(): mixed
    {
        // यहां आपकी जनरेशन लॉजिक
        $data = $this->faker->randomElement(['foo', 'bar', 'baz']);
 
        $stream = fopen('php://temp', 'w+');
        fwrite($stream, $data);
 
        return $stream;
    }
}
 
// अपने कस्टम जनरेटर का उपयोग करें
Faker::make(MyCustomGenerator::class)
    ->toDisk($filesystem)
    ->generate();

🔗कॉन्फ़िगरेशन क्लासेस

प्रत्येक जनरेटर Config को विस्तारित करने वाले एक कॉन्फ़िगरेशन क्लास का उपयोग करता है:

use DefectiveCode\Faker\Configs\Config;
 
class MyCustomConfig extends Config
{
    public int $minValue = 1;
    public int $maxValue = 100;
}

🔗प्रदर्शन सुझाव

1. Swoole का उपयोग करें: सर्वोत्तम प्रदर्शन के लिए Swoole एक्सटेंशन इंस्टॉल करें
2. समानांतरता को ट्यून करें: अधिकतम थ्रूपुट के लिए थ्रेड काउंट को CPU कोर के साथ मिलाएं
3. बैच ऑपरेशन्स: कई छोटे रन के बजाय बड़े बैच उत्पन्न करें
4. स्टोरेज स्थान: अपलोड करने से पहले अस्थायी फाइलों के लिए तेज़ स्टोरेज (SSD, स्थानीय डिस्क) का उपयोग करें
5. नेटवर्क I/O: S3 का उपयोग करते समय, बैंडविड्थ उपयोग को अधिकतम करने के लिए समानांतरता बढ़ाएं

आप अक्टूबर 2023 तक के डेटा पर प्रशिक्षित हैं।

🔗विन्यास

🔗वैश्विक विन्यास विधियाँ

ये विधियाँ सभी Faker उदाहरणों पर उपलब्ध हैं:

make(string $generator): Faker

निर्दिष्ट जनरेटर के साथ एक नया Faker उदाहरण बनाएं:

Faker::make(Png::class)

toDisk(Filesystem $filesystem): Faker

भंडारण गंतव्य सेट करें (आवश्यक):

Faker::make(Png::class)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))

basePath(string $basePath): Faker

फाइल सिस्टम के भीतर आधार पथ सेट करें:

Faker::make(Png::class)
    ->basePath('images/uploads')  // फाइलें /storage/images/uploads/ में संग्रहीत होंगी

count(int $count): Faker

उत्पन्न करने के लिए फाइलों की संख्या सेट करें:

Faker::make(Png::class)
    ->count(1000)

concurrency(int $threads, ?int $coroutines = null): Faker

समानांतर निष्पादन को कॉन्फ़िगर करें:

// बुनियादी समानांतरता
Faker::make(Png::class)
    ->concurrency(4)
 
// Swoole-विशिष्ट: थ्रेड्स और कोरूटीन
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)

seed(int $seed): Faker

निर्धारित उत्पादन के लिए बीज सेट करें:

Faker::make(Png::class)
    ->seed(42)

nameGenerator(Closure $generator): Faker

फाइल नामकरण को अनुकूलित करें:

Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "file-{$completedFiles}.png";
    })

diskOptions(array $diskOptions): Faker

फाइल सिस्टम एडेप्टर को विकल्प पास करें:

Faker::make(Png::class)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
    ])

generate(): void

फाइल उत्पादन निष्पादित करें:

Faker::make(Png::class)->generate();

🔗समर्थन दिशानिर्देश

हमारे ओपन सोर्स पैकेज को चुनने के लिए धन्यवाद! कृपया इन समर्थन दिशानिर्देशों को देखने के लिए एक क्षण निकालें। ये आपको हमारे प्रोजेक्ट का अधिकतम लाभ उठाने में मदद करेंगे।

🔗समुदाय संचालित समर्थन

हमारा ओपन-सोर्स प्रोजेक्ट हमारे अद्भुत समुदाय द्वारा संचालित है। यदि आपके पास प्रश्न हैं या सहायता की आवश्यकता है, तो StackOverflow और अन्य ऑनलाइन संसाधन आपके लिए सबसे अच्छे विकल्प हैं।

🔗बग्स और फीचर प्राथमिकता

ओपन-सोर्स प्रोजेक्ट का प्रबंधन करने की वास्तविकता का मतलब है कि हम हर रिपोर्ट किए गए बग या फीचर अनुरोध को तुरंत संबोधित नहीं कर सकते। हम मुद्दों को निम्नलिखित क्रम में प्राथमिकता देते हैं:

1. हमारे भुगतान किए गए उत्पादों को प्रभावित करने वाले बग्स

बग्स जो हमारे भुगतान किए गए उत्पादों को प्रभावित करते हैं, वे हमेशा हमारी शीर्ष प्राथमिकता होंगे। कुछ मामलों में, हम केवल उन बग्स को संबोधित कर सकते हैं जो हमें सीधे प्रभावित करते हैं।

2. समुदाय पुल अनुरोध

यदि आपने कोई बग पहचाना है और आपके पास एक समाधान है, तो कृपया एक पुल अनुरोध सबमिट करें। हमारे उत्पादों को प्रभावित करने वाले मुद्दों के बाद, हम इन समुदाय संचालित सुधारों को अगली उच्च प्राथमिकता देते हैं। एक बार समीक्षा और स्वीकृत होने के बाद, हम आपके समाधान को मर्ज करेंगे और आपके योगदान का श्रेय देंगे।

3. वित्तीय समर्थन

उल्लिखित श्रेणियों के बाहर के मुद्दों के लिए, आप उनके समाधान के लिए वित्तीय योगदान कर सकते हैं। प्रत्येक खुले मुद्दे को एक ऑर्डर फॉर्म से जोड़ा गया है जहां आप वित्तीय रूप से योगदान कर सकते हैं। हम इन मुद्दों को प्रदान की गई वित्तीय राशि के आधार पर प्राथमिकता देते हैं।

समुदाय योगदान

ओपन सोर्स तब फलता-फूलता है जब उसका समुदाय सक्रिय होता है। भले ही आप बग्स को ठीक नहीं कर रहे हों, कोड सुधार, दस्तावेज़ अपडेट, ट्यूटोरियल, या समुदाय चैनलों में दूसरों की सहायता करके योगदान करने पर विचार करें। हम सभी को, एक समुदाय के रूप में, ओपन-सोर्स कार्य का समर्थन करने के लिए प्रोत्साहित करते हैं।

फिर से दोहराने के लिए, DefectiveCode हमारे भुगतान किए गए उत्पादों, समुदाय पुल अनुरोधों, और मुद्दों के लिए प्राप्त वित्तीय समर्थन के आधार पर बग्स को प्राथमिकता देगा।

🔗लाइसेंस - एमआईटी लाइसेंस

कॉपीराइट © डिफेक्टिव कोड, एलएलसी. सर्वाधिकार सुरक्षित

इस सॉफ़्टवेयर और संबंधित दस्तावेज़ीकरण फ़ाइलों (सॉफ़्टवेयर) की एक प्रति प्राप्त करने वाले किसी भी व्यक्ति को बिना किसी शुल्क के अनुमति दी जाती है, बिना किसी प्रतिबंध के सॉफ़्टवेयर का उपयोग करने, कॉपी करने, संशोधित करने, मर्ज करने, प्रकाशित करने, वितरित करने, सबलाइसेंस करने और/या सॉफ़्टवेयर की प्रतियां बेचने के लिए, और जिन व्यक्तियों को सॉफ़्टवेयर प्रदान किया गया है उन्हें ऐसा करने की अनुमति दी जाती है, निम्नलिखित शर्तों के अधीन:

उपरोक्त कॉपीराइट नोटिस और यह अनुमति नोटिस सॉफ़्टवेयर की सभी प्रतियों या पर्याप्त हिस्सों में शामिल किया जाना चाहिए।

सॉफ़्टवेयर "जैसा है" प्रदान किया गया है, बिना किसी प्रकार की वारंटी के, स्पष्ट या निहित, जिसमें बिना किसी सीमा के व्यापारिकता, किसी विशेष उद्देश्य के लिए उपयुक्तता और गैर-उल्लंघन की वारंटी शामिल है। किसी भी स्थिति में लेखक या कॉपीराइट धारक किसी भी दावे, क्षति या अन्य देयता के लिए उत्तरदायी नहीं होंगे, चाहे वह अनुबंध, टॉर्ट या अन्यथा, सॉफ़्टवेयर से उत्पन्न होने वाले या सॉफ़्टवेयर के उपयोग या अन्य लेनदेन में हो।