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

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

🔗परिचय

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

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

🔗प्रमुख विशेषताएँ

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

🔗उदाहरण

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 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();

🔗संग्रहण कॉन्फ़िगरेशन

फ्लाईसिस्टम का उपयोग करना

Faker स्टोरेज संग्रहण अमूर्तता के लिए लीग फ्लाईसिस्टम का उपयोग करता है:

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();

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

🔗जनरेटर

🔗इमेज जनरेटर

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

PNG

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();

JPG

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();

GIF

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();

BMP

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();

WEBP

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();

AVIF

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.

🔗CSV जनरेटर

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

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 PNG अटैचमेंट जोड़ें
    ->toDisk($filesystem)
    ->generate();

ईमेल हेडर्स

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

• To: यादृच्छिक नाम और ईमेल
• From: यादृच्छिक नाम और ईमेल
• Subject: यादृच्छिक वाक्य
• Date: वर्तमान समय stamps
• Message-ID: बीज के आधार पर निर्धारित 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 PNG अटैचमेंट
    ->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
 
iVBORw0KGgoAAAANTSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+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 का उपयोग करते समय, बैंडविड्थ उपयोग को अधिकतम करने के लिए समवर्तीता बढ़ाएं

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

🔗वैश्विक कॉन्फ़िगरेशन विधियाँ

ये विधियाँ सभी 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 हमारे भुगतान किए गए उत्पादों पर प्रभाव, सामुदायिक पुल अनुरोध और मुद्दों के लिए प्राप्त वित्तीय समर्थन के आधार पर बग को प्राथमिकता देगा.

🔗लाइसेंस - MIT लाइसेंस

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

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

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

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