ticket-processing 0.1.0__py3-none-any.whl

ticket_processing/__init__.py

@@ -0,0 +1,2 @@
+# ticket_processing/__init__.py
+from .ticket_processing import log, request_producer, validator, seat_locker, payment_worker, ticket_issuer, notifier, main

ticket_processing/ticket_processing.py

@@ -0,0 +1,310 @@
+import threading
+import time
+from threading import BrokenBarrierError
+
+requests_queue, valid_queue, locked_queue, paid_queue, notify_queue, threads = [], [], [], [], [], []
+requests_created, valid_ok, valid_fail, locked_ok, locked_fail, paid_ok, paid_fail, payment_workers_done, issued_count, notified_count, canceled_notifications = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+producer_done, validator_done, locker_done, payment_done, issuer_done = False, False, False, False, False
+
+start_event = threading.Event()
+shutdown_event = threading.Event()
+lock = threading.Lock()
+cond = threading.Condition(lock)
+payment_slots = threading.Semaphore(3)
+seat_reservation = threading.BoundedSemaphore(5)
+barrier = threading.Barrier(4)
+
+
+def log(msg: str):
+    now = time.strftime("%H:%M:%S")
+    name = threading.current_thread().name
+    print(f"[{now}] ({name}) {msg}")
+
+
+def request_producer(total_requests=20):
+    global requests_created, producer_done
+
+    start_event.wait()
+    log("Started")
+
+    with cond:
+        for request_id in range(1, total_requests + 1):
+            requests_queue.append({
+                "request_id": request_id,
+                "user_id": (request_id % 7) + 1,
+                "seat_count": 1 if request_id % 3 else 2
+            })
+            requests_created += 1
+            log(f"Created request: {request_id} | requests_queue: {len(requests_queue)}")
+        producer_done = True
+        cond.notify_all()
+
+    log("Finished")
+
+
+def validator():
+    global valid_ok, valid_fail, validator_done
+
+    start_event.wait()
+    log("Started")
+
+    while True:
+        with cond:
+            while not requests_queue and not producer_done and not shutdown_event.is_set():
+                log("Waiting for requests...")
+                cond.wait(timeout=1)
+
+            if shutdown_event.is_set():
+                log("Shutdown detected -> exiting")
+                break
+
+            if not requests_queue and producer_done:
+                validator_done = True
+                cond.notify_all()
+                log("No more requests & producer_done=True -> validator_done=True")
+                break
+
+            req = requests_queue.pop(0)
+            log(f"Picked request={req} from requests_queue | left={len(requests_queue)}")
+
+        time.sleep(.05)
+
+        user_id = req["user_id"]
+        seat_count = req["seat_count"]
+
+        with cond:
+            if (user_id % 2 != 0) or (seat_count < 1 or seat_count > 2):
+                valid_fail += 1
+                log(f"Validation FAILED request={req}")
+            else:
+                valid_ok += 1
+                valid_queue.append(req)
+                log(f"Validated Ok request={req} and valid_queue={len(valid_queue)}")
+            cond.notify_all()
+
+    log("Finished")
+
+
+def seat_locker():
+    global locked_ok, locked_fail, locker_done
+
+    start_event.wait()
+    log("Started")
+
+    while True:
+        with cond:
+            while not valid_queue and not validator_done and not shutdown_event.is_set():
+                log("Waiting for valid requests...")
+                cond.wait(timeout=1)
+
+            if shutdown_event.is_set():
+                log("Shutdown detected -> exiting")
+                break
+
+            if not valid_queue and validator_done:
+                locker_done = True
+                cond.notify_all()
+                log("No more valid requests & validator_done=True -> locker_done=True")
+                break
+
+            req = valid_queue.pop(0)
+            log(f"Picked req={req} from valid queue | left={len(valid_queue)}")
+
+        acquired = seat_reservation.acquire(timeout=2)
+        with cond:
+            if acquired:
+                locked_ok += 1
+                locked_queue.append(req)
+                log(f"Seat LOCKED req={req} | locked_queue={len(locked_queue)}")
+            else:
+                locked_fail += 1
+                log(f"Seat LOCK FAILED timeout req={req}")
+
+            cond.notify_all()
+
+    log("Finished")
+
+
+def payment_worker(payment_workers_total=1):
+    global paid_ok, paid_fail, payment_done, payment_workers_done
+
+    start_event.wait()
+    log("Started")
+
+    while True:
+        with cond:
+            while not locked_queue and not locker_done and not shutdown_event.is_set():
+                log("Waiting for locked requests...")
+                cond.wait(timeout=1)
+
+            if shutdown_event.is_set():
+                log("Shutdown detected -> exiting")
+                break
+
+            if not locked_queue and locker_done:
+                payment_workers_done += 1
+                if payment_workers_done == payment_workers_total:
+                    payment_done = True
+                    cond.notify_all()
+                    log("All payment workers done -> payment_done=True")
+                break
+
+            req = locked_queue.pop(0)
+            log(f"Picked req={req} from locked_queue | left={len(locked_queue)}")
+
+        acquired = payment_slots.acquire(timeout=2)
+        if not acquired:
+            with cond:
+                paid_fail += 1
+                seat_reservation.release()
+                log(f"Payment slot timeout -> FAILED req={req}")
+                cond.notify_all()
+            continue
+
+        try:
+            is_paid = req["request_id"] % 5 != 0
+            time.sleep(.08)
+
+            with cond:
+                if is_paid:
+                    paid_ok += 1
+                    paid_queue.append(req)
+                    log(f"Payment OK req={req} | paid_queue={len(paid_queue)}")
+                else:
+                    paid_fail += 1
+                    seat_reservation.release()
+                    log(f"Payment FAILED req={req} (rule)")
+                cond.notify_all()
+        finally:
+            payment_slots.release()
+
+    log("Finished")
+
+
+def ticket_issuer():
+    global issued_count, issuer_done
+
+    start_event.wait()
+    log("Started")
+
+    while True:
+        with cond:
+            while not paid_queue and not payment_done and not shutdown_event.is_set():
+                log("Waiting for paid queue...")
+                cond.wait(timeout=1)
+
+            if shutdown_event.is_set():
+                log("Shutdown detected -> exiting")
+                break
+
+            if not paid_queue and payment_done:
+                issuer_done = True
+                cond.notify_all()
+                break
+
+            req = paid_queue.pop(0)
+            log(f"Picked req={req} from paid queue | left={len(paid_queue)}")
+
+        time.sleep(.05)
+
+        with cond:
+            issued_count += 1
+            notify_queue.append(req)
+            cond.notify_all()
+
+    log("Finished")
+
+
+def notifier():
+    global notified_count, canceled_notifications
+
+    start_event.wait()
+    log("Started")
+
+    while True:
+        with cond:
+            while not notify_queue and not issuer_done and not shutdown_event.is_set():
+                log("Waiting for issuer...")
+                cond.wait(timeout=1)
+
+            if shutdown_event.is_set() and not notify_queue:
+                log("Shutdown + no notify -> exiting")
+                break
+
+            if issuer_done and not notify_queue:
+                log("Issuer done + notify_queue empty -> exiting")
+                break
+
+            if not notify_queue:
+                continue
+
+            req = notify_queue.pop(0)
+            log(f"Picked req={req} from notify queue | left={len(notify_queue)}")
+
+        try:
+            idx = barrier.wait(timeout=2)
+            with cond:
+                notified_count += 1
+                log(f"Barrier passed (idx={idx}) -> req={req}")
+                cond.notify_all()
+        except BrokenBarrierError:
+            with cond:
+                canceled_notifications += 1
+                log(f"Barrier broken -> canceled req={req}")
+                cond.notify_all()
+
+    log("Finished")
+
+
+def main():
+    threads.append(threading.Thread(target=request_producer, name="Request_producer-1"))
+    threads.append(threading.Thread(target=validator, name="Validator-1"))
+    threads.append(threading.Thread(target=seat_locker, name="Seat_locker-1"))
+    threads.append(threading.Thread(target=payment_worker, name="Payment_worker-1"))
+    threads.append(threading.Thread(target=ticket_issuer, name="Ticket_issuer-1"))
+
+    for i in range(1, 5):
+        n = threading.Thread(target=notifier, name=f"Notifier-{i}")
+        threads.append(n)
+
+    for t in threads:
+        t.start()
+
+    log("All thread started. Releasing start_event...")
+    start_event.set()
+
+    deadline = time.monotonic() + 10
+    for t in threads:
+        remain = deadline - time.monotonic()
+        if remain > 0:
+            t.join(timeout=remain)
+
+    alive = [t for t in threads if t.is_alive()]
+    if alive:
+        log(f"Some threads still alive ({len(alive)}). Triggering shutdown...")
+        shutdown_event.set()
+        with cond:
+            cond.notify_all()
+        try:
+            barrier.abort()
+            log("Barrier aborted")
+        except RuntimeError:
+            pass
+
+        for t in alive:
+            t.join(timeout=3)
+
+    with cond:
+        log("=== FINAL REPORT ===")
+        log(f"request created={requests_created}")
+        log(f"valid_ok={valid_ok}, valid_fail={valid_fail}")
+        log(f"locked_ok={locked_ok}, locked_fail={locked_fail}")
+        log(f"paid_ok={paid_ok}, paid_fail={paid_fail}")
+        log(f"issued_count={issued_count}")
+        log(f"notified count={notified_count}, canceled_notifications={canceled_notifications}")
+        log(f"remaining queues -> req={len(requests_queue)}, valid={len(valid_queue)}, locked={len(locked_queue)}, paid={len(paid_queue)}, notify={len(notify_queue)}")
+        log("=== END ===")
+
+
+if __name__ == "__main__":
+    main()

ticket_processing-0.1.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: ticket-processing
+Version: 0.1.0
+Summary: A simple application for purchasing and processing tickets
+Home-page: https://github.com/zZ72ehsan74Zz/ticket-processing
+Author: ehsan bahmanipor
+Author-email: eh.bahmanipor@gamil.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# Ticket Processing
+A simple application for purchasing and processing tickets.
+The features of this program are as follows:
+
+1) Request producer
+2) Validator
+3) Seat locker
+4) Payment worker
+5) Ticket issuer
+6) Notifier
+
+And it is implemented based on multithreading.
+
+## Installation
+```bash
+pip install ticket-processing

ticket_processing-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+ticket_processing/__init__.py,sha256=ElCF8FKlO1v7sofL-ORTz42vlKQQDRDMtf_oIYINOvw,156
+ticket_processing/ticket_processing.py,sha256=p-2HyWi2WOxf1oHEXgFBCB8nfZGAUUAXKciOabRZ--U,10018
+ticket_processing-0.1.0.dist-info/METADATA,sha256=XUZTtEKXHeTZz5RNAR_UC9Pc4B9gVERXPB9uIcQtDvs,999
+ticket_processing-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ticket_processing-0.1.0.dist-info/top_level.txt,sha256=W-hRATwDFBlQGmh-ZywDZ9HVLzDWXYSadFncv_pmDCE,18
+ticket_processing-0.1.0.dist-info/RECORD,,

ticket_processing-0.1.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
+

ticket_processing-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ticket_processing