oslabcode 1.0.0__py3-none-any.whl

oslabcode/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.1.0"

oslabcode/cli.py

@@ -0,0 +1,105 @@
+from pathlib import Path
+from importlib.resources import files
+import shutil
+import sys
+
+CODES = {
+    "banker": "Banker.py",
+    "bf": "BF.py",
+    "clook": "CLOOK.py",
+    "cscan": "CSCAN.py",
+    "fcfs_ds": "FCFS_DS.py",
+    "fcfs_ps": "FCFS_PS.py",
+    "ff": "FF.py",
+    "fifo": "FIFO.py",
+    "lfu": "LFU.py",
+    "look": "LOOK.py",
+    "lru": "LRU.py",
+    "nf": "NF.py",
+    "optimal": "Optimal.py",
+    "priority": "Priority.py",
+    "rr": "RR.py",
+    "sc": "SC.py",
+    "scan": "SCAN.py",
+    "sjf": "SJF.py",
+    "srtf": "SRTF.py",
+    "sstf": "SSTF.py",
+    "wf": "WF.py",
+}
+
+
+def copy_template(code):
+    try:
+        src = files("oslabcode.templates").joinpath(CODES[code])
+        dst = Path.cwd() / CODES[code]
+
+        shutil.copy(str(src), dst)
+
+        print(f"Downloaded {CODES[code]}")
+        print(f"Saved to {dst}")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+def list_codes():
+    print("\nAvailable Codes:\n")
+
+    for code in CODES:
+        print(code)
+
+
+def copy_all():
+    for code in CODES:
+        copy_template(code)
+
+
+def interactive_menu():
+    codes = list(CODES.keys())
+
+    print("\nAvailable Codes:\n")
+
+    for i, code in enumerate(codes, start=1):
+        print(f"{i}. {code}")
+
+    try:
+        choice = int(input("\nChoose option: "))
+
+        if not (1 <= choice <= len(codes)):
+            print("Invalid choice")
+            return
+
+        copy_template(codes[choice - 1])
+
+    except ValueError:
+        print("Please enter a number.")
+
+
+def main():
+    if len(sys.argv) == 1:
+        interactive_menu()
+        return
+
+    command = sys.argv[1].lower()
+
+    if command == "list":
+        list_codes()
+
+    elif command == "all":
+        copy_all()
+
+    elif command in CODES:
+        copy_template(command)
+
+    else:
+        print("Code not found.\n")
+
+        print("Usage:")
+        print("  oslabcode")
+        print("  oslabcode list")
+        print("  oslabcode all")
+        print("  oslabcode <code>")
+
+
+if __name__ == "__main__":
+    main()

oslabcode/templates/BF.py

@@ -0,0 +1,16 @@
+blocks = list(map(int, input("Enter block sizes: ").split()))
+processes = list(map(int, input("Enter process sizes: ").split()))
+
+for i in range(len(processes)):
+    best = -1
+
+    for j in range(len(blocks)):
+        if blocks[j] >= processes[i]:
+            if best == -1 or blocks[j] < blocks[best]:
+                best = j
+
+    if best != -1:
+        print("Process", i + 1, "allocated to Block", best + 1)
+        blocks[best] -= processes[i]
+    else:
+        print("Process", i + 1, "not allocated")

oslabcode/templates/Banker.py

@@ -0,0 +1,65 @@
+n = int(input("Enter number of processes: "))
+m = int(input("Enter number of resource types: "))
+
+alloc = []
+print("\nEnter Allocation Matrix:")
+for i in range(n):
+    alloc.append(list(map(int, input().split())))
+
+maxm = []
+print("\nEnter Max Matrix:")
+for i in range(n):
+    maxm.append(list(map(int, input().split())))
+
+avail = list(map(int, input("\nEnter Available Resources: ").split()))
+
+need = []
+
+for i in range(n):
+    row = []
+    for j in range(m):
+        row.append(maxm[i][j] - alloc[i][j])
+    need.append(row)
+
+print("\nNeed Matrix:")
+for row in need:
+    print(row)
+
+finish = [False] * n
+safe = []
+
+count = 0
+
+while count < n:
+
+    found = False
+
+    for i in range(n):
+
+        if not finish[i]:
+
+            possible = True
+
+            for j in range(m):
+                if need[i][j] > avail[j]:
+                    possible = False
+                    break
+
+            if possible:
+
+                for j in range(m):
+                    avail[j] += alloc[i][j]
+
+                safe.append("P" + str(i))
+                finish[i] = True
+                found = True
+                count += 1
+
+    if not found:
+        break
+
+if count == n:
+    print("\nSafe Sequence:")
+    print(" -> ".join(safe))
+else:
+    print("\nSystem is NOT in a Safe State")

oslabcode/templates/CLOOK.py

@@ -0,0 +1,24 @@
+req = list(map(int, input("Enter requests: ").split()))
+head = int(input("Enter initial head position: "))
+
+left = [x for x in req if x < head]
+right = [x for x in req if x >= head]
+
+left.sort()
+right.sort()
+
+seek = 0
+
+for r in right:
+    seek += abs(head - r)
+    head = r
+
+if left:
+    seek += abs(head - left[0])
+    head = left[0]
+
+for r in left:
+    seek += abs(head - r)
+    head = r
+
+print("Total Seek Time =", seek)

oslabcode/templates/CSCAN.py

@@ -0,0 +1,27 @@
+req = list(map(int, input("Enter requests: ").split()))
+head = int(input("Enter initial head position: "))
+disk_size = int(input("Enter disk size: "))
+
+left = [x for x in req if x < head]
+right = [x for x in req if x >= head]
+
+left.sort()
+right.sort()
+
+seek = 0
+
+for r in right:
+    seek += abs(head - r)
+    head = r
+
+seek += abs(head - (disk_size - 1))
+head = disk_size - 1
+
+seek += disk_size - 1
+head = 0
+
+for r in left:
+    seek += abs(head - r)
+    head = r
+
+print("Total Seek Time =", seek)

oslabcode/templates/FCFS_DS.py

@@ -0,0 +1,10 @@
+req = list(map(int, input("Enter requests: ").split()))
+head = int(input("Enter initial head position: "))
+
+seek = 0
+
+for r in req:
+    seek += abs(head - r)
+    head = r
+
+print("Total Seek Time =", seek)

oslabcode/templates/FCFS_PS.py

@@ -0,0 +1,28 @@
+n = int(input("Enter number of processes: "))
+
+pid, at, bt = [], [], []
+
+for i in range(n):
+    pid.append(input("Process ID: "))
+    at.append(int(input("Arrival Time: ")))
+    bt.append(int(input("Burst Time: ")))
+
+# Sort by Arrival Time
+p = sorted(zip(pid, at, bt), key=lambda x: x[1])
+
+ct = []
+time = 0
+
+for _, a, b in p:
+    time = max(time, a) + b
+    ct.append(time)
+
+tat = [ct[i] - p[i][1] for i in range(n)]
+wt = [tat[i] - p[i][2] for i in range(n)]
+
+print("\nPID\tTAT\tWT")
+for i in range(n):
+    print(f"{p[i][0]}\t{tat[i]}\t{wt[i]}")
+
+print("\nAverage TAT =", round(sum(tat) / n, 2))
+print("Average WT =", round(sum(wt) / n, 2))

oslabcode/templates/FF.py

@@ -0,0 +1,15 @@
+blocks = list(map(int, input("Enter block sizes: ").split()))
+processes = list(map(int, input("Enter process sizes: ").split()))
+
+for i in range(len(processes)):
+    allocated = False
+
+    for j in range(len(blocks)):
+        if blocks[j] >= processes[i]:
+            print("Process", i + 1, "allocated to Block", j + 1)
+            blocks[j] -= processes[i]
+            allocated = True
+            break
+
+    if not allocated:
+        print("Process", i + 1, "not allocated")

oslabcode/templates/FIFO.py

@@ -0,0 +1,25 @@
+pages = list(map(int, input("Enter page reference string: ").split()))
+frames = int(input("Enter number of frames: "))
+
+memory = []
+faults = 0
+hits = 0
+
+for page in pages:
+
+    if page in memory:
+        hits += 1
+
+    else:
+        faults += 1
+
+        if len(memory) < frames:
+            memory.append(page)
+        else:
+            memory.pop(0)
+            memory.append(page)
+
+    print(memory)
+
+print("Page Faults =", faults)
+print("Page Hits =", hits)

oslabcode/templates/LFU.py

@@ -0,0 +1,36 @@
+pages = list(map(int, input("Enter page reference string: ").split()))
+frames = int(input("Enter number of frames: "))
+
+memory = []
+freq = {}
+
+faults = 0
+hits = 0
+
+for page in pages:
+
+    freq[page] = freq.get(page, 0) + 1
+
+    if page in memory:
+        hits += 1
+
+    else:
+        faults += 1
+
+        if len(memory) < frames:
+            memory.append(page)
+
+        else:
+            lfu = memory[0]
+
+            for p in memory:
+                if freq[p] < freq[lfu]:
+                    lfu = p
+
+            memory.remove(lfu)
+            memory.append(page)
+
+    print(memory)
+
+print("Page Faults =", faults)
+print("Page Hits =", hits)

oslabcode/templates/LOOK.py

@@ -0,0 +1,20 @@
+req = list(map(int, input("Enter requests: ").split()))
+head = int(input("Enter initial head position: "))
+
+left = [x for x in req if x < head]
+right = [x for x in req if x >= head]
+
+left.sort()
+right.sort()
+
+seek = 0
+
+for r in right:
+    seek += abs(head - r)
+    head = r
+
+for r in reversed(left):
+    seek += abs(head - r)
+    head = r
+
+print("Total Seek Time =", seek)

oslabcode/templates/LRU.py

@@ -0,0 +1,27 @@
+pages = list(map(int, input("Enter page reference string: ").split()))
+frames = int(input("Enter number of frames: "))
+
+memory = []
+faults = 0
+hits = 0
+
+for page in pages:
+
+    if page in memory:
+        hits += 1
+        memory.remove(page)
+        memory.append(page)
+
+    else:
+        faults += 1
+
+        if len(memory) < frames:
+            memory.append(page)
+        else:
+            memory.pop(0)
+            memory.append(page)
+
+    print(memory)
+
+print("Page Faults =", faults)
+print("Page Hits =", hits)

oslabcode/templates/NF.py

@@ -0,0 +1,22 @@
+blocks = list(map(int, input("Enter block sizes: ").split()))
+processes = list(map(int, input("Enter process sizes: ").split()))
+
+pos = 0
+n = len(blocks)
+
+for i in range(len(processes)):
+    allocated = False
+    count = 0
+
+    while count < n:
+        if blocks[pos] >= processes[i]:
+            print("Process", i + 1, "allocated to Block", pos + 1)
+            blocks[pos] -= processes[i]
+            allocated = True
+            break
+
+        pos = (pos + 1) % n
+        count += 1
+
+    if not allocated:
+        print("Process", i + 1, "not allocated")

oslabcode/templates/Optimal.py

@@ -0,0 +1,42 @@
+pages = list(map(int, input("Enter page reference string: ").split()))
+frames = int(input("Enter number of frames: "))
+
+memory = []
+faults = 0
+hits = 0
+
+for i in range(len(pages)):
+
+    page = pages[i]
+
+    if page in memory:
+        hits += 1
+
+    else:
+        faults += 1
+
+        if len(memory) < frames:
+            memory.append(page)
+
+        else:
+            idx = -1
+            farthest = -1
+
+            for j in range(len(memory)):
+
+                if memory[j] not in pages[i+1:]:
+                    idx = j
+                    break
+
+                pos = pages[i+1:].index(memory[j])
+
+                if pos > farthest:
+                    farthest = pos
+                    idx = j
+
+            memory[idx] = page
+
+    print(memory)
+
+print("Page Faults =", faults)
+print("Page Hits =", hits)

oslabcode/templates/Priority.py

@@ -0,0 +1,49 @@
+n = int(input("Enter number of processes: "))
+
+pid = []
+at = []
+bt = []
+pr = []
+
+for i in range(n):
+    pid.append(input("Process ID: "))
+    at.append(int(input("Arrival Time: ")))
+    bt.append(int(input("Burst Time: ")))
+    pr.append(int(input("Priority: ")))
+
+completed = [False] * n
+tat = [0] * n
+wt = [0] * n
+
+time = 0
+count = 0
+
+while count < n:
+
+    idx = -1
+    highest = 9999
+
+    for i in range(n):
+        if at[i] <= time and not completed[i]:
+            if pr[i] < highest:
+                highest = pr[i]
+                idx = i
+
+    if idx == -1:
+        time += 1
+        continue
+
+    time += bt[idx]
+
+    tat[idx] = time - at[idx]
+    wt[idx] = tat[idx] - bt[idx]
+
+    completed[idx] = True
+    count += 1
+
+print("\nPID\tTAT\tWT")
+for i in range(n):
+    print(pid[i], "\t", tat[i], "\t", wt[i])
+
+print("\nAverage TAT =", sum(tat)/n)
+print("Average WT =", sum(wt)/n)

oslabcode/templates/RR.py

@@ -0,0 +1,52 @@
+n = int(input("Enter number of processes: "))
+q = int(input("Enter Time Quantum: "))
+
+pid = []
+at = []
+bt = []
+
+for i in range(n):
+    pid.append(input("Process ID: "))
+    at.append(int(input("Arrival Time: ")))
+    bt.append(int(input("Burst Time: ")))
+
+remaining = bt.copy()
+
+tat = [0] * n
+wt = [0] * n
+
+time = 0
+completed = 0
+
+while completed < n:
+
+    done = True
+
+    for i in range(n):
+
+        if remaining[i] > 0 and at[i] <= time:
+
+            done = False
+
+            if remaining[i] > q:
+                time += q
+                remaining[i] -= q
+
+            else:
+                time += remaining[i]
+
+                tat[i] = time - at[i]
+                wt[i] = tat[i] - bt[i]
+
+                remaining[i] = 0
+                completed += 1
+
+    if done:
+        time += 1
+
+print("\nPID\tTAT\tWT")
+for i in range(n):
+    print(pid[i], "\t", tat[i], "\t", wt[i])
+
+print("\nAverage TAT =", sum(tat)/n)
+print("Average WT =", sum(wt)/n)

oslabcode/templates/SC.py

@@ -0,0 +1,32 @@
+from threading import *
+import time
+
+queue = []
+max_size = 5
+
+def customer():
+    for i in range(1, 11):
+        while len(queue) == max_size:
+            pass
+
+        queue.append(i)
+        print("Customer", i, "arrived")
+        time.sleep(1)
+
+def counter():
+    for i in range(1, 11):
+        while len(queue) == 0:
+            pass
+
+        c = queue.pop(0)
+        print("Serving Customer", c)
+        time.sleep(2)
+
+t1 = Thread(target=customer)
+t2 = Thread(target=counter)
+
+t1.start()
+t2.start()
+
+t1.join()
+t2.join()

oslabcode/templates/SCAN.py

@@ -0,0 +1,24 @@
+req = list(map(int, input("Enter requests: ").split()))
+head = int(input("Enter initial head position: "))
+disk_size = int(input("Enter disk size: "))
+
+left = [x for x in req if x < head]
+right = [x for x in req if x >= head]
+
+left.sort()
+right.sort()
+
+seek = 0
+
+for r in right:
+    seek += abs(head - r)
+    head = r
+
+seek += abs(head - (disk_size - 1))
+head = disk_size - 1
+
+for r in reversed(left):
+    seek += abs(head - r)
+    head = r
+
+print("Total Seek Time =", seek)

oslabcode/templates/SJF.py

@@ -0,0 +1,47 @@
+n = int(input("Enter number of processes: "))
+
+pid = []
+at = []
+bt = []
+
+for i in range(n):
+    pid.append(input("Process ID: "))
+    at.append(int(input("Arrival Time: ")))
+    bt.append(int(input("Burst Time: ")))
+
+completed = [False] * n
+tat = [0] * n
+wt = [0] * n
+
+time = 0
+count = 0
+
+while count < n:
+
+    idx = -1
+    min_bt = 9999
+
+    for i in range(n):
+        if at[i] <= time and not completed[i]:
+            if bt[i] < min_bt:
+                min_bt = bt[i]
+                idx = i
+
+    if idx == -1:
+        time += 1
+        continue
+
+    time += bt[idx]
+
+    tat[idx] = time - at[idx]
+    wt[idx] = tat[idx] - bt[idx]
+
+    completed[idx] = True
+    count += 1
+
+print("\nPID\tTAT\tWT")
+for i in range(n):
+    print(pid[i], "\t", tat[i], "\t", wt[i])
+
+print("\nAverage TAT =", sum(tat)/n)
+print("Average WT =", sum(wt)/n)

oslabcode/templates/SRTF.py

@@ -0,0 +1,49 @@
+n = int(input("Enter number of processes: "))
+
+pid = []
+at = []
+bt = []
+
+for i in range(n):
+    pid.append(input("Process ID: "))
+    at.append(int(input("Arrival Time: ")))
+    bt.append(int(input("Burst Time: ")))
+
+remaining = bt.copy()
+
+tat = [0] * n
+wt = [0] * n
+
+time = 0
+completed = 0
+
+while completed < n:
+
+    idx = -1
+    shortest = 9999
+
+    for i in range(n):
+        if at[i] <= time and remaining[i] > 0:
+            if remaining[i] < shortest:
+                shortest = remaining[i]
+                idx = i
+
+    if idx == -1:
+        time += 1
+        continue
+
+    remaining[idx] -= 1
+    time += 1
+
+    if remaining[idx] == 0:
+        completed += 1
+
+        tat[idx] = time - at[idx]
+        wt[idx] = tat[idx] - bt[idx]
+
+print("\nPID\tTAT\tWT")
+for i in range(n):
+    print(pid[i], "\t", tat[i], "\t", wt[i])
+
+print("\nAverage TAT =", sum(tat)/n)
+print("Average WT =", sum(wt)/n)

oslabcode/templates/SSTF.py

@@ -0,0 +1,14 @@
+req = list(map(int, input("Enter requests: ").split()))
+head = int(input("Enter initial head position: "))
+
+seek = 0
+
+while req:
+    nearest = min(req, key=lambda x: abs(head - x))
+
+    seek += abs(head - nearest)
+    head = nearest
+
+    req.remove(nearest)
+
+print("Total Seek Time =", seek)

oslabcode/templates/WF.py

@@ -0,0 +1,16 @@
+blocks = list(map(int, input("Enter block sizes: ").split()))
+processes = list(map(int, input("Enter process sizes: ").split()))
+
+for i in range(len(processes)):
+    worst = -1
+
+    for j in range(len(blocks)):
+        if blocks[j] >= processes[i]:
+            if worst == -1 or blocks[j] > blocks[worst]:
+                worst = j
+
+    if worst != -1:
+        print("Process", i + 1, "allocated to Block", worst + 1)
+        blocks[worst] -= processes[i]
+    else:
+        print("Process", i + 1, "not allocated")

oslabcode-1.0.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: oslabcode
+Version: 1.0.0
+Summary: OS Lab code templates
+Requires-Python: >=3.8

oslabcode-1.0.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+oslabcode/__init__.py,sha256=0y91PW-fcytGzZxMWcdcVL1uY8YfJz4Qb4CVpB1hAXg,21
+oslabcode/cli.py,sha256=ApPk2pfg24qYX8YLjGLs6abpWNz8cf9gXnZxtg3vijw,2117
+oslabcode/templates/BF.py,sha256=gq9LaTtpoiKlr2Loz_moM0WYKm1zKbIpyNKZpUftnYM,522
+oslabcode/templates/Banker.py,sha256=PUx7UHuuF7Bb2N3SzeJU2JYPUDFvDsWVWycRL5FNAKI,1341
+oslabcode/templates/CLOOK.py,sha256=Qqj3g-WzfJs0JTAV23fO8r9T3dz8MmxXx0SUQS2IXPE,446
+oslabcode/templates/CSCAN.py,sha256=ut8G33kpv3wymQ7IZ-z6uTy0xdrOAeLSB8uKAbgnz2Q,522
+oslabcode/templates/FCFS_DS.py,sha256=uY2xtXafpnlCOof_PRdv0jY09mVWXecMxi-a3CKe32M,213
+oslabcode/templates/FCFS_PS.py,sha256=cRBz9ECdcnccnVD-2jRBJP70oc3DXXVJWngqt0yghyk,667
+oslabcode/templates/FF.py,sha256=J1ZoPtk1pddgCKz6bbzrJkF4dwv5UMffZGdeXfP7GQg,491
+oslabcode/templates/FIFO.py,sha256=OD9PGrPkvFfn4x6S0oXIoeBAasggJNybNjPgHlMtcPg,484
+oslabcode/templates/LFU.py,sha256=0CUyX_UlMCqs798yX2qA7UfLQ9FJRqdnOWRYlZVH9BU,679
+oslabcode/templates/LOOK.py,sha256=L-qTaAGRJEsHpj4-6yhpx7spggkmHyxIUJxlFUUDk9w,391
+oslabcode/templates/LRU.py,sha256=n5DjcXp1NFVcaw5J_q91WHs4G2stkaUlUk1c8tOJHcE,542
+oslabcode/templates/NF.py,sha256=QuS4L_BdArcyOy0D_7RRWnQm4G7jiy_lQrsg1tx4H-U,579
+oslabcode/templates/Optimal.py,sha256=rEsUL1VgkhWz6Jgo2ojmFy971UjHUT7wrF0DE8r5cbg,850
+oslabcode/templates/Priority.py,sha256=qh81yw0fZHRDE51tsw82MiW2yU1xicAESkKL67qAMrE,934
+oslabcode/templates/RR.py,sha256=uMCKxzfgfBGqzV3vSbKB-6SPTtbaxi2uNOtycTRKNg8,1002
+oslabcode/templates/SC.py,sha256=wHru8vTkMbmIUPxVV0V2Fo2f41KJYp4u8HicvJ4Abqk,555
+oslabcode/templates/SCAN.py,sha256=AvpZ6215wk15HoQ7_nP8oxMFasziomNdZmmdN_-H71Y,497
+oslabcode/templates/SJF.py,sha256=q6OHD40rn4ICFRH-ytPQWeJTDffkaej2VbbC4uYfsdk,881
+oslabcode/templates/SRTF.py,sha256=U6GenEd-r5z8nJrZMme8lYhwqDqAYPYytKr8oQvRHdY,946
+oslabcode/templates/SSTF.py,sha256=YNWcWm4sogc9eTK-i7znQdT3fuk_-PMnv-kPkEzpzrM,304
+oslabcode/templates/WF.py,sha256=VZLrbT2i-8j9H_RySeE3X3ahkmyGwBuw-Sbe2vi_RbI,529
+oslabcode-1.0.0.dist-info/METADATA,sha256=J_qy5oy1wLJjo5BlMw4f0te9aO3iLlE-cmHta6VDou4,112
+oslabcode-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+oslabcode-1.0.0.dist-info/entry_points.txt,sha256=gM6nkAQUkTL75fUs0VDX_sqJ9AdW-wZysOkHYI39b3s,49
+oslabcode-1.0.0.dist-info/top_level.txt,sha256=Ijo5NZgTe0tadQfi1ao35-Aq4GnVIUVOq2czB2arPCI,10
+oslabcode-1.0.0.dist-info/RECORD,,

oslabcode-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

oslabcode-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+oslabcode = oslabcode.cli:main

oslabcode-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+oslabcode