Update code in endpoints/pen.post.py

endpoints/pen.post.py

@@ -0,0 +1,81 @@
+Sure, here's an example of a FastAPI endpoint that saves data to a database using SQLAlchemy and Pydantic:
+
+```python
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+app = FastAPI()
+
+# SQLAlchemy setup
+Base = declarative_base()
+engine = create_engine('sqlite:///database.db', echo=True)
+Session = sessionmaker(bind=engine)
+
+# SQLAlchemy model
+class Pen(Base):
+    __tablename__ = 'pens'
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    color = Column(String)
+    brand = Column(String)
+
+    def __repr__(self):
+        return f"Pen(id={self.id}, name='{self.name}', color='{self.color}', brand='{self.brand}')"
+
+Base.metadata.create_all(engine)
+
+# Pydantic model
+class PenSchema(BaseModel):
+    name: str
+    color: str
+    brand: str
+
+    class Config:
+        orm_mode = True
+
+# Endpoint to save a pen to the database
+@app.post('/pen')
+def save_pen(pen: PenSchema):
+    session = Session()
+    try:
+        pen_obj = Pen(name=pen.name, color=pen.color, brand=pen.brand)
+        session.add(pen_obj)
+        session.commit()
+        return {"message": "Pen saved successfully"}
+    except Exception as e:
+        session.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        session.close()
+```
+
+Here's a breakdown of the code:
+
+1. We import the necessary modules from FastAPI, Pydantic, and SQLAlchemy.
+2. We set up SQLAlchemy by creating a declarative base, engine, and session maker.
+3. We define the `Pen` model using SQLAlchemy's `declarative_base` and `Column` classes.
+4. We create a Pydantic model `PenSchema` that will be used for data validation and serialization/deserialization.
+5. We define the `/pen` endpoint using the `@app.post` decorator from FastAPI.
+6. Inside the `save_pen` function, we create a new SQLAlchemy session and try to save the pen data to the database.
+7. If the operation is successful, we commit the changes and return a success message.
+8. If an exception occurs, we roll back the changes and raise an `HTTPException` with a 500 status code and the error message.
+9. Finally, we close the session in the `finally` block.
+
+To use this endpoint, you can send a POST request to `/pen` with a JSON payload containing the pen data, like this:
+
+```json
+{
+    "name": "Pilot G2",
+    "color": "Blue",
+    "brand": "Pilot"
+}
+```
+
+The endpoint will validate the data using the `PenSchema` model, create a new `Pen` instance, and save it to the database.
+
+Note that you'll need to have SQLAlchemy and a compatible database driver installed for this code to work. In this example, we're using SQLite, but you can easily switch to a different database by modifying the engine URL.