Backend first commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1 +1,12 @@
-test1
+---
+title: Endpoint
+emoji: 😻
+colorFrom: gray
+colorTo: green
+sdk: gradio
+sdk_version: 5.23.1
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,127 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from inference import ObjectDetector
+import numpy as np
+import cv2
+from receipt_processor.google_ocr import GoogleVisionOCR
+from receipt_processor.receipt_parser import ReceiptParser
+
+# Configuration
+MODEL_ONNX_PATH = "model.onnx"
+CLASS_NAMES = [
+    'Dukat_Maslac_250g_1',
+    'Z-Bregov_Maslac_250g_1',
+    'Zdenka_Maslac_250g_1',
+    'President_Gouda-Sir_250g_1',
+    'Cekin_Pileća-Prsa_500g_1',
+    'Franck_Crema-Kava_175g_1',
+    'Franck_Crema-Kava_250g_1',
+    'Franck_Instant-Crema-Kava_80g_1',
+    'Franck_Intense-Kava_250g_1',
+    'Franck_Original-Kava_250g_1',
+    'Franck_Sensual-Kava_250g_1',
+    'Coca-Cola_Coca-Cola-Original_1l_1',
+    'Mlineta_Oštro-Brašno_1kg_1',
+    'Vindi_Naranča-Nektar_1l_1',
+    'Zvijezda_Mild-Ketchup_500g_1',
+    'Zvijezda_Delicate-Majoneza_400g_1',
+    'Z-Bregov_Trajno-Mlijeko-2.8%_1l_1',
+    'Dijamant_Suncokretovo-Ulje_1l_1',
+    'Zvijezda_Suncokretovo-Ulje_1l_1',
+    'Barilla_Fusilli-Tijesto_500g_1',
+    'Gallo_Riža_900g_1',
+    'Kplus_Riža_1kg_1',
+    'Solana-Pag_Sitna-Sol_1kg_1',
+    'Pasta-Zara_Spaghettini-Tijesto_500g_1',
+    'Rio-Mare_Konzervativna-Tuna_150g_1'
+]
+INPUT_SIZE = 640
+
+# Initialize detector
+detector = ObjectDetector(
+    model_path=MODEL_ONNX_PATH,
+    class_names=CLASS_NAMES,
+    input_size=INPUT_SIZE
+)
+ocr_processor = GoogleVisionOCR()
+receipt_parser = ReceiptParser()
+# Initialize FastAPI
+app = FastAPI()
+
+# Enhanced CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["*"]
+)
+
+@app.options("/detect")
+async def detect_options():
+    return {"Allow": "POST"}
+
+@app.get("/")
+def health_check():
+    return {"status": "OK", "model": "Object Detection API"}
+
+@app.post("/detect")
+async def detect_objects(file: UploadFile = File(...)):
+    try:
+        if not file.content_type.startswith("image/"):
+            raise HTTPException(400, "File must be an image")
+
+        image_data = await file.read()
+        image = cv2.imdecode(np.frombuffer(image_data, np.uint8), cv2.IMREAD_COLOR)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # <<< ADD THIS LINE
+        if image is None:
+            raise HTTPException(400, "Invalid image data")
+
+        # Remove RGB conversion - models expect BGR from OpenCV
+        # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # DELETE THIS LINE
+        
+        # Fix variable reference
+        detections = detector.predict(image)  # Add this line
+        
+        return {
+            "status": "success",
+            "detections": detections,  # Use the variable
+            "count": len(detections)   # Now properly defined
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Processing error: {str(e)}")
+
+# Add new endpoint
+@app.post("/receipt-ocr")
+async def process_receipt(file: UploadFile = File(...)):
+    try:
+        if not file.content_type.startswith("image/"):
+            raise HTTPException(400, "File must be an image")
+
+        content = await file.read()
+        extracted_text = ocr_processor.extract_text(content)
+        
+        if not extracted_text:
+            raise HTTPException(400, "No text extracted from image")
+
+        parsed_receipt = receipt_parser.parse_receipt_text(extracted_text)
+        
+        return {
+            "status": "success",
+            "receipt": parsed_receipt
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Receipt processing error: {str(e)}")
+
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)  # Hugging Face requires port 7860

inference.py

@@ -0,0 +1,113 @@
+import numpy as np
+import cv2
+import onnxruntime as ort
+from typing import List, Dict, Tuple
+
+class ObjectDetector:
+    def __init__(self, model_path: str, class_names: List[str], input_size: int = 640):
+        self.class_names = class_names
+        self.input_size = input_size
+        self.session = self._load_model(model_path)
+        self._warmup()
+
+    def _load_model(self, model_path: str) -> ort.InferenceSession:
+        options = ort.SessionOptions()
+        options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        return ort.InferenceSession(
+            model_path,
+            providers=['CUDAExecutionProvider', 'CPUExecutionProvider'],
+            sess_options=options
+        )
+
+    def _warmup(self):
+        dummy_input = np.random.randn(1, 3, self.input_size, self.input_size).astype(np.float32)
+        self.session.run(None, {"images": dummy_input})
+
+    @staticmethod
+    def compute_iou(box: np.ndarray, boxes: np.ndarray) -> np.ndarray:
+        xmin = np.maximum(box[0], boxes[:, 0])
+        ymin = np.maximum(box[1], boxes[:, 1])
+        xmax = np.minimum(box[2], boxes[:, 2])
+        ymax = np.minimum(box[3], boxes[:, 3])
+        
+        intersection_area = np.maximum(0, xmax - xmin) * np.maximum(0, ymax - ymin)
+        box_area = (box[2] - box[0]) * (box[3] - box[1])
+        boxes_area = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+        
+        return intersection_area / (box_area + boxes_area - intersection_area + 1e-6)
+
+    @staticmethod
+    def nms(boxes: np.ndarray, scores: np.ndarray, iou_threshold: float) -> List[int]:
+        sorted_indices = np.argsort(scores)[::-1]
+        keep_boxes = []
+        
+        while sorted_indices.size > 0:
+            box_id = sorted_indices[0]
+            keep_boxes.append(box_id)
+            ious = ObjectDetector.compute_iou(boxes[box_id, :], boxes[sorted_indices[1:], :])
+            keep_indices = np.where(ious < iou_threshold)[0]
+            sorted_indices = sorted_indices[keep_indices + 1]
+        return keep_boxes
+
+    def preprocess(self, image: np.ndarray) -> Tuple[np.ndarray, float, Tuple[int, int]]:
+        h, w = image.shape[:2]
+        scale = min(self.input_size / h, self.input_size / w)
+        new_h, new_w = int(h * scale), int(w * scale)
+        
+        resized = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+        canvas = np.full((self.input_size, self.input_size, 3), 114, dtype=np.uint8)
+        ph, pw = (self.input_size - new_h) // 2, (self.input_size - new_w) // 2
+        canvas[ph:ph+new_h, pw:pw+new_w] = resized
+        
+        blob = canvas.astype(np.float32) / 255.0
+        return blob.transpose(2, 0, 1)[None, ...], scale, (pw, ph)
+
+    def postprocess(
+        self,
+        predictions: np.ndarray,
+        original_shape: Tuple[int, int],
+        scale: float,
+        padding: Tuple[int, int],
+        conf_threshold: float = 0.3,
+        iou_threshold: float = 0.45
+    ) -> List[Dict]:
+        predictions = np.squeeze(predictions).T
+        scores = np.max(predictions[:, 4:], axis=1)
+        valid = scores > conf_threshold
+        predictions = predictions[valid]
+        
+        if predictions.size == 0:
+            return []
+
+        boxes = predictions[:, :4]
+        boxes[:, [0, 1]] = boxes[:, [0, 1]] - boxes[:, [2, 3]] / 2
+        boxes[:, [2, 3]] = boxes[:, [0, 1]] + boxes[:, [2, 3]]
+        
+        pad_w, pad_h = padding
+        boxes[:, [0, 2]] = (boxes[:, [0, 2]] - pad_w) / scale
+        boxes[:, [1, 3]] = (boxes[:, [1, 3]] - pad_h) / scale
+        
+        h, w = original_shape
+        boxes[:, [0, 2]] = boxes[:, [0, 2]].clip(0, w)
+        boxes[:, [1, 3]] = boxes[:, [1, 3]].clip(0, h)
+        
+        class_ids = np.argmax(predictions[:, 4:], axis=1)
+        indices = self.nms(boxes, scores[valid], iou_threshold)
+        
+        return [{
+            "class": self.class_names[int(class_ids[i])],
+            "confidence": float(scores[valid][i]),
+            "bbox": boxes[i].tolist(),
+            "bbox_normalized": [
+                float((boxes[i][0] + boxes[i][2])/2 / w),
+                float((boxes[i][1] + boxes[i][3])/2 / h),
+                float((boxes[i][2] - boxes[i][0]) / w),
+                float((boxes[i][3] - boxes[i][1]) / h)
+            ]
+        } for i in indices]
+
+    def predict(self, image: np.ndarray) -> List[Dict]:
+        """Main prediction method"""
+        input_tensor, scale, padding = self.preprocess(image)
+        outputs = self.session.run(None, {"images": input_tensor})
+        return self.postprocess(outputs[0], image.shape[:2], scale, padding)

model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b42cdb2b3e5a7e706f8f03d3541324a3d7d3f5da4de71e9b3769e981d2d22b9
+size 103663101

receipt-vision-key.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "singular-cache-417619",
+  "private_key_id": "654a5fedb5f0b75c770321448ea36510da45e347",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDfp8lRIZWfmjvC\nn5GHKlWdplBSdUSLv57J3KWb0yDx1WZ+G3W7/vYeyn1QhSnFXe7p990A2NZD7Lbx\nYTfeUD2+msj3GQeKq1c7EwLvPNiy5HRTxdk33LkE066BD9icvS34ZvGAgMQxdy1f\nH3BebAr+7A5uZeMz+TmN+r+flbsp4oabA++qafUFGVZqn3GG+9+3cnhZlhhna8GR\nQPQgX43GXD9eVLzVtjdVGRg4CVwjSn/rR33+MkEqoxBKAb3t86KNevvRvAqCVRgK\nHw+/VDdJrD4tCDCDxNapIpF9s6ZnrFhKK8yzRUNqgj5FMQX7cTJ2b5lpR1Ucwogq\neXaof3nlAgMBAAECggEAIS1Q3A/lE+SrdkK48gnJ4wWzlxPNvARMIAoy5+NhGPas\nykq1A5L9/BHSFpJ2YJB/WyY5WsGPwUo5ViOzh680BZUM+Di2iW/C1CDNF+OZCqqA\nhhfMkfCUYp6rHXqWCaQ3kEhnDUass+DHsntlriANXoTyXBaRpllTXBgk+l2aAsuQ\nZdGYSaMAM1vpK7yp+TwdBteefrE7BgE+rareh/tU9Dhq6rzJq8S3t5m+lJa8e+sw\nUPW9HjlP+Q9W5MQPf6cXiUmhoo+OXKkCuz9r1BRGyZnlVkgy3jPpjJBNOIg3Jtiy\nO/NnhunPf8mZi9sa4TMud+ekT/HnPmGh4xbmAvIH+QKBgQD0bFK6rbJl+gxqQPo7\nSDwF0ys5Sapr75Bt7Vj8LGnFTQKFvMRBU/N89ISVcB8V7sA/6ApDQ/4CIyg61HkW\nhKcIOqpPQUQgftl6TkHwJ8PtmZlTsfgRKfbnbtRK8o/tdaNgNnjFz3kkSGb8PzQp\njo5VcaNYqwFJ2lsbEx05/Ba4WQKBgQDqP6aShXzz+ToVEr8wrax08JrRRd7RUjoR\nJVmRuFwPn6XxB/J4B4wCUQFdkhN/BUL+f+IzpsQLP9LWxeH3sANppOIYXzihz2nO\nD4uK7JUkpcDTSkLNaZ99eJmG5gCR7OJoxT5z3a+USpwzTEkWiJmJFmlazcPFZ4Xx\n/JDaistcbQKBgQCRX7gYxeScWIt3yuvJxJ3GjSFhMlpFVjgd2ZQacEP8kGAWsP49\nKLRiNoCA7S3f+p+notgvx8nU9Zog22ylowJBl7rh5pyhgzDQWKlJMC2NLNUP/YLg\nmof6gGWNqhVGk7g3Kk7MwCh6FwIBt4nLybkIQs13mEXs6g1T3ht8+F1/CQKBgQDE\nBm3jcXfGRsq3Nc/u8Xc/CNXVyM2Uh2X2UTYqPogzvtrD4G2kylP84ELvRb2w7vtI\nNEZcCPNHoqpSdpgJiS7h6kwWLyEaL5MQEGwq3p5UY60AY8WRVhFUk2aOv8y8UOqK\n2HzRwzMaOnGKcA09oSQy1yFlDooEmQQ7I6soZzuU5QKBgBPeYC/Sre6uGBnGcJ7N\nGQ7Kjiej4aIhne2XHOjkJEAYDwSnm3jEB69wARB+oHiCTY1Us9n1jrhxgjsppcif\nmgG8ynTv4fGB+H15fhdXbm3pZg72w3KcnumV4i1moF7J9zp/+rgcrOn1B1ucXOb9\nVgr1+d15I5+k+QjZ7v10itLx\n-----END PRIVATE KEY-----\n",
+  "client_email": "kiki-163@singular-cache-417619.iam.gserviceaccount.com",
+  "client_id": "116841134751275341792",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/kiki-163%40singular-cache-417619.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

receipt_processor/google_ocr.py

@@ -0,0 +1,12 @@
+from google.cloud import vision
+import os
+
+class GoogleVisionOCR:
+    def __init__(self):
+        os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "receipt-vision-key.json"
+        self.client = vision.ImageAnnotatorClient()
+
+    def extract_text(self, image_content: bytes) -> str:
+        image = vision.Image(content=image_content)
+        response = self.client.text_detection(image=image)
+        return response.text_annotations[0].description if response.text_annotations else ""

receipt_processor/receipt_parser.py

@@ -0,0 +1,58 @@
+import re
+
+class ReceiptParser:
+    @staticmethod
+    def parse_receipt_text(full_text: str) -> dict:
+        lines = full_text.splitlines()
+        receipt = {"store": None, "date": None, "total": None, "items": []}
+
+        # Store detection
+        for line in lines:
+            if any(kw in line.lower() for kw in ["konzum", "plodine", "studenac"]):
+                receipt["store"] = line.strip()
+                break
+
+        # Date detection
+        for line in lines:
+            if match := re.search(r'\b(\d{2}\.\d{2}\.\d{4})\b', line):
+                receipt["date"] = match.group(1)
+                break
+
+        # Total detection
+        for line in reversed(lines):
+            if any(word in line.lower() for word in ["ukupno", "za platiti"]):
+                if match := re.search(r'(\d+,\d{2})', line):
+                    receipt["total"] = f"{match.group(1).replace(',', '.')} EUR"
+                    break
+
+        # Item parsing logic
+        merged_lines = []
+        skip_next = False
+        for i, line in enumerate(lines):
+            if skip_next:
+                skip_next = False
+                continue
+            if re.search(r'\d+,\d{2}$', line):
+                if i+1 < len(lines) and re.match(r'^\d+,\d{2}', lines[i+1]):
+                    merged_lines.append(f"{line} {lines[i+1]}")
+                    skip_next = True
+                    continue
+            merged_lines.append(line)
+
+        item_patterns = [
+            re.compile(r'(.+?)\s+(\d+)\s+(\d+,\d{2})\s+(\d+,\d{2})'),
+            re.compile(r'(.+?)\s+(\d+)\s+x\s+(\d+,\d{2})\s+(\d+,\d{2})'),
+            re.compile(r'(.+?)\s+(\d+)\s+(\d+)\s+(\d+,\d{2})'),
+        ]
+
+        for line in merged_lines:
+            for pattern in item_patterns:
+                if match := pattern.match(line):
+                    receipt["items"].append({
+                        "name": match.group(1).strip().title(),
+                        "qty": int(match.group(2)),
+                        "price": match.group(4).replace(",", ".")
+                    })
+                    break
+
+        return receipt

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+numpy
+onnxruntime-gpu
+opencv-python
+Pillow
+torch
+ultralytics
+python-multipart
+google-cloud-vision