Fresh Deploy

.gitignore

@@ -0,0 +1,10 @@
+
+# Ignore PDF files
+*.pdf
+
+# Ignore Python cache
+__pycache__/
+*.pyc
+
+# Ignore simple artifacts
+*.csv

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code and data
+COPY app.py .
+COPY cars_knowledge_graph.ttl .
+COPY cars_ontology.ttl .
+COPY src/ src/
+
+# Expose Streamlit port
+EXPOSE 7860
+
+# Run the application
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,67 @@
+---
+title: Cars Knowledge Graph
+emoji: 🚗
+colorFrom: blue
+colorTo: red
+sdk: docker
+pinned: false
+---
+
+# Knowledge Representation Project: Cars Knowledge Graph
+
+## 1. Introduction & Motivation
+This project transforms a flat CSV dataset of **Car Specifications (2025)** into a semantic **Knowledge Graph (RDF/OWL)**. 
+**Domain**: Automotive Industry (Cars, Manufacturers, Engines, Performance).
+**Motivation**: To enable complex querying of car data that is not possible with simple tabular lookups, such as inferring "High Performance" vehicles or categorizing cars by complex criteria (e.g., specific engine types + price ranges).
+
+## 2. Ontology Design (Conceptual Model)
+The Ontology is designed using **RDFLib** and conforms to the project requirements (20+ Classes, 7+ Properties).
+
+### Core Classes
+- **Car**: The central entity.
+  - **Subclasses**: `SportsCar`, `HyperCar`, `Sedan`, `Coupe`, `ElectricCar`, `PetrolCar`, `LuxuryCar`.
+- **Manufacturer**: Companies like Ferrari, Tesla, Bugatti.
+- **Component**: `Engine`, `V8Engine`, `V12Engine`.
+- **defined Classes**: 
+  - `SuperCar`: Cars with Top Speed > 300 km/h.
+
+### Properties
+- **Object Properties**: `hasManufacturer`, `hasEngine`, `usesFuel`, `manufactures`.
+- **Datatype Properties**: `hasPriceValue`, `hasHorsePowerValue`, `hasSeatCount`, `hasTopSpeedKMH`.
+
+## 3. Knowledge Graph Construction
+- **Source**: `Cars Datasets 2025.csv`
+- **Output**: `cars_knowledge_graph.ttl` (Turtle Syntax)
+- **Triples Generated**: ~9,842
+
+## 4. Competency Questions & Validation
+The following questions guided the design and were validated via SPARQL:
+
+1. **"List all cars manufactured by Ferrari"**
+   - Verified: Returns models like `SF90 STRADALE`, `ROMA`, `812 GTS`.
+2. **"Which cars have > 800 HorsePower?"**
+   - Verified: Returns `Bugatti Chiron`, `Tesla Roadster 2`, etc.
+3. **"Count of 2-Seater Coupes"**
+   - Result: 147 vehicles.
+4. **"What is the average price of all cars?"**
+   - Result: ~$137,193 USD.
+
+## 5. How to Run
+### Prerequisites
+- Python 3.x
+- Libraries: `rdflib`, `pandas`
+
+### Steps
+1. **Install Dependencies**:
+   ```bash
+   pip install rdflib pandas
+   ```
+2. **Generate Knowledge Graph**:
+   ```bash
+   python src/ontology.py      # Generates Ontology Schema
+   python src/convert_data.py  # Generates Graph from CSV
+   ```
+3. **Run Validation Queries**:
+   ```bash
+   python src/validate.py
+   ```

app.py

@@ -0,0 +1,133 @@
+import streamlit as st
+import pandas as pd
+from rdflib import Graph, Namespace
+import os
+
+# Page Config
+st.set_page_config(page_title="Cars Knowledge Graph Demo", layout="wide")
+
+# Load Graph
+@st.cache_resource
+def load_graph():
+    g = Graph()
+    graph_path = "cars_knowledge_graph.ttl"
+    if os.path.exists(graph_path):
+        g.parse(graph_path, format="turtle")
+    return g
+
+try:
+    g = load_graph()
+except Exception as e:
+    st.error(f"Failed to load graph: {e}")
+    st.stop()
+
+if len(g) == 0:
+    st.warning("Graph is empty or not found. Please run 'src/convert_data.py' first.")
+    st.stop()
+
+# Namespaces
+EX = Namespace("http://example.org/cars/")
+
+# Sidebar Filters
+st.sidebar.header("Filter Cars")
+
+# 1. Manufacturer Filter
+manu_query = """
+    PREFIX ex: <http://example.org/cars/>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+    SELECT DISTINCT ?name WHERE { 
+        ?m a ex:Manufacturer ; rdfs:label ?name . 
+    } ORDER BY ?name
+"""
+manufacturers = ["All"] + [str(row.name) for row in g.query(manu_query)]
+selected_manu = st.sidebar.selectbox("Manufacturer", manufacturers)
+
+# 2. Price Range
+price_query = """
+    PREFIX ex: <http://example.org/cars/>
+    SELECT (MIN(?p) as ?min) (MAX(?p) as ?max) WHERE { ?s ex:hasPriceValue ?p }
+"""
+price_res = list(g.query(price_query))[0]
+min_price, max_price = float(price_res.min), float(price_res.max)
+selected_price = st.sidebar.slider("Max Price (USD)", min_price, max_price, max_price)
+
+# 3. Min Horsepower
+hp_query = """
+    PREFIX ex: <http://example.org/cars/>
+    SELECT (MIN(?hp) as ?min) (MAX(?hp) as ?max) WHERE { ?s ex:hasHorsePowerValue ?hp }
+"""
+hp_res = list(g.query(hp_query))[0]
+min_hp, max_hp = int(hp_res.min), int(hp_res.max)
+selected_hp = st.sidebar.slider("Min Horsepower", min_hp, max_hp, min_hp)
+
+# Main Area
+st.title("🚗 Cars Knowledge Graph Explorer")
+st.markdown("This application queries the RDF Knowledge Graph directly using **SPARQL**.")
+
+# Construct Query based on filters
+sparql_query = f"""
+    PREFIX ex: <http://example.org/cars/>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+    
+    SELECT ?carName ?manuName ?price ?hp ?topSpeed ?seats
+    WHERE {{
+        ?car a ex:Car ;
+             rdfs:label ?carName ;
+             ex:hasManufacturer ?manu ;
+             ex:hasPriceValue ?price ;
+             ex:hasHorsePowerValue ?hp ;
+             ex:hasTopSpeedKMH ?topSpeed ;
+             ex:hasSeatCount ?seats .
+        
+        ?manu rdfs:label ?manuName .
+        
+        FILTER (?price <= {selected_price})
+        FILTER (?hp >= {selected_hp})
+        {f'FILTER (?manuName = "{selected_manu}")' if selected_manu != "All" else ""}
+    }}
+    ORDER BY DESC(?price)
+    LIMIT 100
+"""
+
+# Run Query
+results = g.query(sparql_query)
+
+# Display Results
+data = []
+for row in results:
+    data.append({
+        "Car Model": str(row.carName),
+        "Manufacturer": str(row.manuName),
+        "Price ($)": f"${float(row.price):,.2f}",
+        "Horsepower": int(row.hp),
+        "Top Speed (km/h)": int(row.topSpeed),
+        "Seats": int(row.seats)
+    })
+
+df = pd.DataFrame(data)
+
+col1, col2, col3 = st.columns(3)
+col1.metric("Total Cars Found", len(df))
+col2.metric("Graph Triples", len(g))
+col3.metric("Selected Manufacturer", selected_manu)
+
+if not df.empty:
+    st.dataframe(df, use_container_width=True)
+else:
+    st.info("No cars match your filters.")
+
+# Advanced: Raw SPARQL
+with st.expander("Run Custom SPARQL Query"):
+    custom_query = st.text_area("SPARQL Query", """
+        PREFIX ex: <http://example.org/cars/>
+        SELECT ?name ?price WHERE {
+            ?c ex:hasPriceValue ?price ;
+               rdfs:label ?name .
+        } LIMIT 5
+    """)
+    if st.button("Run Query"):
+        try:
+            raw_res = g.query(custom_query)
+            st.write(list(raw_res))
+        except Exception as e:
+            st.error(f"Error: {e}")

cars_ontology.ttl

@@ -0,0 +1,106 @@
+@prefix ex: <http://example.org/cars/> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+ex:Color a owl:Class .
+
+ex:Coupe a owl:Class .
+
+ex:DieselCar a owl:Class .
+
+ex:EcoFriendlyCar a owl:Class .
+
+ex:EconomyCar a owl:Class .
+
+ex:ElectricCar a owl:Class ;
+    rdfs:subClassOf ex:Car .
+
+ex:ElectricMotor a owl:Class .
+
+ex:Engine a owl:Class ;
+    rdfs:subClassOf ex:Component .
+
+ex:FiveSeaterCar a owl:Class .
+
+ex:FourSeaterCar a owl:Class .
+
+ex:FuelType a owl:Class .
+
+ex:HybridCar a owl:Class .
+
+ex:HyperCar a owl:Class .
+
+ex:ICECar a owl:Class .
+
+ex:LuxuryCar a owl:Class .
+
+ex:LuxurySportCar a owl:Class .
+
+ex:PassengerCar a owl:Class ;
+    rdfs:subClassOf ex:Car .
+
+ex:PetrolCar a owl:Class ;
+    rdfs:subClassOf ex:Car .
+
+ex:SUV a owl:Class .
+
+ex:Sedan a owl:Class .
+
+ex:SportsCar a owl:Class ;
+    rdfs:subClassOf ex:Car .
+
+ex:SuperCar a owl:Class .
+
+ex:TwoSeaterCar a owl:Class .
+
+ex:V10Engine a owl:Class .
+
+ex:V12Engine a owl:Class .
+
+ex:V8Engine a owl:Class .
+
+ex:VEngine a owl:Class .
+
+ex:has0to100Sec a owl:DatatypeProperty ;
+    rdfs:domain ex:Car .
+
+ex:hasCompetitor a owl:ObjectProperty .
+
+ex:hasEngine a owl:ObjectProperty .
+
+ex:hasEngineDisplacement a owl:DatatypeProperty ;
+    rdfs:domain ex:Car .
+
+ex:hasHorsePowerValue a owl:DatatypeProperty ;
+    rdfs:domain ex:Car .
+
+ex:hasManufacturer a owl:ObjectProperty ;
+    rdfs:domain ex:Car ;
+    rdfs:range ex:Manufacturer .
+
+ex:hasPriceValue a owl:DatatypeProperty ;
+    rdfs:domain ex:Car .
+
+ex:hasSeatCount a owl:DatatypeProperty ;
+    rdfs:domain ex:Car .
+
+ex:hasTopSpeedKMH a owl:DatatypeProperty ;
+    rdfs:domain ex:Car .
+
+ex:hasTorqueNm a owl:DatatypeProperty ;
+    rdfs:domain ex:Car .
+
+ex:hasTrimLevel a owl:ObjectProperty .
+
+ex:isModelVariantOf a owl:ObjectProperty .
+
+ex:manufactures a owl:ObjectProperty .
+
+ex:usesFuel a owl:ObjectProperty .
+
+ex:Component a owl:Class .
+
+ex:Manufacturer a owl:Class .
+
+ex:Car a owl:Class .
+

requirements.txt

@@ -0,0 +1,3 @@
+streamlit
+pandas
+rdflib

src/app.py

@@ -0,0 +1,133 @@
+import streamlit as st
+import pandas as pd
+from rdflib import Graph, Namespace
+import os
+
+# Page Config
+st.set_page_config(page_title="Cars Knowledge Graph Demo", layout="wide")
+
+# Load Graph
+@st.cache_resource
+def load_graph():
+    g = Graph()
+    graph_path = "cars_knowledge_graph.ttl"
+    if os.path.exists(graph_path):
+        g.parse(graph_path, format="turtle")
+    return g
+
+try:
+    g = load_graph()
+except Exception as e:
+    st.error(f"Failed to load graph: {e}")
+    st.stop()
+
+if len(g) == 0:
+    st.warning("Graph is empty or not found. Please run 'src/convert_data.py' first.")
+    st.stop()
+
+# Namespaces
+EX = Namespace("http://example.org/cars/")
+
+# Sidebar Filters
+st.sidebar.header("Filter Cars")
+
+# 1. Manufacturer Filter
+manu_query = """
+    PREFIX ex: <http://example.org/cars/>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+    SELECT DISTINCT ?name WHERE { 
+        ?m a ex:Manufacturer ; rdfs:label ?name . 
+    } ORDER BY ?name
+"""
+manufacturers = ["All"] + [str(row.name) for row in g.query(manu_query)]
+selected_manu = st.sidebar.selectbox("Manufacturer", manufacturers)
+
+# 2. Price Range
+price_query = """
+    PREFIX ex: <http://example.org/cars/>
+    SELECT (MIN(?p) as ?min) (MAX(?p) as ?max) WHERE { ?s ex:hasPriceValue ?p }
+"""
+price_res = list(g.query(price_query))[0]
+min_price, max_price = float(price_res.min), float(price_res.max)
+selected_price = st.sidebar.slider("Max Price (USD)", min_price, max_price, max_price)
+
+# 3. Min Horsepower
+hp_query = """
+    PREFIX ex: <http://example.org/cars/>
+    SELECT (MIN(?hp) as ?min) (MAX(?hp) as ?max) WHERE { ?s ex:hasHorsePowerValue ?hp }
+"""
+hp_res = list(g.query(hp_query))[0]
+min_hp, max_hp = int(hp_res.min), int(hp_res.max)
+selected_hp = st.sidebar.slider("Min Horsepower", min_hp, max_hp, min_hp)
+
+# Main Area
+st.title("🚗 Cars Knowledge Graph Explorer")
+st.markdown("This application queries the RDF Knowledge Graph directly using **SPARQL**.")
+
+# Construct Query based on filters
+sparql_query = f"""
+    PREFIX ex: <http://example.org/cars/>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+    
+    SELECT ?carName ?manuName ?price ?hp ?topSpeed ?seats
+    WHERE {{
+        ?car a ex:Car ;
+             rdfs:label ?carName ;
+             ex:hasManufacturer ?manu ;
+             ex:hasPriceValue ?price ;
+             ex:hasHorsePowerValue ?hp ;
+             ex:hasTopSpeedKMH ?topSpeed ;
+             ex:hasSeatCount ?seats .
+        
+        ?manu rdfs:label ?manuName .
+        
+        FILTER (?price <= {selected_price})
+        FILTER (?hp >= {selected_hp})
+        {f'FILTER (?manuName = "{selected_manu}")' if selected_manu != "All" else ""}
+    }}
+    ORDER BY DESC(?price)
+    LIMIT 100
+"""
+
+# Run Query
+results = g.query(sparql_query)
+
+# Display Results
+data = []
+for row in results:
+    data.append({
+        "Car Model": str(row.carName),
+        "Manufacturer": str(row.manuName),
+        "Price ($)": f"${float(row.price):,.2f}",
+        "Horsepower": int(row.hp),
+        "Top Speed (km/h)": int(row.topSpeed),
+        "Seats": int(row.seats)
+    })
+
+df = pd.DataFrame(data)
+
+col1, col2, col3 = st.columns(3)
+col1.metric("Total Cars Found", len(df))
+col2.metric("Graph Triples", len(g))
+col3.metric("Selected Manufacturer", selected_manu)
+
+if not df.empty:
+    st.dataframe(df, use_container_width=True)
+else:
+    st.info("No cars match your filters.")
+
+# Advanced: Raw SPARQL
+with st.expander("Run Custom SPARQL Query"):
+    custom_query = st.text_area("SPARQL Query", """
+        PREFIX ex: <http://example.org/cars/>
+        SELECT ?name ?price WHERE {
+            ?c ex:hasPriceValue ?price ;
+               rdfs:label ?name .
+        } LIMIT 5
+    """)
+    if st.button("Run Query"):
+        try:
+            raw_res = g.query(custom_query)
+            st.write(list(raw_res))
+        except Exception as e:
+            st.error(f"Error: {e}")

src/convert_data.py

@@ -0,0 +1,208 @@
+import pandas as pd
+from rdflib import Graph, Namespace, RDF, RDFS, OWL, Literal, XSD, URIRef
+import re
+import os
+
+# Define Namespace
+EX = Namespace("http://example.org/cars/")
+
+def clean_price(value):
+    if pd.isna(value): return 0.0
+    val_str = str(value).replace('$', '').replace(',', '').strip()
+    match = re.search(r'([\d\.]+)', val_str)
+    return float(match.group(1)) if match else 0.0
+
+def clean_number(value):
+    if pd.isna(value): return 0
+    match = re.search(r'([\d\.,]+)', str(value))
+    if match:
+        return float(match.group(1).replace(',', ''))
+    return 0
+
+def clean_seats(value):
+    if pd.isna(value): return 2
+    match = re.search(r'(\d+)', str(value))
+    return int(match.group(1)) if match else 2
+
+def convert_data():
+    # Load or Create Graph
+    g = Graph()
+    g.bind("ex", EX)
+    g.bind("owl", OWL)
+    g.bind("rdfs", RDFS)
+    
+    # Load Ontology T-Box (if exists, to keep definitions)
+    if os.path.exists("cars_ontology.ttl"):
+        g.parse("cars_ontology.ttl", format="turtle")
+
+    # DBpedia Mappings
+    dbpedia_manufacturers = {
+        "FERRARI": "http://dbpedia.org/resource/Ferrari",
+        "ROLLS ROYCE": "http://dbpedia.org/resource/Rolls-Royce_Motor_Cars",
+        "FORD": "http://dbpedia.org/resource/Ford_Motor_Company",
+        "MERCEDES": "http://dbpedia.org/resource/Mercedes-Benz",
+        "AUDI": "http://dbpedia.org/resource/Audi",
+        "BMW": "http://dbpedia.org/resource/BMW",
+        "ASTON MARTIN": "http://dbpedia.org/resource/Aston_Martin",
+        "BENTLEY": "http://dbpedia.org/resource/Bentley",
+        "LAMBORGHINI": "http://dbpedia.org/resource/Lamborghini",
+        "TOYOTA": "http://dbpedia.org/resource/Toyota",
+        "NISSAN": "http://dbpedia.org/resource/Nissan",
+        "VOLVO": "http://dbpedia.org/resource/Volvo_Cars",
+        "KIA": "http://dbpedia.org/resource/Kia",
+        "HONDA": "http://dbpedia.org/resource/Honda",
+        "HYUNDAI": "http://dbpedia.org/resource/Hyundai_Motor_Company",
+        "MAHINDRA": "http://dbpedia.org/resource/Mahindra_&_Mahindra",
+        "MARUTI SUZUKI": "http://dbpedia.org/resource/Maruti_Suzuki",
+        "VOLKSWAGEN": "http://dbpedia.org/resource/Volkswagen",
+        "PORSCHE": "http://dbpedia.org/resource/Porsche",
+        "CADILLAC": "http://dbpedia.org/resource/Cadillac",
+        "TATA MOTORS": "http://dbpedia.org/resource/Tata_Motors",
+        "TESLA": "http://dbpedia.org/resource/Tesla,_Inc.",
+        "JEEP": "http://dbpedia.org/resource/Jeep",
+        "MAZDA": "http://dbpedia.org/resource/Mazda",
+        "CHEVROLET": "http://dbpedia.org/resource/Chevrolet",
+        "GMC": "http://dbpedia.org/resource/GMC_(automobile)",
+        "PEUGEOT": "http://dbpedia.org/resource/Peugeot",
+        "BUGATTI": "http://dbpedia.org/resource/Bugatti_Automobiles",
+        "JAGUAR LAND ROVER": "http://dbpedia.org/resource/Jaguar_Land_Rover",
+        "ACURA": "http://dbpedia.org/resource/Acura",
+        "MITSUBISHI": "http://dbpedia.org/resource/Mitsubishi_Motors"
+    }
+
+    dbpedia_body = {
+        "Coupe": "http://dbpedia.org/resource/Coupe",
+        "Sedan": "http://dbpedia.org/resource/Sedan_(automobile)",
+        "SUV": "http://dbpedia.org/resource/Sport_utility_vehicle",
+        "SuperCar": "http://dbpedia.org/resource/Supercar",
+        "Car": "http://dbpedia.org/resource/Car"
+    }
+
+    # Fuel Mappings
+    dbpedia_fuels = {
+        "PETROL": "http://dbpedia.org/resource/Gasoline",
+        "DIESEL": "http://dbpedia.org/resource/Diesel_fuel",
+        "ELECTRIC": "http://dbpedia.org/resource/Electric_vehicle", # Linking to EV concept for fuel type context
+        "HYBRID": "http://dbpedia.org/resource/Hybrid_vehicle",
+        "PLUG-IN HYBRID": "http://dbpedia.org/resource/Plug-in_hybrid",
+        "HYDROGEN": "http://dbpedia.org/resource/Hydrogen_fuel",
+        "CNG": "http://dbpedia.org/resource/Compressed_natural_gas"
+    }
+
+    # Engine Mappings (Common types)
+    dbpedia_engines = {
+        "V8": "http://dbpedia.org/resource/V8_engine",
+        "V10": "http://dbpedia.org/resource/V10_engine",
+        "V12": "http://dbpedia.org/resource/V12_engine",
+        "V6": "http://dbpedia.org/resource/V6_engine",
+        "W12": "http://dbpedia.org/resource/W12_engine",
+        "W16": "http://dbpedia.org/resource/W16_engine",
+        "I4": "http://dbpedia.org/resource/Inline-four_engine",
+        "ELECTRIC": "http://dbpedia.org/resource/Electric_motor"
+    }
+
+    # Load CSV
+    csv_path = "../Cars Datasets 2025.csv"
+    if not os.path.exists(csv_path):
+        csv_path = "Cars Datasets 2025.csv"
+        
+    try:
+        df = pd.read_csv(csv_path, encoding='latin1')
+    except Exception as e:
+        print(f"Error reading CSV: {e}")
+        return
+
+    print(f"Processing {len(df)} rows...")
+
+    for index, row in df.iterrows():
+        # Clean Data
+        car_name = str(row['Cars Names']).strip()
+        comp_name_raw = str(row['Company Names']).strip()
+        comp_name_upper = comp_name_raw.upper()
+        
+        # Normalize Company Name for URI
+        comp_uri_suffix = comp_name_upper.replace(" ", "_")
+        comp_uri = EX[comp_uri_suffix]
+        
+        car_uri = EX[car_name.replace(" ", "_").replace("/", "-").replace("(", "").replace(")", "")]
+        
+        # Add Type
+        g.add((car_uri, RDF.type, EX.Car))
+        g.add((comp_uri, RDF.type, EX.Manufacturer))
+        
+        # Interlinking: Manufacturer
+        if comp_name_upper in dbpedia_manufacturers:
+            g.add((comp_uri, OWL.sameAs, URIRef(dbpedia_manufacturers[comp_name_upper])))
+        
+        # Fuel Type Logic
+        fuel_raw = str(row['Fuel Types']).strip()
+        fuel_clean = "PETROL" # Default
+        if "diesel" in fuel_raw.lower(): fuel_clean = "DIESEL"
+        elif "electric" in fuel_raw.lower() and "hybrid" not in fuel_raw.lower(): fuel_clean = "ELECTRIC"
+        elif "plug" in fuel_raw.lower(): fuel_clean = "PLUG-IN HYBRID"
+        elif "hybrid" in fuel_raw.lower(): fuel_clean = "HYBRID"
+        elif "hydrogen" in fuel_raw.lower(): fuel_clean = "HYDROGEN"
+        elif "cng" in fuel_raw.lower(): fuel_clean = "CNG"
+        
+        fuel_uri = EX[fuel_clean.replace(" ", "_").replace("-", "_")]
+        g.add((fuel_uri, RDF.type, EX.FuelType))
+        g.add((car_uri, EX.usesFuel, fuel_uri))
+        
+        if fuel_clean in dbpedia_fuels:
+             g.add((fuel_uri, OWL.sameAs, URIRef(dbpedia_fuels[fuel_clean])))
+             
+        # Engine Logic
+        engine_raw = str(row['Engines']).strip()
+        engine_clean = "Engine"
+        if "v8" in engine_raw.lower(): engine_clean = "V8"
+        elif "v12" in engine_raw.lower(): engine_clean = "V12"
+        elif "v10" in engine_raw.lower(): engine_clean = "V10"
+        elif "v6" in engine_raw.lower(): engine_clean = "V6"
+        elif "w12" in engine_raw.lower(): engine_clean = "W12"
+        elif "w16" in engine_raw.lower(): engine_clean = "W16"
+        
+        engine_uri = EX[engine_clean.replace(" ", "_")]
+        g.add((engine_uri, RDF.type, EX.Engine))
+        g.add((car_uri, EX.hasEngine, engine_uri))
+        
+        if engine_clean in dbpedia_engines:
+            g.add((engine_uri, OWL.sameAs, URIRef(dbpedia_engines[engine_clean])))
+
+        # Determine Car Subclass & Interlinking
+        seats = clean_seats(row['Seats'])
+        price = clean_price(row['Cars Prices'])
+        top_speed = clean_number(row['Total Speed'])
+        
+        car_type = EX.Car
+        if seats == 2:
+            car_type = EX.Coupe
+            g.add((car_uri, RDF.type, EX.Coupe))
+            g.add((EX.Coupe, OWL.sameAs, URIRef(dbpedia_body["Coupe"]))) # Class Level link (optional but good)
+        elif seats >= 4:
+            car_type = EX.Sedan
+            g.add((car_uri, RDF.type, EX.Sedan))
+            g.add((EX.Sedan, OWL.sameAs, URIRef(dbpedia_body["Sedan"])))
+            
+        if top_speed > 300:
+            g.add((car_uri, RDF.type, EX.SuperCar))
+            g.add((EX.SuperCar, OWL.sameAs, URIRef(dbpedia_body["SuperCar"])))
+            
+        # Add Properties
+        g.add((car_uri, EX.hasManufacturer, comp_uri))
+        g.add((car_uri, RDFS.label, Literal(car_name, datatype=XSD.string)))
+        g.add((comp_uri, RDFS.label, Literal(comp_name_raw, datatype=XSD.string)))
+        g.add((fuel_uri, RDFS.label, Literal(fuel_clean, datatype=XSD.string)))
+        
+        g.add((car_uri, EX.hasPriceValue, Literal(price, datatype=XSD.float)))
+        g.add((car_uri, EX.hasSeatCount, Literal(seats, datatype=XSD.integer)))
+        g.add((car_uri, EX.hasTopSpeedKMH, Literal(int(top_speed), datatype=XSD.integer)))
+        
+        hp = clean_number(row['HorsePower'])
+        g.add((car_uri, EX.hasHorsePowerValue, Literal(int(hp), datatype=XSD.integer)))
+
+    # Save Graph
+    g.serialize(destination="cars_knowledge_graph.ttl", format="turtle")
+    print(f"Knowledge Graph saved to cars_knowledge_graph.ttl with {len(g)} triples.")
+
+if __name__ == "__main__":
+    convert_data()

src/ontology.py

@@ -0,0 +1,68 @@
+from rdflib import Graph, Namespace, RDF, RDFS, OWL, Literal, XSD
+
+def create_ontology():
+    g = Graph()
+    
+    # Define Namespace
+    EX = Namespace("http://example.org/cars/")
+    g.bind("ex", EX)
+    
+    # Enable OWL/RDFS
+    g.bind("owl", OWL)
+    
+    # ==========================
+    # CLASSES (Goal: 20+)
+    # ==========================
+    classes = [
+        "Car", "Component", "Engine", "FuelType", "Manufacturer", 
+        "Color", "PassengerCar", "TwoSeaterCar", "FourSeaterCar", 
+        "FiveSeaterCar", "Coupe", "Sedan", "SUV", "SportsCar", 
+        "SuperCar", "HyperCar", "EconomyCar", "ElectricCar", 
+        "ICECar", "HybridCar", "PetrolCar", "DieselCar", 
+        "VEngine", "V8Engine", "V10Engine", "V12Engine", 
+        "ElectricMotor", "EcoFriendlyCar", "LuxuryCar", "LuxurySportCar"
+    ]
+    
+    for cls in classes:
+        g.add((EX[cls], RDF.type, OWL.Class))
+        
+    # Class Hierarchy
+    g.add((EX.PassengerCar, RDFS.subClassOf, EX.Car))
+    g.add((EX.SportsCar, RDFS.subClassOf, EX.Car))
+    g.add((EX.Engine, RDFS.subClassOf, EX.Component))
+    g.add((EX.ElectricCar, RDFS.subClassOf, EX.Car))
+    g.add((EX.PetrolCar, RDFS.subClassOf, EX.Car))
+
+    # ==========================
+    # PROPERTIES (Goal: 7+ Object, 7+ Data)
+    # ==========================
+    
+    # Object Properties
+    obj_props = [
+        "hasManufacturer", "manufactures", "hasEngine", "usesFuel", 
+        "hasCompetitor", "isModelVariantOf", "hasTrimLevel"
+    ]
+    
+    for prop in obj_props:
+        g.add((EX[prop], RDF.type, OWL.ObjectProperty))
+        
+    # Domain/Range examples
+    g.add((EX.hasManufacturer, RDFS.domain, EX.Car))
+    g.add((EX.hasManufacturer, RDFS.range, EX.Manufacturer))
+    
+    # Datatype Properties
+    data_props = [
+        "hasPriceValue", "hasHorsePowerValue", "hasTopSpeedKMH", 
+        "hasSeatCount", "hasTorqueNm", "has0to100Sec", "hasEngineDisplacement"
+    ]
+    
+    for prop in data_props:
+        g.add((EX[prop], RDF.type, OWL.DatatypeProperty))
+        g.add((EX[prop], RDFS.domain, EX.Car))
+
+    # Save Ontology T-Box
+    g.serialize(destination="cars_ontology.ttl", format="turtle")
+    print("Ontology T-Box saved to cars_ontology.ttl")
+
+if __name__ == "__main__":
+    create_ontology()

src/publish.py

@@ -0,0 +1,74 @@
+from fastapi import FastAPI, Query, Request, HTTPException
+from fastapi.responses import JSONResponse, HTMLResponse
+from rdflib import Graph
+import os
+import uvicorn
+
+app = FastAPI(title="Cars Knowledge Graph SPARQL Endpoint")
+
+# Load the Knowledge Graph
+g = Graph()
+GRAPH_FILE = "cars_knowledge_graph.ttl"
+
+if os.path.exists(GRAPH_FILE):
+    print(f"Loading Knowledge Graph from {GRAPH_FILE}...")
+    g.parse(GRAPH_FILE, format="turtle")
+    print(f"Graph loaded with {len(g)} triples.")
+else:
+    print(f"WARNING: {GRAPH_FILE} not found. Please run convert_data.py first.")
+
+@app.get("/", response_class=HTMLResponse)
+async def home():
+    return """
+    <h1>Cars Knowledge Graph SPARQL Endpoint (FastAPI)</h1>
+    <p>The Knowledge Graph is published and accessible.</p>
+    <p>Send SPARQL queries to: <code>/sparql</code></p>
+    <h3>Example Query:</h3>
+    <pre>
+    SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 10
+    </pre>
+    <p>View API Docs at: <a href="/docs">/docs</a></p>
+    """
+
+async def run_query(query: str):
+    if not query:
+        raise HTTPException(status_code=400, detail="No query provided")
+    
+    try:
+        results = g.query(query)
+        
+        # Format results as JSON
+        res_list = []
+        for row in results:
+            res_dict = {}
+            if getattr(results, "vars", None):
+                for i, var in enumerate(results.vars):
+                    if row[i] is not None:
+                        res_dict[str(var)] = str(row[i])
+            res_list.append(res_dict)
+            
+        return {"results": res_list}
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/sparql")
+async def sparql_get(query: str = Query(..., description="SPARQL Query")):
+    return await run_query(query)
+
+@app.post("/sparql")
+async def sparql_post(request: Request):
+    # Handle both form data and raw body
+    content_type = request.headers.get("content-type", "")
+    if "application/x-www-form-urlencoded" in content_type:
+        form = await request.form()
+        query = form.get("query")
+    else:
+        # data = await request.json() # Optional depending on client
+        query = (await request.body()).decode("utf-8")
+        
+    return await run_query(query)
+
+if __name__ == "__main__":
+    print("Starting SPARQL Endpoint on http://localhost:8000")
+    uvicorn.run(app, host="0.0.0.0", port=8000)

src/validate.py

@@ -0,0 +1,129 @@
+from rdflib import Graph, Namespace
+import pandas as pd
+
+def run_validation():
+    g = Graph()
+    g.parse("cars_knowledge_graph.ttl", format="turtle")
+    
+    EX = Namespace("http://example.org/cars/")
+    
+    queries = {
+        "1. List all cars manufactured by Ferrari": """
+            PREFIX ex: <http://example.org/cars/>
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            
+            SELECT ?car_name
+            WHERE {
+                ?car ex:hasManufacturer ?manu .
+                ?manu rdfs:label ?manu_name .
+                FILTER (REGEX(?manu_name, "Ferrari", "i"))
+                ?car rdfs:label ?car_name .
+            }
+        """,
+        "2. Cars with HorsePower > 800": """
+            PREFIX ex: <http://example.org/cars/>
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            
+            SELECT ?car_name ?hp
+            WHERE {
+                ?car ex:hasHorsePowerValue ?hp .
+                ?car rdfs:label ?car_name .
+                FILTER (?hp > 800)
+            }
+        """,
+        "3. Count of 2-Seater cars": """
+            PREFIX ex: <http://example.org/cars/>
+            
+            SELECT (COUNT(?car) as ?count)
+            WHERE {
+                ?car a ex:Coupe .
+            }
+        """,
+        "4. Average Price of cars": """
+            PREFIX ex: <http://example.org/cars/>
+            
+            SELECT (AVG(?price) as ?avg_price)
+            WHERE {
+                ?car ex:hasPriceValue ?price .
+            }
+        """,
+        "5. (Federated) Get Manufacturer Description from DBpedia": """
+            PREFIX ex: <http://example.org/cars/>
+            PREFIX owl: <http://www.w3.org/2002/07/owl#>
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            PREFIX dbo: <http://dbpedia.org/ontology/>
+            
+            SELECT ?manu_name ?desc
+            WHERE {
+                ?manu a ex:Manufacturer ;
+                      rdfs:label ?manu_name ;
+                      owl:sameAs ?dbpedia_link .
+                
+                SERVICE <http://dbpedia.org/sparql> {
+                    ?dbpedia_link dbo:abstract ?desc .
+                    FILTER (LANG(?desc) = 'en')
+                }
+            }
+            LIMIT 3
+        """
+    }
+    
+    print(f"Loaded Graph with {len(g)} triples.\n")
+    
+    # Run Local Queries
+    for title, query in list(queries.items())[:-1]: # Skip the last one for special handling
+        print(f"--- {title} ---")
+        try:
+            results = g.query(query)
+            for row in results:
+                print(row)
+        except Exception as e:
+            print(f"Query Error: {e}")
+        print("\n")
+
+    # Run Federated Query (Special Handling)
+    print(f"--- 5. (Federated) Get Manufacturer Description from DBpedia ---")
+    print("Attempting to run SERVICE query via rdflib (may fail due to DBpedia restrictions)...")
+    fed_query = queries["5. (Federated) Get Manufacturer Description from DBpedia"]
+    
+    try:
+        results = g.query(fed_query)
+        for row in results:
+            print(row)
+    except Exception as e:
+        print(f"Standard SERVICE query failed ({e}).\nData is likely interlinked, but local engine cannot negotiate with DBpedia.")
+        print("Fallback: Verifying Interlinking manually via SPARQLWrapper...")
+        
+        try:
+            from SPARQLWrapper import SPARQLWrapper, JSON
+            sparql = SPARQLWrapper("http://dbpedia.org/sparql")
+            
+            # Get a manufacturer link from our graph
+            manu_link_query = """
+                PREFIX ex: <http://example.org/cars/>
+                PREFIX owl: <http://www.w3.org/2002/07/owl#>
+                SELECT ?link WHERE { ?m a ex:Manufacturer ; owl:sameAs ?link . } LIMIT 1
+            """
+            res = g.query(manu_link_query)
+            link = list(res)[0][0]
+            print(f"Found Interlink: {link}")
+            
+            # Query DBpedia for that link
+            dbpedia_q = f"""
+                PREFIX dbo: <http://dbpedia.org/ontology/>
+                SELECT ?desc WHERE {{ <{link}> dbo:abstract ?desc . FILTER (LANG(?desc) = 'en') }} LIMIT 1
+            """
+            sparql.setQuery(dbpedia_q)
+            sparql.setReturnFormat(JSON)
+            results = sparql.query().convert()
+            
+            for result in results["results"]["bindings"]:
+                print(f"Description from DBpedia: {result['desc']['value'][:200]}...")
+                
+        except ImportError:
+            print("SPARQLWrapper not installed. Cannot run fallback.")
+        except Exception as ex:
+            print(f"Fallback failed: {ex}")
+
+if __name__ == "__main__":
+    run_validation()