sem6labs 0.1.0__tar.gz

sem6labs-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include sem6/scaffold *

sem6labs-0.1.0/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: sem6labs
+Version: 0.1.0

sem6labs-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

sem6labs-0.1.0/sem6labs/scaffold/1) BFS_DFS.py

@@ -0,0 +1,55 @@
+from collections import defaultdict, deque
+
+#class for dfs and bfs
+
+class Graph:
+  def __init__(self):
+    self.graph = defaultdict(list);
+  def add_edge(self, u, v):
+    self.graph[u].append(v)
+    self.graph[v].append(u)
+    
+  # DFS  
+
+  def dfsRecursive(self, vertex, visitedNode=None):
+    if visitedNode is None:
+      visitedNode = set()
+    visitedNode.add(vertex)
+    print(vertex,end=" ")
+    for neighbour in self.graph[vertex]:
+      if neighbour not in visitedNode:
+        self.dfsRecursive(neighbour,visitedNode)
+  
+  #BFS
+
+  def bfs(self,start):
+    visited=set();
+    queue = deque([start])
+    visited.add(start);
+    while queue:
+      vertex = queue.popleft()
+      print(vertex,end=" ")
+      for neighbour in self.graph[vertex]:
+        if neighbour not in visited:
+          queue.append(neighbour)
+          visited.add(neighbour)
+
+
+g = Graph()
+edges=[(0,1),(0,2),(1,3),(1,4),(2,5),(2,6),(3,7),(4,8),(5,9),(6,10)]
+for u,v in edges:
+  g.add_edge(u,v)
+  
+start = int(input("Enter Starting Node : "))
+
+# printing the output
+
+print(f"\ndepth first search starting from vertex {start} :")
+g.dfsRecursive(start)   
+print("\n")
+
+print(f"breadth first search starting from vertex {start} :")
+g.bfs(start)
+
+print("\n")
+print('-' * 20)

sem6labs-0.1.0/sem6labs/scaffold/2) AStar.py

@@ -0,0 +1,67 @@
+import heapq
+
+#Class for A-star algorithm
+
+class a_star:
+  def __init__(self, grid, start, goal):
+    self.grid = grid
+    self.start = start
+    self.goal = goal
+    self.rows = len(grid)
+    self.coloumn = len(grid[0])
+
+  def heuristic(self,node):
+    return abs(node[0]-self.goal[0] + abs(node[1]-self.goal[1]))
+
+  def nebighbors(self,node):
+    dirs = [(0,1),(1,0),(0,-1),(-1,0)]
+    result =[]
+    for d in dirs:
+      nebighbor = (node[0]+d[0],node[1]+d[1])
+      if 0<=nebighbor[0]<self.rows and 0<=nebighbor[1]<self.coloumn:
+        if self.grid[nebighbor[0]][nebighbor[1]]==0:
+          result.append(nebighbor)
+    return result
+  
+  def reconstruct_path(self, came_from, current):
+    total_path = [current]
+    while current in came_from:
+      current = came_from[current]
+      total_path.append(current)
+    return total_path[::-1]
+  
+  #A-star
+  
+  def a_star_search(self):
+    open_list=[]
+    heapq.heappush(open_list,(0,self.start))
+    came_from={}
+    g_score={self.start:0}
+    f_score={self.start:self.heuristic(self.start)}
+    while open_list:
+      current = heapq.heappop(open_list)[1]
+      if current == self.goal:
+        return self.reconstruct_path(came_from,current)
+      
+      for neighbor in self.nebighbors(current):
+        tentaive_g_score = g_score[current]+1
+        if neighbor not in g_score or tentaive_g_score < g_score[neighbor]:
+          came_from[neighbor] = current
+          g_score[neighbor]=tentaive_g_score
+          f_score[neighbor]=tentaive_g_score + self.heuristic(neighbor)
+          heapq.heappush(open_list,(f_score[neighbor],neighbor))
+    return []
+
+grid = [
+  [0,1,0,1,0],
+  [0,1,0,1,0],
+  [0,0,0,1,0],
+  [1,1,0,1,0],
+  [0,0,0,0,0]
+]
+
+start, goal = (0,1),(4,0)
+aStar = a_star(grid,start,goal)
+print("\nPath from start to global : ",aStar.a_star_search())
+
+print('\n', '-' * 30)

sem6labs-0.1.0/sem6labs/scaffold/3) GreedySearch_SSSP.py

@@ -0,0 +1,79 @@
+class Dijkstra:
+    def __init__(self) -> None:
+        self.vertices = int(input("Enter number of vertices: "))
+        self.graph = [[float('inf')]*self.vertices for _ in range(self.vertices)]
+
+        self.edges = int(input("Enter number of edges: "))
+        print()
+        print("Start End Distance")
+
+        edges_added = 0
+        while edges_added < self.edges:
+            try:
+                v1, v2, e = input().split(" ")
+                v1, v2, e = int(v1), int(v2), int(e)
+                if v1 == v2:
+                    print("Self-loops not allowed, re-enter")
+                    continue
+                if not (1 <= v1 <= self.vertices) or not (1 <= v2 <= self.vertices):
+                    print(f"Invalid. Enter values between 1 and {self.vertices}")
+                    continue
+                self.graph[v1-1][v2-1] = e
+                self.graph[v2-1][v1-1] = e
+                edges_added += 1  # only increments on valid input
+            except ValueError:
+                print("Invalid input. Enter: start end distance")
+        
+        for i in range(self.vertices):
+            self.graph[i][i] = 0
+    
+    def printMatrix(self):
+        print()
+        print("\t",end="")
+        for i in range(self.vertices):
+            print(i+1,end="\t")
+        print()
+        for i,row in enumerate(self.graph):
+            print(i+1,end="\t")
+            for ele in row:
+                print(ele,end="\t")
+            print()
+        print()
+    
+    def solve(self):
+        source = int(input("Enter starting node : "))
+        print()
+        if not (1 <= source <= self.vertices):
+            print(f"Enter a value between 1 and {self.vertices}")
+            return
+        visited = set()
+        distances = [float('inf')] * self.vertices
+        distances[source - 1] = 0
+
+        while True:
+            minDist = float('inf')
+            minId = -1
+            for i,dist in enumerate(distances):
+                if dist < minDist and i not in visited:
+                    minDist = dist
+                    minId = i
+            
+            if minId == -1:
+                break
+
+            for i,distance in enumerate(self.graph[minId]):
+                if distances[i] > minDist + distance:
+                    distances[i] = minDist + distance
+            visited.add(minId)
+        
+        print(f"Distances from source {source}:")
+        for i,distance in enumerate(distances):
+            print(f"Distance to {i+1}: {distance}")
+
+
+
+solver = Dijkstra()
+solver.printMatrix()
+solver.solve()
+
+print('\n', '-' * 40)

sem6labs-0.1.0/sem6labs/scaffold/4) CSP_using_Nqueens.py

@@ -0,0 +1,61 @@
+import time
+
+def print_board(board):
+  for row in board:
+    print(" ".join("Q" if col else "." for col in row))
+  print()
+
+def is_safe(board, row, col, n):
+  for i in range(row):
+    if board[i][col]:return False
+  for i,j in zip(range(row-1,-1,-1),range(col-1,-1,-1)):
+    if board[i][j]:return False
+  for i,j in zip(range(row-1,-1,-1),range(col+1,n)):
+    if board[i][j]:return False
+  return True
+
+#solving n-queens using backtracking 
+
+def solve_bt(board,row,n):
+  if row == n:
+    print_board(board)
+    return True
+  for col in range(n):
+    if is_safe(board, row, col, n):
+      board[row][col]=True
+      if solve_bt(board, row+1, n) : return True
+      board[row][col]=False
+  return False     
+
+#solving n-queens using branch-n-bound
+
+def solve_bnb(row,n,cols,d1,d2,board):
+  if row == n:
+    print_board(board)
+    return True
+  for col in range(n):
+    if not (cols[col] or d1[row + col] or d2[row - col + (n-1)]):
+      board[row][col] = cols[col] = d1[row + col] = d2[row - col + (n-1)] = True
+      if solve_bnb(row+1, n, cols, d1, d2, board) : return True
+      board[row][col] = cols[col] = d1[row + col] = d2[row - col + (n-1)] = False
+  return False
+
+# taking input from user
+
+n = int(input("Enter Number N : "))
+print()
+
+print("Backtracking:\n")
+start = time.time()
+solve_bt([[False]*n for _ in range(n)],0,n)
+end = time.time()
+print(f"Time required: {(end - start) * 1000:.2f} ms")
+print()
+
+print("Branch and Bound:\n")
+start = time.time()
+solve_bnb(0, n, [False] * n, [False] * (2*n-1), [False] * (2*n-1), [[False] * n for _ in range(n)])
+end = time.time()
+print(f"Time required: {(end - start) * 1000:.2f} ms")
+
+print('\n', '-' * 40)

sem6labs-0.1.0/sem6labs/scaffold/5) Elementary_chatbot.py

@@ -0,0 +1,56 @@
+from nltk.chat.util import Chat,reflections
+
+pairs = [
+    [
+        r"My name is (.*)",
+        ["Hello %1. How are you today?","How may I help you?"]
+    ],
+    [
+        r"(.*) name?",
+        ["I am a Chatbot. I don't have a particular name"]
+    ],
+    [
+        r"How are you?",
+        ["I am fine.","I am always happy to help"]
+    ],
+    [
+        r"I am doing good",
+        ["Nice to hear that"]
+    ],
+    [
+        r"Hi|Hello|Hey|hi|hello",
+        ["Hey there","hello"]
+    ],
+    [
+        r"(.*) created?",
+        ["I was made by a computer programmer"]
+    ],
+    [
+        r"(.*) investments|money?",
+        ["There are many options to invest money like mutual funds, regional banks, etc."]
+    ],
+    [
+        r"(.*) stocks?",
+        ["There are many companies to invest your money in."]
+    ],
+    [
+        r"(.*) companies (.*) money?",
+        ["Amazon,Tesla"]
+    ],
+    [
+        r"(.*)", 
+        ["I'm not sure how to respond to that. Could you rephrase?"]
+    ],
+    [
+        r"quit", 
+        ["exiting chatbot"]
+    ]
+]
+
+def chat():
+    print("Hello I am a chatbot.Type 'quit' to exit")
+    obj = Chat(pairs,reflections)
+    obj.converse()
+chat()
+
+print('\n', '-' * 40)

sem6labs-0.1.0/sem6labs/scaffold/6) expertSystem_SMT.py

@@ -0,0 +1,53 @@
+def get_float(prompt):
+    while True:
+        try: return float(input(prompt))
+        except ValueError: print("Invalid input")
+
+def analyze(price, ma, rsi, vol, avg_vol, pe, eps):
+    signals = []
+    if price < ma: signals.append("Price below moving average (bearish trend)")
+    else: signals.append("Price above moving average (bullish trend)")
+    if rsi < 30: signals.append("RSI oversold - potential buy opportunity")
+    elif rsi > 70: signals.append("RSI overbought - potential sell opportunity")
+    else: signals.append("RSI neutral")
+    if vol > avg_vol * 1.5: signals.append("High volume - strong market conviction")
+    elif vol < avg_vol * 0.5: signals.append("Low volume - weak market conviction")
+    if pe < 15: signals.append("Low P/E - potentially undervalued")
+    elif pe > 30: signals.append("High P/E - potentially overvalued")
+    if eps > 0: signals.append("Positive EPS - company is profitable")
+    else: signals.append("Negative EPS - company is at a loss")
+
+    buys  = sum(1 for s in signals if "buy" in s.lower() or "undervalued" in s.lower() or "profitable" in s.lower())
+    sells = sum(1 for s in signals if "sell" in s.lower() or "overvalued" in s.lower() or "loss" in s.lower())
+
+    print("\n--- Analysis ---")
+    for s in signals: print(f"  • {s}")
+    print(f"\nBuy signals: {buys} | Sell signals: {sells}")
+    if buys > sells + 1:   
+        print("Recommendation: STRONG BUY")
+    elif buys > sells:     
+        print("Recommendation: BUY")
+    elif sells > buys + 1: 
+        print("Recommendation: STRONG SELL")
+    elif sells > buys:     
+        print("Recommendation: SELL")
+    else:                  
+        print("Recommendation: HOLD")
+
+while True:
+    print("\n=== Stock Market Expert System ===")
+    print("1. Evaluate Stock\n2. Exit")
+    choice = input("Choice: ")
+    if choice == "2": break
+    elif choice == "1":
+        stock  = input("Stock symbol: ").upper()
+        price  = get_float("Current price: ")
+        ma     = get_float("50-day moving average: ")
+        rsi    = get_float("RSI (0-100): ")
+        vol    = get_float("Today's volume: ")
+        avg    = get_float("Average volume: ")
+        pe     = get_float("P/E ratio: ")
+        eps    = get_float("EPS: ")
+        print(f"\nEvaluating {stock}...")
+        analyze(price, ma, rsi, vol, avg, pe, eps)
+    else: print("Invalid choice")

sem6labs-0.1.0/sem6labs/scaffold/KVM_installation.txt

@@ -0,0 +1,14 @@
+Installation
+- sudo apt install cpu-checker
+
+- sudo kvm-ok
+
+- sudo apt install -y qemu qemu-kvm libvirt-daemon libvirt-clients bridge-utils virt-manager
+
+- sudo systemctl status libvirtd
+
+- sudo systemctl enable --now libvirtd
+
+Configuration
+
+- sudo virt-manager

sem6labs-0.1.0/sem6labs.egg-info/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: sem6labs
+Version: 0.1.0

sem6labs-0.1.0/sem6labs.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+MANIFEST.in
+pyproject.toml
+setup.py
+sem6labs/__init__.py
+sem6labs.egg-info/PKG-INFO
+sem6labs.egg-info/SOURCES.txt
+sem6labs.egg-info/dependency_links.txt
+sem6labs.egg-info/top_level.txt
+sem6labs/scaffold/1) BFS_DFS.py
+sem6labs/scaffold/2) AStar.py
+sem6labs/scaffold/3) GreedySearch_SSSP.py
+sem6labs/scaffold/4) CSP_using_Nqueens.py
+sem6labs/scaffold/5) Elementary_chatbot.py
+sem6labs/scaffold/6) expertSystem_SMT.py
+sem6labs/scaffold/KVM_installation.txt

sem6labs-0.1.0/sem6labs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sem6labs-0.1.0/sem6labs.egg-info/top_level.txt

@@ -0,0 +1 @@
+sem6labs

sem6labs-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sem6labs-0.1.0/setup.py

@@ -0,0 +1,24 @@
+import os
+import shutil
+from setuptools import setup, find_packages
+from setuptools.command.install import install
+
+class CustomInstall(install):
+    def run(self):
+        install.run(self)
+        dest = os.getcwd()
+        # locate scaffold relative to setup.py itself
+        scaffold_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'sem6labs', 'scaffold')
+        for filename in os.listdir(scaffold_dir):
+            src = os.path.join(scaffold_dir, filename)
+            shutil.copy2(src, dest)
+            print(f"Installed: {filename} → {dest}")
+
+setup(
+    name='sem6labs',
+    version='0.1.0',
+    packages=find_packages(),
+    package_data={'sem6labs': ['scaffold/*']},
+    include_package_data=True,
+    cmdclass={'install': CustomInstall},
+)