# This file makes the config directory a Python package. import os class Settings: # Replace with actual values, potentially loaded from environment variables or a config file API_BASE_URL = os.getenv("API_BASE_URL", "https://api.example.com") CLIENT_ID = os.getenv("CLIENT_ID", "your_client_id") CLIENT_SECRET = os.getenv("CLIENT_SECRET", "your_client_secret") HTTP_PROXY = os.getenv("HTTP_PROXY", "http://proxy.abc.com:8080") HTTPS_PROXY = os.getenv("HTTPS_PROXY", "http://proxy.abc.com:8080") # Rate Limiter settings RATE_LIMIT = int(os.getenv("RATE_LIMIT", 180)) # requests RATE_PERIOD = int(os.getenv("RATE_PERIOD", 60)) # seconds settings = Settings() # This file makes the models directory a Python package. from typing import Any, Dict, Optional class APIResponse: """ A simple wrapper for API responses, assuming JSON structure. Adjust based on the actual API response format. """ def __init__(self, response_data: Dict[str, Any]): self._raw_data = response_data # Example: Assuming the actual data is under a 'data' key self.data: Any = response_data.get('data') self.metadata: Optional[Dict[str, Any]] = response_data.get('meta') self.errors: Optional[Any] = response_data.get('errors') def __repr__(self) -> str: return f"APIResponse(data={self.data}, metadata={self.metadata}, errors={self.errors})" @property def raw(self) -> Dict[str, Any]: return self._raw_data from typing import Dict, Any class ServiceRequest: """ Represents a service request structure. Placeholder implementation. """ def __init__(self, data: Dict[str, Any]): # Basic validation or attribute setting can happen here self.data = data def to_dict(self) -> Dict[str, Any]: return self.data # This file makes the utils directory a Python package. import time import threading class RateLimiter: """ A simple token bucket rate limiter. """ def __init__(self, limit: int, period: int): self.limit = limit self.period = period self.tokens = limit self.last_refill_time = time.monotonic() self._lock = threading.Lock() def _refill(self): now = time.monotonic() elapsed = now - self.last_refill_time if elapsed >= self.period: self.tokens = self.limit self.last_refill_time = now # Optional: Allow partial refills based on elapsed time if needed def allow_request(self) -> bool: with self._lock: self._refill() if self.tokens > 0: self.tokens -= 1 return True return False import json from typing import Any def stringify(data: Any) -> str: """ Converts Python objects (like lists or dicts) into a JSON string representation. Handles potential JSON serialization errors. """ try: # Use compact separators to minimize length if needed by the API return json.dumps(data, separators=(',', ':')) except TypeError as e: # Log the error or raise a more specific exception if needed print(f"Error stringifying data: {e}") raise ValueError(f"Could not stringify data: {data}") from e from typing import Dict, Any, List, Optional class ValidationError(ValueError): """Custom exception for validation errors.""" pass def validate_request(data: Optional[Dict[str, Any]], required_fields: List[str]): """ Validates that the request data contains the required fields. Supports nested fields using dot notation (e.g., 'meta.updatedBy'). """ if data is None: raise ValidationError("Request data cannot be None.") missing_fields = [] for field_path in required_fields: parts = field_path.split('.') current_data = data found = True for part in parts: if isinstance(current_data, dict) and part in current_data: current_data = current_data[part] else: found = False break if not found: missing_fields.append(field_path) if missing_fields: raise ValidationError(f"Missing required fields: {', '.join(missing_fields)}") def validate_user(user_id: Any): """Validates the user identifier.""" if not user_id or not isinstance(user_id, (str, int)): # Adjust types as needed raise ValidationError(f"Invalid user identifier: {user_id}") # Add more specific user validation logic if required (e.g., format check) def validate_location_id(location_id: Any): """Validates the location ID.""" if not isinstance(location_id, int) or location_id <= 0: raise ValidationError(f"locationId must be a positive integer, got: {location_id}") # Add other specific validators as needed # This file makes the services directory a Python package. import requests import time import logging import threading from typing import Optional, Dict, Any, List, Union from config.settings import settings from models.api_response import APIResponse from utils.validators import validate_request, validate_user, validate_location_id, ValidationError from utils.rate_limiter import RateLimiter from utils.stringifier import stringify from models.service_request import ServiceRequest # Assuming this model exists # Configure logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) class APIError(Exception): """Custom exception for API related errors.""" def __init__(self, message, status_code=None, response_data=None): super().__init__(message) self.status_code = status_code self.response_data = response_data class AuthenticationError(APIError): """Custom exception for authentication failures.""" pass class RateLimitError(APIError): """Custom exception for rate limit exceeded errors.""" pass class ThirdPartyAPIFacade: def __init__(self): self.session = requests.Session() self.token: Optional[str] = None self.token_expiry: float = 0 self._token_lock = threading.Lock() # Lock for thread-safe token refresh if settings.HTTP_PROXY or settings.HTTPS_PROXY: self.proxies = { 'http': settings.HTTP_PROXY, 'https': settings.HTTPS_PROXY } logger.info(f"Setting proxies: {self.proxies}") self.session.proxies = self.proxies else: self.proxies = None logger.info("No proxies configured.") self.base_url = settings.API_BASE_URL self.rate_limiter = RateLimiter(limit=settings.RATE_LIMIT, period=settings.RATE_PERIOD) def _get_access_token(self) -> str: """ Retrieves the access token, refreshing it if necessary. Thread-safe. """ with self._token_lock: if not self.token or time.time() > self.token_expiry: logger.info("Access token expired or not found. Requesting new token.") payload = { 'grant_type': 'client_credentials', 'client_id': settings.CLIENT_ID, 'client_secret': settings.CLIENT_SECRET, 'scope': '*' # Adjust scope if needed } token_url = f"{self.base_url}/v1/los/oauth/token" try: # Use a separate request for token to avoid session header interference if any response = requests.post(token_url, data=payload, proxies=self.proxies, timeout=10) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) token_data = response.json().get('data') if not token_data or 'access_token' not in token_data or 'expires_in' not in token_data: logger.error(f"Invalid token response structure: {response.json()}") raise AuthenticationError("Invalid token data received from API.") self.token = token_data['access_token'] # Add a small buffer (e.g., 60 seconds) to expiry time buffer = 60 self.token_expiry = time.time() + token_data['expires_in'] - buffer logger.info(f"Successfully obtained new access token. Expires around {time.ctime(self.token_expiry)}") except requests.exceptions.RequestException as e: logger.exception(f"Failed to get access token from {token_url}: {e}") raise AuthenticationError(f"Failed to get access token: {e}") from e except (KeyError, ValueError) as e: # Handle potential JSON parsing or key errors logger.exception(f"Failed to parse token response: {e}") raise AuthenticationError(f"Failed to parse token response: {e}") from e # Return the current valid token if not self.token: # Should not happen if logic above is correct, but as a safeguard raise AuthenticationError("Token is unexpectedly None after refresh attempt.") return self.token def _make_request(self, method: str, endpoint: str, is_file_download: bool = False, **kwargs) -> Union[APIResponse, requests.Response]: """ Makes a request to the third-party API, handling authentication, rate limiting, and errors. """ if not self.rate_limiter.allow_request(): logger.warning("Rate limit exceeded.") raise RateLimitError("Rate limit exceeded. Please wait before retrying.") try: token = self._get_access_token() except AuthenticationError as e: logger.error(f"Authentication failed: {e}") # Re-raise as APIError or handle appropriately raise APIError(f"Authentication failed: {e}") from e headers = kwargs.pop('headers', {}) headers['Authorization'] = f'Bearer {token}' # Content-Type is typically set by requests based on 'json' or 'data'/'files' kwargs, # but can be overridden if needed. For multipart/form-data (file uploads), # requests sets it automatically when 'files' is used. # Avoid setting default 'Content-Type': 'application/json' here if using 'files'. if 'json' in kwargs and 'Content-Type' not in headers: headers['Content-Type'] = 'application/json' url = f"{self.base_url}{endpoint}" logger.info(f"Making {method} request to {url}") logger.debug(f"Headers: {headers}") logger.debug(f"Params: {kwargs.get('params')}") logger.debug(f"JSON Payload: {kwargs.get('json')}") logger.debug(f"Data Payload: {kwargs.get('data')}") logger.debug(f"Files: {kwargs.get('files')}") try: response = self.session.request( method, url, headers=headers, timeout=30, # Increased timeout **kwargs ) logger.info(f"API request to {url} completed with status: {response.status_code}") logger.debug(f"Response Headers: {response.headers}") # Check if the response indicates a file download content_disposition = response.headers.get('Content-Disposition', '').lower() is_attachment = 'attachment' in content_disposition if is_file_download: if response.ok and is_attachment: logger.info(f"Detected file download response for {url}.") return response # Return raw response for file handling else: # Try to get error details even for failed file downloads error_details = f"Expected file download but received status {response.status_code}." try: error_data = response.json() error_details += f" Response: {error_data}" except ValueError: error_details += f" Response (non-JSON): {response.text[:200]}" logger.error(error_details) raise APIError(error_details, status_code=response.status_code) # Process non-file responses response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) # Handle successful responses (usually JSON) content_type = response.headers.get('Content-Type', '').lower() if 'application/json' in content_type: try: json_data = response.json() logger.debug(f"Parsed JSON response: {json_data}") return APIResponse(json_data) except ValueError as e: logger.exception(f"Failed to parse JSON response from {url}. Content: {response.text[:200]}") raise APIError(f"Invalid JSON response received: {e}", status_code=response.status_code, response_data=response.text) else: # Handle unexpected successful responses that are not JSON logger.warning(f"Received non-JSON response from {url} (Content-Type: {content_type}). Returning raw response.") # Depending on requirements, you might want to return response.text, response.content, or raise an error # For now, let's wrap it minimally, assuming 'data' might be the text content return APIResponse({'data': response.text, 'meta': {'content_type': content_type}}) except requests.exceptions.HTTPError as e: logger.error(f"HTTP error occurred for {url}: {e.response.status_code} {e.response.reason}") error_data = None try: error_data = e.response.json() logger.error(f"Error response body: {error_data}") except ValueError: # Handle cases where error response is not JSON logger.error(f"Error response body (non-JSON): {e.response.text[:500]}") error_data = e.response.text raise APIError(f"API request failed: {e}", status_code=e.response.status_code, response_data=error_data) from e except requests.exceptions.Timeout as e: logger.error(f"Request timed out for {url}: {e}") raise APIError(f"Request timed out: {e}") from e except requests.exceptions.ConnectionError as e: logger.error(f"Connection error for {url}: {e}") raise APIError(f"Connection error: {e}") from e except requests.exceptions.RequestException as e: logger.exception(f"An unexpected error occurred during request to {url}: {e}") raise APIError(f"API request failed unexpectedly: {e}") from e except ValidationError as e: # Catch validation errors from utils logger.error(f"Validation failed: {e}") raise # Re-raise validation errors # --- Public API Methods --- def get_access_token(self) -> str: """Public method to explicitly get the current access token.""" try: return self._get_access_token() except AuthenticationError as e: raise APIError(f"Failed to retrieve access token: {e}") from e # Collateral Overview def update_collateral_overview(self, location_id: int, data: Dict[str, Any]) -> Dict[str, Any]: validate_location_id(location_id) validate_request(data, required_fields=['meta.updatedBy', 'data']) validate_user(data['meta']['updatedBy']) response = self._make_request('PATCH', f'/v1/los/collateralOverview/{location_id}', json=data) return response.data def get_collateral_overview(self, location_id: int, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: validate_location_id(location_id) endpoint = f'/v1/los/loan/information/collateralOverview/{location_id}' response = self._make_request('GET', endpoint, params=params) return response.data def get_collateral_fields(self) -> Dict[str, Any]: response = self._make_request('GET', '/v1/los/collateralOverview/fields') return response.data def get_environmental_risk_codes(self, location_id: int) -> Dict[str, Any]: validate_location_id(location_id) response = self._make_request('GET', f'/v1/los/loan/information/environmental/riskCodes/{location_id}') return response.data # Service Request def create_service_request(self, data: Dict[str, Any]) -> Dict[str, Any]: # Assuming ServiceRequest model might do some validation/transformation service_request = ServiceRequest(data) validate_request(service_request.to_dict(), required_fields=[ 'meta.cabinet', 'meta.currency', 'meta.requestedBy', 'meta.createdBy', 'meta.srfAction', 'meta.processAsWarnings', 'data.transaction', 'data.collaterals' ]) response = self._make_request('POST', '/v1/los/serviceRequest/form', json=service_request.to_dict()) return response.data def add_services(self, location_id: int, data: Dict[str, Any]) -> Dict[str, Any]: validate_location_id(location_id) validate_request(data, required_fields=['meta.updatedBy', 'data.services']) validate_user(data['meta']['updatedBy']) response = self._make_request('POST', f'/v1/los/serviceRequest/addService/{location_id}', json=data) return response.data def add_collateral(self, loan_id: Optional[int] = None, location_id: Optional[int] = None, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: if not data: raise ValidationError("Request data cannot be None for add_collateral.") if sum([bool(loan_id), bool(location_id)]) != 1: raise ValidationError("Provide exactly one of loanID or locationID.") entity_type = "loanID" if loan_id else "locationID" entity_id = loan_id or location_id if entity_type == "locationID": validate_location_id(entity_id) # Add validation for loan_id if needed endpoint = f'/v1/los/serviceRequest/addCollateral/{entity_type}/{entity_id}' validate_request(data, required_fields=['meta.updatedBy', 'meta.processAsWarnings', 'data.collaterals']) validate_user(data['meta']['updatedBy']) response = self._make_request('POST', endpoint, json=data) return response.data def get_service_request_status(self, service_request_id: Optional[int] = None, loan_id: Optional[int] = None, location_id: Optional[int] = None) -> Dict[str, Any]: if sum([bool(service_request_id), bool(loan_id), bool(location_id)]) != 1: raise ValidationError("Provide exactly one of serviceRequestID, loanID, or locationID.") if service_request_id: entity_type, entity_id = "serviceRequestID", service_request_id elif loan_id: entity_type, entity_id = "loanID", loan_id else: # location_id must be set entity_type, entity_id = "locationID", location_id validate_location_id(entity_id) # Add validation for service_request_id and loan_id if needed endpoint = f'/v1/los/serviceRequest/status/{entity_type}/{entity_id}' response = self._make_request('GET', endpoint) return response.data def get_service_request_fields(self) -> Dict[str, Any]: response = self._make_request('GET', '/v1/los/serviceRequest/fields') return response.data # File Management def get_file_list(self, service_request_id: Optional[int] = None, loan_id: Optional[int] = None, location_id: Optional[int] = None) -> Dict[str, Any]: if sum([bool(service_request_id), bool(loan_id), bool(location_id)]) != 1: raise ValidationError("Provide exactly one of serviceRequestID, loanID, or locationID.") if service_request_id: entity_type, entity_id = "serviceRequestID", service_request_id elif loan_id: entity_type, entity_id = "loanID", loan_id else: # location_id must be set entity_type, entity_id = "locationID", location_id validate_location_id(entity_id) # Add validation for service_request_id and loan_id if needed endpoint = f'/v1/los/serviceRequest/files/list/{entity_type}/{entity_id}' response = self._make_request('GET', endpoint) return response.data def download_file(self, upload_id: int) -> requests.Response: """Downloads a file and returns the raw requests.Response object.""" if not isinstance(upload_id, int) or upload_id <= 0: raise ValidationError("upload_id must be a positive integer.") # Pass is_file_download=True to handle response correctly response = self._make_request('GET', f'/v1/los/serviceRequest/files/download/{upload_id}', stream=True, is_file_download=True) # _make_request now returns the raw response if is_file_download is True and successful return response def upload_file(self, location_id: int, uploaded_by: str, file_data: Any, file_name: str, file_content_type: str, prepared_by: Optional[str] = None, report_title: Optional[str] = None, report_date: Optional[str] = None, display_filename: Optional[str] = None, service_groups: Optional[List[Dict[str, Any]]] = None, service_types: Optional[List[Dict[str, Any]]] = None, document_types: Optional[List[Dict[str, Any]]] = None, document_status: Optional[Dict[str, Any]] = None) -> APIResponse: """Uploads a file using multipart/form-data.""" validate_location_id(location_id) validate_user(uploaded_by) # Prepare form data fields (non-file parts) form_data = { # API seems to expect these in the URL path based on original code, # but often file uploads take metadata as form fields. Double-check API spec. # If they MUST be in URL, the endpoint needs adjustment. Assuming form fields for now. # 'locationId': location_id, # Usually part of URL or inferred # 'uploadedBy': uploaded_by, # Usually part of URL or inferred } if prepared_by: form_data['preparedBy'] = prepared_by if report_title: form_data['reportTitle'] = report_title if report_date: form_data['reportDate'] = report_date if display_filename: form_data['displayFileName'] = display_filename if service_groups: form_data['serviceGroups'] = stringify(service_groups) if service_types: form_data['serviceTypes'] = stringify(service_types) if document_types: form_data['documentTypes'] = stringify(document_types) if document_status: form_data['documentStatus'] = stringify(document_status) # Prepare the file part for multipart upload # 'file_data' should be a file-like object (e.g., open(filepath, 'rb')) or bytes files = {'file': (file_name, file_data, file_content_type)} # Endpoint from original code: /v1/los/files/upload/locationId/{location_id}/uploadedBy/{uploaded_by} # This suggests locationId and uploadedBy are path parameters. endpoint = f'/v1/los/files/upload/locationId/{location_id}/uploadedBy/{uploaded_by}' # Make the request. _make_request handles auth. # requests will automatically set Content-Type to multipart/form-data. response = self._make_request( 'POST', endpoint, data=form_data, # Use 'data' for form fields files=files # Use 'files' for the file part ) # Assuming upload returns JSON confirmation return response # Data Capture Fields & Indicators def get_data_capture(self, location_service_id: int) -> Dict[str, Any]: if not isinstance(location_service_id, int) or location_service_id <= 0: raise ValidationError("locationServiceId must be a positive integer") response = self._make_request('GET', f'/v1/datacaptures/locationServiceId/{location_service_id}') return response.data # Utilities API: Service Types def get_service_types(self) -> Dict[str, Any]: response = self._make_request('GET', '/v1/los/utility/serviceTypes') return response.data # Utilities API: Document Types def get_document_types(self) -> Dict[str, Any]: response = self._make_request('GET', '/v1/los/utility/documentTypes') return response.data # Utilities API: Document Status def get_document_status(self) -> Dict[str, Any]: response = self._make_request('GET', '/v1/los/utility/documentStatus') return response.data # Singleton instance (consider dependency injection for better testability in larger apps) api_facade = ThirdPartyAPIFacade() from flask import Flask, jsonify, request, Response, stream_with_context import os import io # Assuming the facade instance is created in services.third_party_api_facade from services.third_party_api_facade import api_facade, APIError, RateLimitError, ValidationError app = Flask(__name__) # --- Error Handling --- @app.errorhandler(APIError) def handle_api_error(error): app.logger.error(f"API Error: {error} (Status: {error.status_code}, Data: {error.response_data})") response = jsonify({ "error": "API Interaction Failed", "message": str(error), "details": error.response_data }) response.status_code = error.status_code or 500 return response @app.errorhandler(RateLimitError) def handle_rate_limit_error(error): app.logger.warning(f"Rate Limit Error: {error}") response = jsonify({"error": "Rate Limit Exceeded", "message": str(error)}) response.status_code = 429 # Too Many Requests return response @app.errorhandler(ValidationError) def handle_validation_error(error): app.logger.warning(f"Validation Error: {error}") response = jsonify({"error": "Invalid Request Data", "message": str(error)}) response.status_code = 400 # Bad Request return response @app.errorhandler(Exception) def handle_generic_error(error): app.logger.exception(f"An unexpected error occurred: {error}") response = jsonify({"error": "Internal Server Error", "message": "An unexpected error occurred."}) response.status_code = 500 return response # --- Routes --- @app.route('/health', methods=['GET']) def health_check(): """Basic health check endpoint.""" return jsonify({"status": "healthy"}), 200 @app.route('/token', methods=['GET']) def get_token(): """Endpoint to explicitly get the API token (for debugging/testing).""" token = api_facade.get_access_token() return jsonify({"access_token": token}), 200 # --- Collateral Routes --- @app.route('/collateral/', methods=['GET']) def get_collateral(location_id): """Get collateral overview by location ID.""" params = request.args.to_dict() # Pass any query params data = api_facade.get_collateral_overview(location_id, params=params) return jsonify(data), 200 @app.route('/collateral/', methods=['PATCH']) def update_collateral(location_id): """Update collateral overview.""" req_data = request.get_json() if not req_data: raise ValidationError("Request body must be JSON.") updated_data = api_facade.update_collateral_overview(location_id, req_data) return jsonify(updated_data), 200 @app.route('/collateral/fields', methods=['GET']) def get_collateral_fields_route(): """Get collateral fields.""" data = api_facade.get_collateral_fields() return jsonify(data), 200 # --- Service Request Routes --- @app.route('/service-request', methods=['POST']) def create_service_request_route(): """Create a new service request.""" req_data = request.get_json() if not req_data: raise ValidationError("Request body must be JSON.") result = api_facade.create_service_request(req_data) return jsonify(result), 201 # 201 Created @app.route('/service-request/status', methods=['GET']) def get_service_request_status_route(): """Get service request status by ID (serviceRequestID, loanID, or locationID).""" service_request_id = request.args.get('serviceRequestID', type=int) loan_id = request.args.get('loanID', type=int) location_id = request.args.get('locationID', type=int) status = api_facade.get_service_request_status(service_request_id, loan_id, location_id) return jsonify(status), 200 # --- File Management Routes --- @app.route('/files/download/', methods=['GET']) def download_file_route(upload_id): """Download a file by upload ID.""" try: file_response = api_facade.download_file(upload_id) # Extract filename from Content-Disposition header content_disposition = file_response.headers.get('Content-Disposition') filename = "downloaded_file" # Default filename if content_disposition: parts = content_disposition.split('filename=') if len(parts) > 1: filename = parts[1].strip('"') # Stream the file content def generate(): for chunk in file_response.iter_content(chunk_size=8192): yield chunk return Response(stream_with_context(generate()), headers={ 'Content-Disposition': f'attachment; filename="{filename}"', 'Content-Type': file_response.headers.get('Content-Type', 'application/octet-stream') }) except APIError as e: # Re-raise to be caught by the APIError handler raise e except Exception as e: app.logger.exception(f"Error during file download streaming for upload ID {upload_id}: {e}") return jsonify({"error": "File Download Failed", "message": str(e)}), 500 @app.route('/files/upload/', methods=['POST']) def upload_file_route(location_id): """Upload a file for a given location ID.""" if 'file' not in request.files: raise ValidationError("Missing 'file' part in the multipart request.") file = request.files['file'] uploaded_by = request.form.get('uploadedBy') if not uploaded_by: raise ValidationError("Missing 'uploadedBy' form field.") # Extract other optional form data prepared_by = request.form.get('preparedBy') report_title = request.form.get('reportTitle') # ... extract other fields similarly ... # Example for JSON fields (need to parse them) import json service_groups = json.loads(request.form.get('serviceGroups', 'null')) service_types = json.loads(request.form.get('serviceTypes', 'null')) document_types = json.loads(request.form.get('documentTypes', 'null')) document_status = json.loads(request.form.get('documentStatus', 'null')) # Use file.stream for file_data, file.filename, file.content_type result = api_facade.upload_file( location_id=location_id, uploaded_by=uploaded_by, file_data=file.stream, # Pass the file stream directly file_name=file.filename or 'uploaded_file', file_content_type=file.content_type or 'application/octet-stream', prepared_by=prepared_by, report_title=report_title, # Pass other parsed fields service_groups=service_groups, service_types=service_types, document_types=document_types, document_status=document_status # ... ) # Assuming upload returns JSON confirmation in result.data return jsonify(result.data), 200 # Or 201 if appropriate # --- Utility Routes --- @app.route('/utility/service-types', methods=['GET']) def get_service_types_route(): data = api_facade.get_service_types() return jsonify(data), 200 @app.route('/utility/document-types', methods=['GET']) def get_document_types_route(): data = api_facade.get_document_types() return jsonify(data), 200 @app.route('/utility/document-status', methods=['GET']) def get_document_status_route(): data = api_facade.get_document_status() return jsonify(data), 200 if __name__ == '__main__': # Use environment variables for host and port if available host = os.getenv('FLASK_RUN_HOST', '127.0.0.1') port = int(os.getenv('FLASK_RUN_PORT', 5000)) debug = os.getenv('FLASK_DEBUG', 'False').lower() in ('true', '1', 't') app.run(host=host, port=port, debug=debug)