Metadata-Version: 2.1
Name: py_spring_core
Version: 0.0.7
Summary: PySpring is a Python web framework inspired by Spring Boot, combining FastAPI, and Pydantic for building scalable web applications with auto dependency injection, configuration management, and a web server.
Author-Email: William Chen <OW6201231@gmail.com>
License: MIT
Requires-Python: >=3.10
Requires-Dist: annotated-types==0.7.0
Requires-Dist: anyio==4.4.0
Requires-Dist: certifi==2024.7.4
Requires-Dist: click==8.1.7
Requires-Dist: dnspython==2.6.1
Requires-Dist: email-validator==2.2.0
Requires-Dist: exceptiongroup==1.2.2
Requires-Dist: fastapi==0.112.0
Requires-Dist: fastapi-cli==0.0.5
Requires-Dist: greenlet==3.0.3
Requires-Dist: h11==0.14.0
Requires-Dist: httpcore==1.0.5
Requires-Dist: httptools==0.6.1
Requires-Dist: httpx==0.27.0
Requires-Dist: idna==3.7
Requires-Dist: itsdangerous==2.2.0
Requires-Dist: Jinja2==3.1.4
Requires-Dist: loguru==0.7.2
Requires-Dist: markdown-it-py==3.0.0
Requires-Dist: MarkupSafe==2.1.5
Requires-Dist: mdurl==0.1.2
Requires-Dist: orjson==3.10.7
Requires-Dist: pydantic==2.8.2
Requires-Dist: pydantic-extra-types==2.9.0
Requires-Dist: pydantic-settings==2.4.0
Requires-Dist: pydantic-core==2.20.1
Requires-Dist: Pygments==2.18.0
Requires-Dist: python-dotenv==1.0.1
Requires-Dist: python-multipart==0.0.9
Requires-Dist: PyYAML==6.0.2
Requires-Dist: rich==13.7.1
Requires-Dist: shellingham==1.5.4
Requires-Dist: sniffio==1.3.1
Requires-Dist: starlette==0.37.2
Requires-Dist: typer>=0.12.5
Requires-Dist: typing-extensions==4.12.2
Requires-Dist: ujson==5.10.0
Requires-Dist: uvicorn==0.30.5
Requires-Dist: uvloop==0.19.0
Requires-Dist: watchfiles==0.23.0
Requires-Dist: websockets==12.0
Requires-Dist: cachetools>=5.5.0
Requires-Dist: mypy>=1.11.2
Description-Content-Type: text/markdown

# **PySpring** Framework

#### **PySpring** is a Python web framework inspired by Spring Boot. It combines FastAPI for the web layer, and Pydantic for data validation. PySpring provides a structured approach to building scalable web applications with `auto dependency injection`, `auto configuration management` and a `web server` for hosting your application.

## Key Features
- **Application Initialization**: `PySpringApplication` class serves as the main entry point for the **PySpring** application. It initializes the application from a configuration file, scans the application source directory for Python files, and groups them into class files and model files.

- **Application Context Management**: **PySpring** manages the application context and dependency injection. It registers application entities such as components, controllers, bean collections, and properties. It also initializes the application context and injects dependencies.

- **REST Controllers**: **PySpring** supports RESTful API development using the RestController class. It allows you to define routes, handle HTTP requests, and register middlewares easily.

- **Component-based Architecture**: **PySpring** encourages a component-based architecture, where components are reusable and modular building blocks of the application. Components can have their own lifecycle and can be registered and managed by the application context.

- **Properties Management**: Properties classes provide a convenient way to manage application-specific configurations. **PySpring** supports loading properties from a properties file and injecting them into components.

- **Framework Modules**: **PySpring** allows the integration of additional framework modules to extend the functionality of the application. Modules can provide additional routes, middlewares, or any other custom functionality required by the application.

- **Builtin FastAPI Integration**: **PySpring** integrates with `FastAPI`, a modern, fast (high-performance), web framework for building APIs with Python. It leverages FastAPI's features for routing, request handling, and server configuration.

## Project Structure
```
PySpring/
├── src/                    # Source code directory
├── tests/                  # Test files
├── logs/                   # Application logs
├── py_spring_core/         # Core framework package
├── app-config.json         # Application configuration
├── application-properties.json  # Application properties
├── main.py                 # Application entry point
├── pyproject.toml          # Project metadata and dependencies
└── README.md              # Project documentation
```

## Getting Started

### Prerequisites
- Python 3.10 or higher
- pip (Python package installer)

### Installation
1. Install the **PySpring** framework:
```bash
pip install py-spring-core
```

2. Create a new Python project and navigate to its directory

3. Set up your application:
   - Implement your application properties, components, and controllers using **PySpring** conventions inside the declared source code folder (which can be modified via the `app_src_target_dir` key in `app-config.json`)
   - Create an `app-config.json` file for your application configuration
   - Create an `application-properties.json` file for your application properties

4. Create your main application script:
```python
from py_spring_core import PySpringApplication

def main():
    app = PySpringApplication("./app-config.json")
    app.run()

if __name__ == "__main__":
    main()
```

5. Run your application:
```bash
python main.py
```

For a complete example project, please refer to the [PySpring Example Project](https://github.com/NFUChen/PySpring-Example-Project).

## Development Setup
1. Clone the repository:
```bash
git clone https://github.com/NFUChen/PySpring.git
cd PySpring
```

2. Install development dependencies:
```bash
pip install -e ".[dev]"
```

3. Run tests:
```bash
pytest
```

## Dependencies
PySpring relies on several key dependencies:
- FastAPI (0.112.0)
- Pydantic (2.8.2)
- Uvicorn (0.30.5)
- Loguru (0.7.2)
- And other supporting packages

For a complete list of dependencies, see `pyproject.toml`.

## Contributing

Contributions to **PySpring** are welcome! If you find any issues or have suggestions for improvements, please:
1. Fork the repository
2. Create a feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request

## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
