juneja-codebase 4.0.0__tar.gz → 4.1.1__tar.gz

juneja_codebase-4.1.1/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include juneja_codebase/templates *

juneja_codebase-4.1.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: juneja_codebase
+Version: 4.1.1
+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.1/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.1/juneja_codebase/__init__.py

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

{juneja_codebase-4.0.0 → juneja_codebase-4.1.1}/juneja_codebase/main.py

@@ -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}")
         
@@ -150,7 +175,7 @@ Examples:
     parser.add_argument(
         '--version', '-v',
         action='version',
-        version='%(prog)s 4.0.0'
+        version='%(prog)s 4.1.1'
     )
     
     args = parser.parse_args()
@@ -177,12 +202,14 @@ 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()

juneja_codebase-4.1.1/juneja_codebase/templates/Blockchain Codes/.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: gcc build active file",
+            "command": "/usr/bin/gcc",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}/${fileBasenameNoExtension}"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
+        }
+    ],
+    "version": "2.0.0"
+}

juneja_codebase-4.1.1/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.1/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.1/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.1/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.1/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.1/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.1/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;
+}