Naming Convention - zamaniamin/python GitHub Wiki

When using FastAPI, following a consistent and clear naming convention for your models, schemas, and services can enhance code readability and maintainability. Here are some best practices:

Models:

Use Singular Nouns:
- Name your models with singular nouns to represent a single instance of the entity.
```
class User(BaseModel):
    username: str
    email: str
```
Be Descriptive:
- Choose descriptive names that convey the purpose of the model.
```
class Item(BaseModel):
    name: str
    description: str
```

Schemas:

Use CamelCase:

CamelCase is a common convention for naming schemas.

class ItemResponse(BaseModel):
    name: str
    description: str

Include the Word "Response" or "Request" for Clarity:
- Make it clear whether a schema is used for request or response purposes.
```
class ItemCreateRequest(BaseModel):
    name: str
    description: str
```

Services:

Use Singular Nouns for Service Classes:
- Similar to models, use singular nouns for service classes.
```
class UserService:
    def create_user(self, user: User):
        # implementation
```

Be Explicit:

Choose names that clearly indicate the service's functionality.

class EmailService:
    def send_email(self, to: str, subject: str, body: str):
        # implementation

CRUD Operations:

Follow CRUD Naming Conventions:

For services that perform CRUD operations, follow naming conventions like get, create, update, and delete.

class ItemService:
    def create_item(self, item: Item):
        # implementation

    def get_item(self, item_id: int):
        # implementation

    def update_item(self, item_id: int, item: Item):
        # implementation

    def delete_item(self, item_id: int):
        # implementation

Miscellaneous:

Use Consistent Prefixes:
- If needed, use consistent prefixes for related classes to group them visually.
```
class UserModel:
    # ...

class UserSchema:
    # ...

class UserService:
    # ...
```
Avoid Ambiguous Names:
- Ensure that your names are not ambiguous and clearly convey the purpose of each class.

Remember that these are general guidelines, and the most important thing is to be consistent within your project. Choose a convention that fits your team's style and stick to it throughout your codebase.