fastpy-rest 0.1.3
FastPy-Rest is a minimalisitc lightweight framework to create restapis easily.

# FastPy-Rest - A Simple Python Web Framework

[FastPy-Rest]() is a lightweight Python web framework designed for educational purposes. It provides a simple and easy-to-understand structure to help you learn the fundamentals of building a web framework from scratch. With FastPy, you can explore various aspects of web development, including routing, request handling, response generation, and more.

## Features

* Minimalistic design for educational purposes.
* Supports common HTTP methods (GET, POST, PUT, PATCH, DELETE).
* Route handling and request processing.
* Exception handling for HTTP errors.
* Asynchronous request handling with asyncio.
* Basic support for request parameters, headers, and cookies.

## Getting Started

To get started with FastPy, follow these steps:

1. Install the package with `pip install fastpy-rest`
2. Create your own routes and handlers
3. Start the server

   ```python
   from fastpy_rest import FastPy

   app = FastPy()

   @app.get("/get")
   async def get(id: int):
      return id

   if __name__ == "__main__":
      app.run()
   ```

## Documentation

### Defining Routes

This project is highly inspired by FastAPI and it has the very same route defining syntax too, using decorators. The handler function may or may not be async, framework takes care of that by itself whether to await or call without await.

```python
@app.get("/path")
async def get_handler():
   ...

```

Similary other methods like `post`, `put`, `patch` and `delete` can be defined.

### Various Input Parameters

#### Query Params

We can take query params in our handlers by simply taking input parameters with type annotations except some annotations which we will discuss in body, headers, cookies and path.

```python
@app.get("/path")
async def get_handler(id: int):
   return id
```

#### Path Params

Any parameter in handler function which is mentioned in path as `/{path_param}` will be considered a path parameter.

```python
@app.get("/path/{id}")
async def get_handler(id: int):
   return id
```

#### Body

Any parameter with annotation of subclass of `BaseModel` defined in `pydantic` is considered as a body json and body will be validated according to this body.

```python
from pydantic import BaseModel

class StudentIn(BaseModel):
   name: str
   class: int

@app.post("/create")
async def create_student(student: StudentIn):
    return student
```

#### Headers

Parameters with primitive type annotations along with default value of `Headers` will be extracted from headers.

```python
from fastpy_rest import Headers

@app.get("/path")
async def handler(authorization: str = Headers())):
   return {"authorization": authorization}
```

#### Cookies

Very same as headers, instead of `Headers()`, `Cookies` is used as a default value.

### Data Serialization and Validation

For the purpose of serialization, deserialization and validation, Pydantic is used heavily. For body, we can denote it in a pydantic model and deserialize accordingly. In the framework, input annotations are mandatory and data is deserialized according to those annotations. Return annotation is not mandatory but we can also define that and enforce the validation of output data.

```python
from pydantic import BaseModel

class StudentIn(BaseModel):
   name: str
   class: int

@app.post("/create")
async def create_student(student: StudentIn) -> StudentIn:
    return student
```

### Request Class

To avoid the data validation, `Request` class can be used in annotations and in handler, request object will be provider with parsed path, query and other params.

```python
from fastpy_rest import Request

@app.post("/create")
async def create_student(request: Request):
    ...
```

### Response Class

To send custom status code for success (default=200), Response class object should be returned from handler. In this case, return type will not be validated.

```python
from fastpy_rest import Request, Response

@app.post("/create")
async def create_student(request: Request):
    return Response(201, "Student has been created.")
```

### Custom Exceptions

To raise exceptions with appropriate code and messages, `HttpException` class has been defined.

```python
from fastpy_rest import Request, HttpException

@app.post("/create")
async def create_student(request: Request):
    raise HttpException(401, "Request not authenticated.")
```

## Testing

You can run the provided unit tests to verify the functionality of FastPy. To run all the tests, use the following command:

```bash
python -m unittest discover -p 'test_*.py'
```

## Contributing

FastPy is intended for educational purposes and may not be suitable for production use. If you'd like to contribute to the project or have any suggestions, please feel free to create an issue or submit a pull request.

## License

This project is licensed under the MIT License. See the [LICENSE](https://github.com/sineshashi/FastPy/blob/master/LICENSE) file for details.

## Acknowledgments

FastPy was created as an educational project to help individuals learn the basics of web framework development. We acknowledge the contributions of the open-source community and various educational resources that inspired this project.

---

Happy learning and building with FastPy! ðŸ˜Š