juneja-codebase 2.4.0__tar.gz → 4.1.0__tar.gz

juneja_codebase-4.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: juneja_codebase
+Version: 4.1.0
+Summary: CLI tool to generate academic practical code files for Compiler Design, Data Structures, OS, and DBMS
+Home-page: UNKNOWN
+Author: AJ
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Education
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# juneja-codebase
+
+Offline CLI for generating practical code files for multiple subjects.
+
+## Install
+
+```bash
+pip install juneja-codebase==4.1.0
+```
+
+## Use
+
+```bash
+juneja-codebase --list
+juneja-codebase --all
+juneja-codebase --subject compiler_design
+juneja-codebase --subject blockchain
+juneja-codebase --all --zip
+juneja-codebase --all --output ./my_codes
+```
+
+If the console script is not on PATH, use:
+
+```bash
+python3 -m juneja_codebase.main --list
+python3 -m juneja_codebase.main --all
+python3 -m juneja_codebase.main --subject blockchain
+```
+
+## Subjects
+
+- Compiler Design
+- Blockchain Codes
+- Deep Learning
+- Social Network Analysis
+
+## Notes
+
+- `--subject blockchain` resolves to the `Blockchain Codes` templates folder.
+- The package works offline because templates ship inside the wheel and sdist.
+
+
+
+

juneja_codebase-4.1.0/README.md

@@ -0,0 +1,42 @@
+# juneja-codebase
+
+Offline CLI for generating practical code files for multiple subjects.
+
+## Install
+
+```bash
+pip install juneja-codebase==4.1.0
+```
+
+## Use
+
+```bash
+juneja-codebase --list
+juneja-codebase --all
+juneja-codebase --subject compiler_design
+juneja-codebase --subject blockchain
+juneja-codebase --all --zip
+juneja-codebase --all --output ./my_codes
+```
+
+If the console script is not on PATH, use:
+
+```bash
+python3 -m juneja_codebase.main --list
+python3 -m juneja_codebase.main --all
+python3 -m juneja_codebase.main --subject blockchain
+```
+
+## Subjects
+
+- Compiler Design
+- Blockchain Codes
+- Deep Learning
+- Social Network Analysis
+
+## Notes
+
+- `--subject blockchain` resolves to the `Blockchain Codes` templates folder.
+- The package works offline because templates ship inside the wheel and sdist.
+
+

juneja_codebase-4.1.0/juneja_codebase/__init__.py

@@ -0,0 +1,6 @@
+"""
+juneja-codebase: A CLI tool to generate academic practical code files
+"""
+
+__version__ = "4.1.0"
+__author__ = "AJ"

{juneja_codebase-2.4.0 → juneja_codebase-4.1.0}/juneja_codebase/main.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Main CLI entry point for reqcode-aj
+Main CLI entry point for juneja-codebase
 """
 
 import argparse
@@ -15,24 +15,49 @@ def get_templates_dir():
     return Path(__file__).parent / "templates"
 
 
+def normalize_subject_name(name):
+    """Normalize a subject name for flexible matching."""
+    return "".join(ch.lower() for ch in name if ch.isalnum())
+
+
+def resolve_subject_dir(subject):
+    """Resolve a user-supplied subject name to a template directory."""
+    templates_dir = get_templates_dir()
+    subject_lookup = normalize_subject_name(subject)
+
+    for candidate in templates_dir.iterdir():
+        if not candidate.is_dir():
+            continue
+
+        candidate_lookup = normalize_subject_name(candidate.name)
+        if (
+            candidate.name.lower() == subject.lower()
+            or candidate_lookup == subject_lookup
+            or candidate_lookup.startswith(subject_lookup)
+            or subject_lookup.startswith(candidate_lookup)
+        ):
+            return candidate
+
+    return None
+
+
 def list_subjects():
     """List all available subjects"""
     templates_dir = get_templates_dir()
-    subjects = [d.name for d in templates_dir.iterdir() if d.is_dir()]
+    subjects = sorted(d.name for d in templates_dir.iterdir() if d.is_dir())
     return subjects
 
 
 def copy_subject_files(subject, output_dir):
     """Copy files for a specific subject to the output directory"""
-    templates_dir = get_templates_dir()
-    subject_dir = templates_dir / subject
+    subject_dir = resolve_subject_dir(subject)
     
-    if not subject_dir.exists():
+    if subject_dir is None:
         print(f"Error: Subject '{subject}' not found!")
         print(f"Available subjects: {', '.join(list_subjects())}")
         return False
     
-    output_path = Path(output_dir) / subject
+    output_path = Path(output_dir) / subject_dir.name
     output_path.mkdir(parents=True, exist_ok=True)
     
     # Copy all files from subject directory
@@ -66,17 +91,17 @@ def create_zip_archive(subject, output_file):
     
     if subject:
         # Zip specific subject
-        subject_dir = templates_dir / subject
-        if not subject_dir.exists():
+        subject_dir = resolve_subject_dir(subject)
+        if subject_dir is None:
             print(f"Error: Subject '{subject}' not found!")
             return False
         
-        zip_name = output_file if output_file else f"{subject}.zip"
+        zip_name = output_file if output_file else f"{subject_dir.name.replace(' ', '_')}.zip"
         
         with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as zipf:
             for item in subject_dir.rglob('*'):
                 if item.is_file():
-                    arcname = subject / item.relative_to(subject_dir)
+                    arcname = Path(subject_dir.name) / item.relative_to(subject_dir)
                     zipf.write(item, arcname)
                     print(f"Added to zip: {arcname}")
         
@@ -107,12 +132,12 @@ def main():
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
-  reqcode --list                              # List available subjects
-  reqcode --all                               # Generate all code files
-  reqcode --subject compiler_design           # Generate specific subject files
-  reqcode --all --output ./my_codes           # Generate to specific directory
-  reqcode --all --zip                         # Create zip of all subjects
-  reqcode --subject compiler_design --zip     # Create zip of specific subject
+    juneja-codebase --list                              # List available subjects
+    juneja-codebase --all                               # Generate all code files
+    juneja-codebase --subject compiler_design           # Generate specific subject files
+    juneja-codebase --all --output ./my_codes           # Generate to specific directory
+    juneja-codebase --all --zip                         # Create zip of all subjects
+    juneja-codebase --subject compiler_design --zip     # Create zip of specific subject
         """
     )
     
@@ -150,7 +175,7 @@ Examples:
     parser.add_argument(
         '--version', '-v',
         action='version',
-        version='%(prog)s 0.1.0'
+        version='%(prog)s 4.0.0'
     )
     
     args = parser.parse_args()
@@ -177,19 +202,21 @@ Examples:
     # Generate files
     if args.all:
         print("Generating all subject files...")
-        copy_all_subjects(args.output)
-        print(f"\n✓ All files generated in: {os.path.abspath(args.output)}")
+        if copy_all_subjects(args.output):
+            print(f"\n✓ All files generated in: {os.path.abspath(args.output)}")
+        else:
+            print("\nSome subjects could not be generated.")
     elif args.subject:
         print(f"Generating {args.subject} files...")
-        copy_subject_files(args.subject, args.output)
-        print(f"\n✓ Files generated in: {os.path.abspath(args.output)}")
+        if copy_subject_files(args.subject, args.output):
+            print(f"\n✓ Files generated in: {os.path.abspath(args.output)}")
     else:
         # No action specified, show help
         parser.print_help()
         print("\n" + "="*70)
-        print("💡 TIP: If 'reqcode' command doesn't work in your system, use:")
-        print("    python -m reqcode_aj.main --list")
-        print("    python -m reqcode_aj.main --all")
+        print("💡 TIP: If 'juneja-codebase' command doesn't work in your system, use:")
+        print("    python -m juneja_codebase.main --list")
+        print("    python -m juneja_codebase.main --all")
         print("="*70)
 
 

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise1_Blockchain.cpp

@@ -0,0 +1,82 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <iomanip>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+#include <openssl/pem.h>
+#include <openssl/err.h>
+
+void printHex(const unsigned char* data, size_t len) {
+    for (size_t i = 0; i < len; ++i) {
+        std::printf("%02x", data[i]);
+        if ((i + 1) % 32 == 0) std::printf("\n"); 
+    }
+    std::printf("\n");
+}
+
+int main() {
+    std::string document = "This is a confidential document for verification.";
+    unsigned char* signature = nullptr;
+    size_t sig_len = 0;
+
+    // Generating RSA Key Pair
+    EVP_PKEY *pkey = EVP_RSA_gen(2048);
+    if (!pkey) { std::cerr << "Keygen failed\n"; return 1; }
+
+    // Printing the Private Key (The Secret Part)
+    std::cout << "\nSENDER'S PRIVATE KEY (Used for Signing):\n\n";
+    BIO* pri_bio = BIO_new(BIO_s_mem());
+    PEM_write_bio_PrivateKey(pri_bio, pkey, NULL, NULL, 0, NULL, NULL);
+    char* pri_buf;
+    size_t pri_len = BIO_get_mem_data(pri_bio, &pri_buf);
+    std::cout.write(pri_buf, pri_len) << "\n";
+
+    // Printing the Public Key (The Shared Part)
+    std::cout << "\nSENDER'S PUBLIC KEY (Shared with Receiver):\n\n";
+    BIO* pub_bio = BIO_new(BIO_s_mem());
+    PEM_write_bio_PUBKEY(pub_bio, pkey);
+    char* pub_buf;
+    size_t pub_len = BIO_get_mem_data(pub_bio, &pub_buf);
+    std::cout.write(pub_buf, pub_len) << "\n";
+
+    // Creating the Signature (Signing Process)
+    std::cout << "SIGNING THE DOCUMENT...\n";
+    std::cout << "Document Content: \"" << document << "\"\n\n";
+    
+    EVP_MD_CTX *m_ctx = EVP_MD_CTX_new();
+    EVP_DigestSignInit(m_ctx, NULL, EVP_sha256(), NULL, pkey);
+    EVP_DigestSignUpdate(m_ctx, document.c_str(), document.length());
+    
+    // Getting signature length first
+    EVP_DigestSignFinal(m_ctx, NULL, &sig_len);
+    signature = (unsigned char*)OPENSSL_malloc(sig_len);
+    EVP_DigestSignFinal(m_ctx, signature, &sig_len);
+
+    std::cout << "\nGENERATED SIGNATURE (HEXADECIMAL):\n\n";
+    printHex(signature, sig_len);
+
+    // Verification Process
+    std::cout << "\nVERIFYING SIGNATURE WITH PUBLIC KEY...\n\n";
+    EVP_MD_CTX *v_ctx = EVP_MD_CTX_new();
+    EVP_DigestVerifyInit(v_ctx, NULL, EVP_sha256(), NULL, pkey);
+    EVP_DigestVerifyUpdate(v_ctx, document.c_str(), document.length());
+    
+    int is_valid = EVP_DigestVerifyFinal(v_ctx, signature, sig_len);
+
+    if (is_valid == 1) {
+        std::cout << "RESULT: SUCCESS! The signature is VALID.\n";
+    } else {
+        std::cout << "RESULT: FAILED! The signature is INVALID.\n";
+    }
+
+    // Cleanup
+    OPENSSL_free(signature);
+    BIO_free(pri_bio);
+    BIO_free(pub_bio);
+    EVP_MD_CTX_free(m_ctx);
+    EVP_MD_CTX_free(v_ctx);
+    EVP_PKEY_free(pkey);
+
+    return 0;
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise2_Blockchain.cpp

@@ -0,0 +1,69 @@
+#include <iostream>
+#include <vector>
+#include <ctime>
+#include <string>
+using namespace std;
+
+class Block {
+public:
+    int index;
+    string transactions;
+    string prevHash;
+    string currentHash;
+    time_t timeCreated;
+
+    Block(int idx, string tx, string lastHash) {
+        index = idx;
+        transactions = tx;
+        prevHash = lastHash;
+        timeCreated = time(0);
+        currentHash = generateHash();
+    }
+
+    string generateHash() {
+        // We combine all data into one string to "sign" it
+        string toHash = to_string(index) + transactions + prevHash + to_string(timeCreated);
+        
+        hash<string> hasher; 
+        return to_string(hasher(toHash));
+    }
+};
+
+// Manages the list of blocks
+class Blockchain {
+public:
+    vector<Block> ledger;
+
+    Blockchain() {
+        // Create the first "Genesis" block manually
+        ledger.push_back(Block(0, "Initial Block", "0"));
+    }
+
+    void addTransaction(string data) {
+        // Get the hash of the very last block in our ledger
+        string lastBlockHash = ledger.back().currentHash;
+        
+        // Create a new block linked to the last one
+        ledger.push_back(Block(ledger.size(), data, lastBlockHash));
+    }
+
+    void displayChain() {
+        for (const auto& b : ledger) {
+            cout << "--- Block #" << b.index << " ---" << endl;
+            cout << "Time: " << b.timeCreated << endl;
+            cout << "Data: " << b.transactions << endl;
+            cout << "Prev: " << b.prevHash << endl;
+            cout << "Hash: " << b.currentHash << endl << endl;
+        }
+    }
+};
+
+int main() {
+    Blockchain bitCoin;
+
+    bitCoin.addTransaction("I have 40 bit coin");
+    bitCoin.addTransaction("Aman have 30 bicoin");
+
+    bitCoin.displayChain();
+    return 0;
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-1_Blockchain.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <openssl/sha.h>
+#include <iomanip>
+#include <string>
+#include <sstream>
+using namespace std;
+
+string getSHA256(string input) {
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+    
+    SHA256(reinterpret_cast<const unsigned char*>(input.c_str()), input.size(), hash);
+
+    stringstream ss;
+    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+        ss << hex << setw(2) << setfill('0') << (int)hash[i];
+    }
+    return ss.str();
+}
+int main() {
+    string userInput;
+    cout << " SHA-256 HASH GENERATOR " << endl;
+    
+    cout << "Enter text to hash: ";
+    getline(cin, userInput); // Allows spaces in input
+
+    string result = getSHA256(userInput);
+
+    cout << "\nInput String : " << userInput << endl;
+    cout << "Message Digest: " << result << endl;
+    return 0;
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-2_Blockchain.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+#include <openssl/sha.h>
+#include <iomanip>
+using namespace std;
+
+int main() {
+    string msg = "Blockchain Developer";
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+
+    SHA256(reinterpret_cast<const unsigned char*>(msg.c_str()), msg.size(), hash);
+
+    cout << "Message     : " << msg << endl;
+    cout << "SHA256 Hash : ";
+
+    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++)
+        cout << hex << setw(2) << setfill('0') << (int)hash[i];
+
+    cout << endl;
+    cout << "Decryption  : Not possible (SHA256 is one-way)" << endl;
+
+    return 0;
+}
+

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-3_Blockchain.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+#include <openssl/sha.h>
+#include <iomanip>
+#include <string>
+#include <sstream>
+
+using namespace std;
+
+string getSHA256(string input) {
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+    SHA256(reinterpret_cast<const unsigned char*>(input.c_str()), input.size(), hash);
+
+    stringstream ss;
+    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+        ss << hex << setw(2) << setfill('0') << (int)hash[i];
+    }
+
+    return ss.str();
+}
+
+int main() {
+    string str1 = "Hello World";
+    string str2 = "Hello world";
+
+    cout << "String 1: " << str1 << endl;
+    cout << "Hash 1 : " << getSHA256(str1) << endl;
+
+    cout << "\nString 2: " << str2 << endl;
+    cout << "Hash 2 : " << getSHA256(str2) << endl;
+
+    return 0;
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise4_Blockchain.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+#include <openssl/sha.h>
+#include <iomanip>
+#include <string>
+#include <sstream>
+
+using namespace std;
+
+int main() {
+    string input = "Hello World";
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+
+    // Generating the hash
+    SHA256(reinterpret_cast<const unsigned char*>(input.c_str()), input.size(), hash);
+
+    stringstream ss;
+    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+        ss << hex << setw(2) << setfill('0') << (int)hash[i];
+    }
+
+    cout << "Input  : " << input << endl;
+    cout << "SHA-256: " << ss.str() << endl;
+
+    return 0;
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise5_Blockchain.cpp

@@ -0,0 +1,62 @@
+#include <iostream>
+#include <cmath>
+#include <iomanip>
+using namespace std;
+
+long long power(long long base, long long exp, long long mod) {
+    long long res = 1;
+    base = base % mod;
+    while (exp > 0) {
+        if (exp % 2 == 1) res = (res * base) % mod;
+        base = (base * base) % mod;
+        exp = exp / 2;
+    }
+    return res;
+}
+
+int findPrivate_d(int e, int phi) {
+    for (int d = 1; d < phi; d++) {
+        if ((e * d) % phi == 1)
+            return d;
+    }
+    return 0;
+}
+int main() {
+    int p = 17; 
+    int q = 11;
+    int n = p * q;             
+    int phi = (p - 1) * (q - 1); // Euler's Totient Function
+    
+    // Given Public Exponent (e)
+    int e = 11; 
+    
+    // Find Private Key (d)
+    int d = findPrivate_d(e, phi);
+    
+    // Original Message (Transaction Data)
+    int M = 123;
+    
+    // --- RSA Encryption ---
+    long long C = power(M, e, n); // Formula: C = (M^e) % n
+    
+    // --- RSA Decryption ---
+    long long decrypted_M = power(C, d, n); // Formula: Decrypted_M = (C^d) % n
+
+    cout << "--- RSA Implementation ---" << endl;
+    cout << "p: " << p << " | q: " << q << endl;
+    cout << "Public Modulus (n)    : " << n << endl;
+    cout << "Euler's Totient (phi) : " << phi << endl;
+    cout << "Public Key (e)        : " << e << endl;
+    cout << "Private Key (d)       : " << d << endl;
+    cout << "----------------" << endl;
+    cout << "Original Message (M)     : " << M << endl;
+    cout << "Encrypted Ciphertext (C) : " << C << endl;
+    cout << "Decrypted Message        : " << decrypted_M << endl;
+    
+    if (M == decrypted_M) {
+        cout << "\nVerification complete! Original message recovered." << endl;
+    } else {
+        cout << "\nDecryption failed." << endl;
+    }
+    return 0;
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise6_Blockchain.cpp

@@ -0,0 +1,91 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <ctime>
+#include <sstream>
+#include <iomanip>
+using namespace std;
+
+string simpleHash(string input) {
+    unsigned long hash = 5381;
+    for (size_t i = 0; i < input.length(); i++) {
+        char c = input[i];
+        hash = ((hash << 5) + hash) + c; 
+    }
+    stringstream ss;
+    ss << hex << setw(8) << setfill('0') << hash;
+    return ss.str();
+}
+
+class Block {
+public:
+    int index;
+    string data;
+    string prevHash;
+    string hash;
+    int nonce;
+
+    Block(int idx, string d, string pHash) {
+        index = idx;
+        data = d;
+        prevHash = pHash;
+        nonce = 0;
+        mineBlock(); // Perform PoW immediately upon creation
+    }
+
+    string calculateHash() {
+        stringstream ss;
+        ss << index << data << prevHash << nonce;
+        return simpleHash(ss.str());
+    }
+
+    void mineBlock() {
+        string target = "00"; //Hash must start with "00"
+        do {
+            nonce++;
+            hash = calculateHash();
+        } while (hash.substr(0, 2) != target);
+        
+        cout << "Block Mined! Hash: " << hash << " | Nonce: " << nonce << endl;
+    }
+};
+
+class Blockchain {
+public:
+    vector<Block> chain;
+
+    Blockchain() {
+        cout << "Mining Genesis Block..." << endl;
+        chain.push_back(Block(0, "Genesis Block", "0"));
+    }
+
+    void addBlock(string data) {
+        cout << "Mining Block " << chain.size() << "..." << endl;
+        string lastHash = chain.back().hash;
+        chain.push_back(Block(chain.size(), data, lastHash));
+    }
+
+    void printChain() {
+        cout << "\n--- COMPLETE BLOCKCHAIN DETAILS ---" << endl;
+        for (size_t i = 0 ; i<chain.size() ; i++) {
+           cout << "Index    : " << chain[i].index << endl;
+		   cout << "Data     : " << chain[i].data << endl;
+           cout << "Prev Hash: " << chain[i].prevHash << endl;
+           cout << "Hash     : " << chain[i].hash << endl;
+           cout << "Nonce    : " << chain[i].nonce << endl;
+           cout << "-----------------------------------" << endl;
+        }
+    }
+};
+
+int main() {
+    Blockchain myCoin;
+
+    myCoin.addBlock("A -> B");
+    myCoin.addBlock("B -> C");
+    myCoin.addBlock("C -> D");
+
+    myCoin.printChain();
+
+    return 0;
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise7_Blockchain.cpp

@@ -0,0 +1,139 @@
+#include <iostream>
+#include <vector>
+#include <ctime>
+#include <sstream>
+#include <iomanip>
+#include <openssl/sha.h>
+
+using namespace std;
+
+/* ==========================================
+   SHA-256 Hash Function
+========================================== */
+string sha256(const string &input) {
+    unsigned char hash[SHA256_DIGEST_LENGTH];
+
+    SHA256(
+        (unsigned char*)input.c_str(),
+        input.size(),
+        hash
+    );
+
+    stringstream ss;
+
+    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+        ss << hex << setw(2) << setfill('0') << (int)hash[i];
+    }
+
+    return ss.str();
+}
+
+/* ==========================================
+   Block Class
+========================================== */
+class Block {
+public:
+    int index;
+    string data;
+    string previousHash;
+    string hash;
+    long timestamp;
+
+    // Constructor
+    Block(int idx, string d, string prevHash) {
+        index = idx;
+        data = d;
+        previousHash = prevHash;
+        timestamp = time(0);
+        hash = calculateHash();
+    }
+
+    // Hash calculation
+    string calculateHash() const {
+        string input = to_string(index) + data + previousHash + to_string(timestamp);
+        return sha256(input);
+    }
+};
+
+/* ==========================================
+   Blockchain Class
+========================================== */
+class Blockchain {
+public:
+    vector<Block> chain;
+
+    // Constructor
+    Blockchain() {
+        chain.push_back(createGenesisBlock());
+    }
+
+    // Genesis block
+    Block createGenesisBlock() {
+        return Block(0, "Genesis Block (Mayank)", "0");
+    }
+
+    // Get latest block
+    Block getLatestBlock() {
+        return chain.back();
+    }
+
+    // Add new block
+    void addBlock(string data) {
+        Block newBlock(chain.size(), data, getLatestBlock().hash);
+        chain.push_back(newBlock);
+    }
+
+    // Print blockchain
+    void printChain() {
+        for (auto &block : chain) {
+            cout << "\nBlock " << block.index << endl;
+            cout << "Data           : " << block.data << endl;
+            cout << "Previous Hash  : " << block.previousHash << endl;
+            cout << "Hash           : " << block.hash << endl;
+            cout << "--------------------------------------\n";
+        }
+    }
+
+    // Validate blockchain
+    bool isChainValid() {
+        for (int i = 1; i < chain.size(); i++) {
+            Block &current = chain[i];
+            Block &previous = chain[i - 1];
+
+            // Check current hash
+            if (current.hash != current.calculateHash())
+                return false;
+
+            // Check chain linking
+            if (current.previousHash != previous.hash)
+                return false;
+        }
+        return true;
+    }
+};
+
+/* ==========================================
+   Main Function
+========================================== */
+int main() {
+
+    cout << "===== Blockchain Practical by Mayank =====\n";
+
+    Blockchain myChain;
+
+    // Adding blocks
+    myChain.addBlock("A -> B");
+    myChain.addBlock("B -> C");
+    myChain.addBlock("C -> D");
+    myChain.addBlock("D -> E");
+    myChain.addBlock("E -> F");
+
+    cout << "\n===== Original Blockchain =====\n";
+    myChain.printChain();
+
+    // Validate chain
+    cout << "\nIs Blockchain Valid? : "
+         << (myChain.isChainValid() ? "YES" : "NO") << endl;
+
+    return 0;
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise8-1_Blockchain.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Simple {
+
+    uint public value;
+
+    function set(uint _v) public {
+        value = _v;
+    }
+
+    function get() public view returns (uint) {
+        return value;
+    }
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise8-2_Blockchain.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract StudentStorage {
+
+    string public name;
+    uint public age;
+
+    // Set student details
+    function setStudent(string memory _name, uint _age) public {
+        name = _name;
+        age = _age;
+    }
+
+    // Get student details
+    function getStudent() public view returns (string memory, uint) {
+        return (name, age);
+    }
+}

juneja_codebase-4.1.0/juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise8-3_Blockchain.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract SecureFundTransfer {
+
+    // Deposit Ether
+    function deposit() public payable {}
+
+    // Transfer using call (recommended)
+    function transferFunds(address payable recipient, uint amount) public {
+        require(address(this).balance >= amount, "Insufficient balance");
+
+        (bool success, ) = recipient.call{value: amount}("");
+        require(success, "Transfer failed");
+    }
+
+    // Check balance
+    function getBalance() public view returns (uint) {
+        return address(this).balance;
+    }
+}

juneja_codebase-4.1.0/juneja_codebase.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: juneja-codebase
+Version: 4.1.0
+Summary: CLI tool to generate academic practical code files for Compiler Design, Data Structures, OS, and DBMS
+Home-page: UNKNOWN
+Author: AJ
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Education
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# juneja-codebase
+
+Offline CLI for generating practical code files for multiple subjects.
+
+## Install
+
+```bash
+pip install juneja-codebase==4.1.0
+```
+
+## Use
+
+```bash
+juneja-codebase --list
+juneja-codebase --all
+juneja-codebase --subject compiler_design
+juneja-codebase --subject blockchain
+juneja-codebase --all --zip
+juneja-codebase --all --output ./my_codes
+```
+
+If the console script is not on PATH, use:
+
+```bash
+python3 -m juneja_codebase.main --list
+python3 -m juneja_codebase.main --all
+python3 -m juneja_codebase.main --subject blockchain
+```
+
+## Subjects
+
+- Compiler Design
+- Blockchain Codes
+- Deep Learning
+- Social Network Analysis
+
+## Notes
+
+- `--subject blockchain` resolves to the `Blockchain Codes` templates folder.
+- The package works offline because templates ship inside the wheel and sdist.
+
+
+
+

{juneja_codebase-2.4.0 → juneja_codebase-4.1.0}/juneja_codebase.egg-info/SOURCES.txt

@@ -10,6 +10,27 @@ juneja_codebase.egg-info/SOURCES.txt
 juneja_codebase.egg-info/dependency_links.txt
 juneja_codebase.egg-info/entry_points.txt
 juneja_codebase.egg-info/top_level.txt
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise1_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise1_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise2_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise2_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-1_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-1_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-2_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-2_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-3_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise3-3_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise4_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise4_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise5_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise5_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise6_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise6_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise7_Blockchain
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise7_Blockchain.cpp
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise8-1_Blockchain.sol
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise8-2_Blockchain.sol
+juneja_codebase/templates/Blockchain Codes/AnshJuneja_LabExercise8-3_Blockchain.sol
 juneja_codebase/templates/compiler_design/AnshJuneja_Practical10_CD.l
 juneja_codebase/templates/compiler_design/AnshJuneja_Practical10_CD.y
 juneja_codebase/templates/compiler_design/AnshJuneja_Practical11_CD.l

{juneja_codebase-2.4.0 → juneja_codebase-4.1.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = juneja_codebase
-version = 2.4.0
+version = 4.1.0
 
 [options]
 packages = find:

{juneja_codebase-2.4.0 → juneja_codebase-4.1.0}/setup.py

@@ -7,7 +7,7 @@ long_description = (this_directory / "README.md").read_text(encoding='utf-8') if
 
 setup(
 	name="juneja_codebase",
-	version="2.4.0",
+	version="4.1.0",
 	author="AJ",
 	description="CLI tool to generate academic practical code files for Compiler Design, Data Structures, OS, and DBMS",
 	long_description=long_description,

juneja_codebase-2.4.0/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.1
-Name: juneja_codebase
-Version: 2.4.0
-Summary: CLI tool to generate academic practical code files for Compiler Design, Data Structures, OS, and DBMS
-Home-page: UNKNOWN
-Author: AJ
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Education
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-UNKNOWN
-

juneja_codebase-2.4.0/juneja_codebase/__init__.py

@@ -1,6 +0,0 @@
-"""
-reqcode-aj: A CLI tool to generate academic practical code files
-"""
-
-__version__ = "0.1.0"
-__author__ = "AJ"

juneja_codebase-2.4.0/juneja_codebase.egg-info/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.1
-Name: juneja-codebase
-Version: 2.4.0
-Summary: CLI tool to generate academic practical code files for Compiler Design, Data Structures, OS, and DBMS
-Home-page: UNKNOWN
-Author: AJ
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Education
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-UNKNOWN
-