Automate Python Virtual Environment Setup on Linux Terminal

Q: Automate Python Virtual Environment Setup on Linux Terminal

This question evaluates proficiency in shell scripting and Linux terminal automation for Python virtual-environment setup, focusing on environment management, automation, and reproducibility skills relevant to data science workflows.

Q: How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

Q: What difficulty level is this coding question?

This is a Medium difficulty Coding & Algorithms question, commonly asked during Onsite rounds at Capital One.

Q: What role is this question designed for?

This question is commonly asked for Data Scientist candidates at Capital One during technical interviews.

Question

##### Scenario

Shell script that automates Python virtual-environment setup on a Linux terminal during a tech interview

##### Question

Walk through the script line-by-line and explain exactly what each command does. What advantages does writing this logic as a shell script provide compared with other approaches? Run the script in the terminal and describe the expected side-effects or files that should appear.

##### Hints

Think about shebang, `set -e`, `virtualenv`, `source`, permission bits, idempotency, and automation benefits such as reproducibility.

PracHub · Accepted Answer

from typing import List, Dict, Optional, Set, Tuple

class FSState:
    def __init__(self):
        # nodes: path -> 'dir' or 'file'
        self.nodes: Dict[str, str] = {}
        # file_exec: path -> bool (only for files)
        self.file_exec: Dict[str, bool] = {}
        # children: dir path -> set of immediate child paths
        self.children: Dict[str, Set[str]] = {}
        # environment
        self.env: Dict[str, Optional[str]] = {"ACTIVE_VENV": None}
        # initialize root directory
        self.nodes['/'] = 'dir'
        self.children['/'] = set()

def clone(self) -> 'FSState':
        c = FSState()
        c.nodes = dict(self.nodes)
        c.file_exec = dict(self.file_exec)
        c.children = {k: set(v) for k, v in self.children.items()}
        c.env = dict(self.env)
        return c

def is_idempotent_script(commands: List[str]) -> bool:
    def canon(path: str) -> str:
        s = path.strip()
        # collapse multiple slashes
        while '//' in s:
            s = s.replace('//', '/')
        s = s.strip('/')
        return '/' if s == '' else '/' + s

def parent(path: str) -> str:
        if path == '/':
            return '/'
        i = path.rfind('/')
        return '/' if i == 0 else path[:i]

def join(base: str, name: str) -> str:
        return '/' + name if base == '/' else base + '/' + name

def is_dir(st: FSState, p: str) -> bool:
        return st.nodes.get(p) == 'dir'

def is_file(st: FSState, p: str) -> bool:
        return st.nodes.get(p) == 'file'

def mkdir_p(st: FSState, p: str) -> Optional[str]:
        # returns None on success, or error message
        if p == '/':
            return None
        comps = p.strip('/').split('/')
        cur = '/'
        for comp in comps:
            nxt = join(cur, comp)
            if nxt in st.nodes:
                if is_file(st, nxt):
                    return f"mkdir blocked by file at {nxt}"
                # directory exists; continue
            else:
                # create directory
                st.nodes[nxt] = 'dir'
                st.children[nxt] = set()
                st.children[cur].add(nxt)
            cur = nxt
        return None

def touch(st: FSState, p: str) -> Optional[str]:
        par = parent(p)
        if not is_dir(st, par):
            return f"touch parent missing or not dir at {par}"
        if p in st.nodes:
            if is_dir(st, p):
                return f"touch path is directory at {p}"
            # file exists: no-op
            return None
        st.nodes[p] = 'file'
        st.file_exec[p] = False
        st.children[par].add(p)
        return None

def rm_rf(st: FSState, p: str) -> Optional[str]:
        if p not in st.nodes:
            return None
        if is_file(st, p):
            par = parent(p)
            if par in st.children and p in st.children[par]:
                st.children[par].remove(p)
            st.nodes.pop(p, None)
            st.file_exec.pop(p, None)
            return None
        # directory removal (recursive). Do not allow removing root '/'
        if p == '/':
            return "cannot remove root"
        # gather directories to remove
        order: List[str] = []
        stack: List[str] = [p]
        while stack:
            d = stack.pop()
            order.append(d)
            # iterate over a snapshot of children
            for child in list(st.children.get(d, set())):
                if is_dir(st, child):
                    stack.append(child)
                else:
                    # remove file child
                    st.children[d].remove(child)
                    st.nodes.pop(child, None)
                    st.file_exec.pop(child, None)
        # remove directories in reverse (deepest first)
        for d in reversed(order):
            # by now, d has only (possibly) dir children in st.children[d]
            # remove reference from parent
            par = parent(d)
            if par in st.children and d in

Quick Overview

Solution

Explanation

Hints

Quick Overview