INTERNSHIP REPORT

A report submitted in partial fulfilment of the requirements for the Award of Degree of

BACHELOR OF TECHNOLOGY
In
COMPUTER SCIENCE AND ENGINEERING
by
RAHUL LALWANI
Regd.No : 23671A05E7
Under Supervision of
Mr. M.ANIL
Assistant professor
Department of Computer Science & Engineering

(Duration: 1st August, 2024 - 15 th October, 2024)

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

J.B. INSTITUTE OF ENGINEERING AND TECHNOLOGY
(UGC Autonomous)
Approved by AICTE, Accredited by NBA & NAAC Permanently affiliated to JNTUH, Hyderabad ,
Telangana

2023 – 2027
 DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

J.B. INSTITUTE OF ENGINEERING AND TECHNOLOGY

(UGC Autonomous)

CERTIFICATE

This is to certify that the “Internship report” submitted by RAHUL LALWANI (Regd.
No.:23671A05E7 ) is work done by him and submitted during academic year 2024 – 2025, in partial
fulfilment of the requirements for the award of the degree of BACHELOR OF TECHNOLOGY in
COMPUTER SCIENCE AND ENGINEERING, at Creative Technologies Pvt. Ltd, Hyderabad.

Mr. M. ANIL Dr.G.SRINIVASULU

Assistant professor
Department of Computer Science Head of the Department
& Engineering of Computer Science
and Engineering
 ACKNOWLEDGEMENT

First I would like to thank Mr. M.Anil , Assistant Professor JBIET, Hyderabad for giving me
the opportunity to do an internship within the organization.

I also would like all the people that worked along with me JBIET with their patience and
openness they created an enjoyable working environment.

It is indeed with a great sense of pleasure and immense sense of gratitude that I acknowledge the
help of these individuals.

I would like to thank Mr. M.Anil , internship coordinator, Department of Computer Science
Engineering for his support and advices to get and complete internship in above said organization. I
am extremely great full to my department staff members who helped me in this internship.

I would like to thank my Head of the Department Dr. G.Srinivasulu for his constructive criticism
throughout my internship. I am highly indebted to Principal Dr. P.C. Krishnamachary, for the
facilities provided to accomplish this internship.

RAHUL LALWANI
23671A05E7
 ABSTRACT

This program is a restaurant menu ordering and billing system tailored for a fictional establishment, "Taj Hotel."
Its main purpose is to simplify the food ordering and billing process by offering a structured, user-interactive
experience. The program categorizes the available food items into three main categories: Tiffins, Chinese Food,
and Biryanis, each containing a variety of specific dishes with pre-set prices.
Upon running the program, the user is greeted with a welcome message and presented with a menu displaying
these three categories. The user can then select a category, after which a detailed list of dishes under that category
is shown along with their respective prices. The system allows the user to make a selection, based on which it
generates a bill for the ordered item. The bill amount is then added to an ongoing total that is displayed after each
order, enabling the user to track their expenditure throughout the session.
A key feature of the program is its ability to handle multiple orders. After each selection, the user is asked whether
they would like to order more items. If they choose to continue, they are returned to the main menu to select
another category or item. This cycle continues until the user decides to stop ordering. Once the user indicates that
they are finished, the system displays the final total bill for all the items ordered during the session.
The program not only automates the ordering process but also minimizes the potential for errors in manual billing.
By eliminating the need for manual calculations, it ensures that the correct prices are applied consistently and
accurately. In addition, the program is designed to handle invalid inputs gracefully, guiding users back to the
correct options if an invalid choice is made, thereby enhancing the user experience.
In essence, this restaurant ordering and billing system is a basic yet effective tool for automating the customer
experience in a restaurant. It is highly adaptable and can be expanded or modified to include more categories,
special discounts, or even integration with a point-of-sale (POS) system. This system, while simple, forms the
foundation of restaurant automation, offering an efficient way for restaurants to manage customer orders and
billing in a smooth, organized manner.

ORGANISATION INFORMATION:

This program is designed for a restaurant, "Taj Hotel," to automate the food ordering and
billing process. Below is a breakdown of how the system could be organized and integrated
into the restaurant’s operations:
1. Business Name:
Taj Hotel

2. Objective:
The primary objective of this system is to streamline the ordering and billing processes for the
restaurant, reducing manual effort and enhancing the overall customer experience. The system
provides a digital menu, processes customer orders, and automatically generates the total bill
for multiple orders, making it easy for both the staff and customers to keep track of
transactions.

3. Food Categories Offered:

The program divides the restaurant’s menu into three main categories:
• Tiffins: Traditional breakfast and snack items, typically light meals.
• Chinese Food: Popular Chinese-inspired dishes.
• Biryanis: A variety of rice-based biryani dishes, both vegetarian and non-vegetarian.

4. Menu Structure:
Each category contains multiple items, each priced differently:
• Tiffins: Idli, Dosa, Vada, Puri, Bonda, Upma
• Chinese Food: Veg Noodles, Egg Noodles, Chicken Noodles, Veg Rice, Egg Rice, Chicken
Rice, Veg Manchuria, Chicken Manchuria
• Biryani Varieties: Veg Biryani, Egg Biryani, Chicken Biryani (Single, Full, Family, and
Jumbo Packs)
5. Features:
• Menu Navigation: Customers can browse through different food categories and select
items.
• Bill Calculation: Automatically calculates and updates the total bill as items are added.
• Multiple Orders: The system supports placing multiple orders within the same session,
with an ongoing total provided after each order.
• Error Handling: If a customer makes an invalid input, the program provides feedback
and allows them to retry, ensuring smooth operation.
• Final Bill Display: Once the customer completes their orders, the system shows the final
bill.

6. Operational Benefits:
• Efficiency: Reduces time and errors associated with manual order taking and billing.
• Customer Satisfaction: Enhances the customer experience by providing clear,
transparent billing and the flexibility to place multiple orders.
• Staff Support: Frees up the restaurant staff by automating the process of order-taking
and bill calculation, allowing them to focus on preparing and delivering food.

7. Adaptability:
• Expansion: The system can be easily expanded to include more food categories or items.
• Integration: It can be integrated with the restaurant’s point-of-sale (POS) system or
adapted to work on various platforms (desktop, tablet, or mobile).

8. Usage Scenarios:
• Dine-In: Customers in the restaurant can use the system to order food through a self-
service kiosk or a waiter can operate the system to take orders.
• Takeout/Delivery: The system can be adapted for takeout or delivery services, where
orders are processed, and a bill is generated for the customer to pay upon pickup or
delivery.

9. Scalability:
The program is highly scalable, as it can handle increasing menu options, larger customer
bases, and additional categories like beverages or desserts. Moreover, features like discounting,
membership points, or payment integration can be added in the future.
This organization information showcases how the system improves restaurant operations,
providing a practical, automated solution for handling orders and generating bills accurately
and efficiently.

PROGRAMS AND OPPORTUNITIES:

The restaurant ordering and billing system described in the above program opens up
various programs and opportunities for the restaurant (Taj Hotel) as well as potential
software developers, business owners, and stakeholders in the food and hospitality
industry. Below are some key opportunities that can arise from implementing and
expanding this system:
1. Loyalty Programs for Customers
• Customer Membership & Loyalty Program: The system can be expanded to
include customer membership features, offering rewards points, discounts, or
special offers based on frequent visits or total spending. This helps build customer
retention and loyalty.
o Opportunity: Increased customer engagement and repeat business.
o Implementation: Customers earn points with each order, and the system
tracks their loyalty status, unlocking special discounts or free items after
accumulating a certain amount of points.
• Special Discount Days: The system can be programmed to automatically apply
discounts on specific days (e.g., 10% off on Tuesdays for biryanis), enhancing
customer incentives to visit regularly.
o Opportunity: Attract customers during slow business hours or days.

2. Expansion of Services
• Integration with Online Ordering: The program can be extended to support
online ordering via the restaurant’s website or mobile app. Customers can order
their favorite items online, and the system will generate their bill and notify them
when the order is ready.
o Opportunity: Increase customer base by catering to takeout or delivery
customers.
o Partnership Opportunities: Collaborations with food delivery platforms
such as UberEats, Swiggy, or Zomato.
• Self-Service Kiosks: The program can be adapted into a self-service kiosk system
where customers place orders at digital touchscreens in the restaurant. This
reduces the need for waitstaff and speeds up the ordering process.
o Opportunity: Reduce labor costs while improving service speed and
accuracy.
• Multi-Location Integration: If Taj Hotel expands into multiple locations, the
billing system can be synchronized across branches, providing a unified
experience for all customers and enabling centralized reporting and management.

3. Data Collection and Analytics

• Customer Data & Behavior Tracking: The system can track the preferences and
order history of customers, which allows for the creation of personalized
marketing campaigns.
o Opportunity: Data-driven insights help the restaurant design targeted
promotions, such as offering discounts on frequently ordered items.
o Customer Feedback Loop: After each transaction, customers could be
prompted for feedback via a quick survey, allowing the restaurant to
collect valuable data on customer satisfaction.
• Sales and Inventory Analysis: By integrating the billing system with inventory
management, the restaurant can automatically track which items are selling the
most, monitor inventory levels, and forecast demand for ingredients.
o Opportunity: Optimize stock purchasing, reduce food waste, and adjust the
menu according to popular items.

4. Franchise & Licensing Opportunities

• Franchise Model: Taj Hotel could expand its business model by franchising its
brand and offering a packaged solution that includes this ordering and billing
system. Franchisees would benefit from a ready-to-go software solution for their
operations.
 o Opportunity: Generate additional revenue streams by licensing the
software to franchisees or other restaurants.
• Software as a Service (SaaS): The billing system could be developed into a SaaS
product offered to other restaurants that need a customizable, efficient ordering
system.
o Opportunity: Expand into the restaurant software market by offering this
program to smaller or independent restaurants who need affordable
solutions for managing orders and billing.

5. Integration with Other Technologies

• Mobile Payment Integration: The program can integrate with digital payment
gateways such as Paytm, Google Pay, Apple Pay, or credit card processors.
Customers can complete their orders and pay directly through the system.
o Opportunity: Offer convenience to customers and reduce cash handling.
• QR Code Ordering: Customers could use their smartphones to scan a QR code on
the table or the menu, which takes them to an online ordering system powered by
this program. This contactless service is especially relevant post-pandemic.
o Opportunity: Create a seamless dining experience while reducing human-
to-human contact.
• Artificial Intelligence (AI): An AI-enhanced version of the system could
recommend dishes based on customer history or suggest items that pair well
together.
o Opportunity: Personalize the customer experience and boost sales by
upselling additional items.

6. Restaurant Management Opportunities

• Employee Performance & Time Tracking: The system could be expanded to
include features for tracking employee performance, managing shifts, and
monitoring how efficiently the kitchen operates.
o Opportunity: Improve overall operational efficiency by linking order
processing with staff performance.
• Table Reservation System: Expand the program to include table reservations,
allowing customers to reserve tables online or at the restaurant. The system could
also manage the flow of reservations and walk-in customers.
o Opportunity: Improve restaurant management and customer satisfaction
by reducing wait times.

7. Marketing and Customer Engagement Opportunities

• Targeted Marketing Campaigns: By collecting customer data, Taj Hotel could
run email campaigns, send promotional SMS messages, or create personalized
offers (e.g., birthday discounts) to drive sales.
o Opportunity: Increase customer engagement and enhance customer
relations.
• Social Media Integration: The system could be integrated with social media
platforms, allowing customers to share their experience and food reviews online,
helping the restaurant reach a broader audience.
o Opportunity: Leverage the power of social media to attract new customers
through user-generated content.
8. Environmental and Sustainability Initiatives
• Digital Receipts: Instead of printing paper receipts, the system can send digital
receipts to customers via email or SMS.
o Opportunity: Reduce paper waste and contribute to sustainability
initiatives while offering a modern, eco-friendly option.
• Food Waste Tracking: By integrating inventory management and tracking unsold
items, the system can help Taj Hotel reduce food waste and optimize food
preparation.
o Opportunity: Achieve sustainability goals by minimizing waste and better
managing resources.

METHODOLOGIES:

To develop and enhance the restaurant ordering and billing system for Taj Hotel, a set of
methodologies is essential to ensure efficient system design, development, deployment, and
maintenance. The following outlines a combination of software development methodologies, user
experience (UX) design, and quality assurance strategies that can be applied to this program.

1. Agile Software Development Methodology

The Agile methodology is highly suitable for this project, allowing for iterative development,
continuous feedback, and flexibility in handling changes.
• Key Features:
o Iterative Development: The project can be divided into small, manageable
iterations (sprints). Each iteration would focus on developing core features such
as menu creation, order processing, and bill generation, followed by
enhancements like loyalty programs, data analytics, or multi-location integration.
o Customer Feedback: Regular interaction with restaurant staff and customers can
provide real-time feedback, allowing the system to evolve based on user needs.
o Quick Updates: Small, frequent updates ensure that the system is always in a
usable state while introducing new features.
• Benefits:
o Continuous improvement based on real-world feedback.
o Flexibility to adapt to evolving business needs, such as adding features for
delivery, online ordering, or self-service kiosks.

2. Waterfall Methodology (For Initial Build)

While Agile is great for iterative improvements, the initial build of the system may benefit
from a Waterfall approach, especially if the requirements are well defined at the outset. This
traditional approach could be suitable for the first version of the program where the focus is
on building a solid foundation before enhancements.
 • Phases:
o Requirement Analysis: Understanding the exact requirements of the restaurant,
including categories of food, billing features, and user interaction.
o System Design: Laying out the system architecture, user interface design, and
menu structure.
o Implementation: Coding the program based on the predefined requirements.
o Testing: Conducting end-to-end testing to ensure the system functions as
expected.
o Deployment: Launching the program for use in the restaurant.
• Benefits:
o A clear roadmap from start to finish.
o Well-suited for a project with stable and well-defined requirements, especially for
the core system.

3. User-Centered Design (UCD) Methodology

For a successful ordering and billing system, User-Centered Design is crucial. This
methodology focuses on designing the system around the needs, preferences, and behaviors of
the users—both customers and restaurant staff.
• Phases:
o User Research: Understanding the daily operations of the restaurant, the
interaction patterns of customers, and the workflow of the waitstaff. This could
involve surveys, interviews, and observing restaurant activities.
o Personas Creation: Creating personas representing different user groups
(customers, waiters, kitchen staff) to ensure the system is designed to cater to all.
o Prototyping: Developing wireframes and prototypes of the menu and billing
system, including easy-to-navigate interfaces for both staff and customers.
o Usability Testing: Testing the system with real users to identify any usability
issues, ensuring that the system is intuitive, easy to use, and efficient.
• Benefits:
o Ensures the system is highly intuitive and user-friendly.
o Minimizes user error and training time by designing interfaces based on real user
behaviors.

4. Modular Design and Development

To ensure that the system can be easily expanded and maintained, a modular design approach
is essential.
• Key Principles:
o Separation of Concerns: Breaking the program into independent modules, such
as order processing, billing, and user management. Each module should handle
its specific functionality and interact with other modules through clearly defined
interfaces.
o Reusability: By creating modular components, the program can be scaled or
 modified without affecting the entire system. For example, the billing module
could be reused if the system expands to include an online ordering platform.
o Scalability: As the restaurant grows, new features such as loyalty programs,
multi-location support, or online ordering can be added by plugging in new
modules without disrupting existing functionality.
• Benefits:
o Easier to maintain, test, and scale the system.
o Reduces development time when adding new features in the future.

5. Test-Driven Development (TDD)

To ensure a high-quality and bug-free system, Test-Driven Development (TDD) should be
incorporated. TDD emphasizes writing tests before the actual code is developed, ensuring that
the system behaves as expected from the outset.
• Process:
o Write Tests First: For each feature (e.g., placing an order, generating a bill),
developers write tests specifying the expected behavior.
o Develop Feature: Code is written to pass the tests. The tests act as the acceptance
criteria for each feature.
o Refactor and Improve: After passing the tests, the code is refactored for
optimization while ensuring that the tests still pass.
• Benefits:
o Ensures a robust, reliable system with minimal bugs.
o Increases confidence in the codebase, making it easier to add new features
without introducing errors.
o Automated testing can be set up for continuous integration, ensuring the system
remains reliable over time.

6. Database Design and Management

A well-structured database is critical to the efficient functioning of the program, especially as
the restaurant expands and handles more orders, customers, and inventory.
• Methodology:
o Relational Database Design: Use a relational database (e.g., MySQL,
PostgreSQL) to store and manage orders, menu items, billing data, customer
information, and inventory.
o Normalization: The database should be normalized to reduce redundancy and
ensure consistency in data storage.
o Scalability: Ensure the database can scale as the number of orders, menu items,
and customers grows over time.
• Benefits:
o Allows for efficient data retrieval, updates, and reporting.
o Ensures data integrity and reduces the risk of data anomalies.
 7. Quality Assurance (QA) and Testing Methodologies
Quality assurance is a key aspect of the development process to ensure the system functions as
expected and is free from bugs.
• Testing Types:
o Unit Testing: Testing individual components (e.g., billing logic, menu selection) to
ensure each part works in isolation.
o Integration Testing: Testing how different modules of the system (e.g., ordering
and billing) work together.
o User Acceptance Testing (UAT): Allowing real restaurant staff to test the system
in a live environment to ensure it meets their operational needs and expectations.
o Stress Testing: Ensuring the system can handle peak loads, such as high order
volumes during busy restaurant hours.
• Benefits:
o Minimizes bugs and errors in the live system.
o Ensures the system is robust and scalable for future expansion.

8. Continuous Deployment and Maintenance

After the system is deployed, continuous monitoring and maintenance are crucial to ensure it
continues to function optimally.
• DevOps Methodology:
o Continuous Integration/Continuous Deployment (CI/CD): Automate the
deployment process so that any updates or patches are seamlessly integrated into
the live system without disrupting operations.
o Regular Updates: Schedule regular updates to add new features or fix bugs based
on user feedback and evolving business needs.
o Monitoring and Logging: Implement logging and monitoring to detect issues in
real time and respond quickly to system failures or bugs.
• Benefits:
o Ensures that the system remains secure, functional, and up-to-date.
o Reduces downtime and improves user experience by automating the deployment
of new features and bug fixes.

KEY PARTS OF THE REPROT:

When preparing a report for the restaurant menu ordering and billing system based on the code
provided, the following sections should be included. Each section covers different aspects of the
project, from the introduction to technical details and future recommendations.

1. Title of the Report

• "Restaurant Menu Ordering and Billing System for Taj Hotel"
2. Abstract
A brief summary of the project, its purpose, and functionality.
Example: This report outlines the development of a restaurant menu ordering and billing system
designed to streamline the food ordering process and manage customer bills efficiently. The system
allows customers to select from multiple categories, including tiffins, Chinese food, and biryanis, and
generates a corresponding bill. It simplifies the billing process while offering an intuitive interface for
staff and customers.

3. Introduction
This section introduces the purpose of the project, its objectives, and why it was developed.
Example: The goal of the system is to automate the food ordering and billing process for Taj Hotel,
enhancing the efficiency of order processing and improving the overall customer experience. By
allowing customers to select from predefined food categories and generating an accurate bill, the
system reduces manual errors, improves service speed, and ensures a smooth workflow for restaurant
operations.

4. System Requirements
This section lists the hardware and software requirements needed to run the program.
• Hardware Requirements:
o Basic computing device (PC or tablet)
o Internet connection (if extended to online ordering)
• Software Requirements:
o Python (version 3.x)
o Integrated Development Environment (IDE) for Python, e.g., PyCharm, VS Code
o Optional: Web server for online or mobile integration

5. System Design
This section explains how the system is structured, including the architecture, modules, and
components.
Example: The system is designed as a simple console-based application that allows users to interact
with the menu. It consists of three main categories: Tiffins, Chinese Food, and Biryanis, each with
its own list of menu items and prices. The system provides prompts for user input, calculates the total
bill based on the selection, and allows users to place multiple orders before finalizing the total bill.
Key modules include:
• Main Menu Module: Displays the food categories.
• Billing Module: Handles the selection of food items and calculates the total bill.
• User Input Module: Collects inputs from the user (customers and staff).

6. Flowchart or System Workflow

Provide a flowchart or explanation of the system workflow to show how users interact with the
program.
Steps:
1. Display the main menu (categories: Tiffins, Chinese, Biryanis).
2. User selects a category.
3. Display list of food items and prices under the chosen category.
4. User selects the desired food item.
5. Bill is updated based on the user's choice.
6. User is prompted whether they want to order more.
7. If "yes," the process repeats. If "no," the final bill is displayed.

7. Code Implementation
This section includes a detailed explanation of the code. Break it down into key functions and logic,
explaining their roles and how they contribute to the overall system.
• Main Menu Function: Displays food categories and prompts the user to select one.
• Billing Function: Takes the selected food item, calculates the price, and updates the total bill.
• Loop for Additional Orders: Keeps the program running until the user confirms they are
done ordering.
8. Testing and Validation
Detail how the program was tested to ensure it works as expected.
• Unit Testing: Each function (e.g., displaying menu items, calculating bills) was tested
separately to ensure it performs the intended tasks.
• System Testing: The entire program was run to simulate a real customer interaction with
multiple orders.

9. Challenges and Limitations

Discuss any challenges faced during development and the limitations of the current system.
Example: Challenges included handling invalid inputs gracefully and ensuring accurate billing with
multiple orders. One limitation is that the system currently only supports console-based interaction
and does not offer online ordering or mobile app integration.

10. Recommendations for Future Development

Suggest improvements or expansions to the system, such as integrating online ordering, loyalty
programs, or payment gateways.
Example: Future iterations of this system could include:
• A graphical user interface (GUI) for easier use.
• Integration with online ordering platforms and delivery services.
• Adding support for multiple payment options, including digital payments and mobile wallets.
• A loyalty program to encourage customer retention.

11. Conclusion
Summarize the results of the project and its benefits for Taj Hotel.
Example: The restaurant menu ordering and billing system has successfully streamlined the ordering
process for Taj Hotel, reducing manual errors, and improving the speed and accuracy of bill
generation. The system offers an efficient and user-friendly solution for both customers and staff,
contributing to better customer service and operational efficiency.

12. Appendices
If necessary, include any supplementary information such as screenshots, sample output, or additional
documentation.
 INTERNSHIP OBJECTIVES
The primary focus of this internship is to develop, enhance, and optimize a restaurant menu ordering
and billing system for Taj Hotel. This project aims to introduce a software solution that simplifies the
ordering process, ensures accurate bill calculation, and improves operational efficiency in a restaurant
setting. Throughout the internship, the intern will work on various stages of software development,
gaining hands-on experience in coding, system design, testing, and deployment.
Key Objectives:
1. Understanding Software Development Life Cycle (SDLC):
o The intern will gain an in-depth understanding of the different phases of software
development, from requirements gathering and system design to coding, testing, and
deployment.
o The intern will learn to structure a program using modular code, ensuring that different
sections of the software are easy to manage, test, and scale.
2. Hands-On Coding Experience:
o The intern will be responsible for coding a menu-driven restaurant ordering system
that includes the creation of categories (e.g., Tiffins, Chinese Food, Biryani) and
calculating the bill based on customer selections.
o The intern will gain proficiency in Python programming, including the use of
functions, loops, conditionals, and user input handling.
3. User Experience Design (UX):
o The intern will learn how to design a user-friendly console-based interface for
restaurant staff and customers, ensuring that the system is intuitive and easy to
navigate.
o Focus will be placed on minimizing user error through clear prompts, validation of
user inputs, and feedback mechanisms.
4. Problem-Solving and Debugging:
o A key objective is to enhance the intern's problem-solving skills by addressing
potential issues such as invalid user inputs, edge cases in ordering, and handling
multiple orders efficiently.
o The intern will develop skills in debugging and error handling to ensure the system
operates smoothly in a live environment.
5. Testing and Quality Assurance:
o The intern will learn the importance of testing software to ensure it meets functional
requirements. This will include unit testing of individual features and system testing
for the overall program.
o The intern will work on creating and running test cases to validate the accuracy of the
billing system and ensure that it performs correctly under various conditions (e.g.,
multiple orders, incorrect inputs).
6. Collaborative and Independent Work:
o The intern will collaborate with a mentor or project supervisor to understand project
goals and receive feedback on their work.
o Additionally, the intern will develop independent problem-solving skills, taking
ownership of coding tasks and implementing solutions.
7. Project Documentation:
o The intern will be responsible for documenting the code, including explaining the
functions, workflow, and logic behind each part of the system.
o The intern will create a final report summarizing the project, its development process,
challenges, solutions, and future recommendations for expansion.
8. Exposure to Real-World Applications:
o This project provides a practical, real-world application of software development for
the food and hospitality industry, giving the intern exposure to how such systems
improve efficiency in businesses.
o By the end of the internship, the intern will have experience developing a functional
software system that directly impacts restaurant operations, customer satisfaction, and
service speed.
 WEEKLY REPORT OF INTERNSHIP ACTIVITIES

Intern Name: DASARI ABHILASH

Internship Period: 1st August,2024 to 15th October,2024.
Week Ending: 15th October
Supervisor: Mr.M.Anil
Organization: Taj Hotel

Week 1: Introduction and Requirements Gathering

Objectives:
• Familiarize with the organization and its operations.
• Understand the requirements for the restaurant menu ordering and billing system.
Activities:
• Attended orientation sessions to learn about Taj Hotel’s services and operational workflows.
• Met with the project supervisor to discuss the goals and scope of the software project.
• Conducted interviews with restaurant staff to gather insights on current ordering and billing
processes, identifying pain points and areas for improvement.
• Documented requirements for the system, including key features, user interactions, and
expected outcomes.
Deliverables:
• Requirement analysis document outlining features needed in the ordering system.

Week 2: System Design and Prototyping

Objectives:
• Design the structure of the program.
• Create a prototype of the user interface.
Activities:
• Created flowcharts to visualize the workflow of the ordering and billing system.
• Designed a console-based interface layout, including menus for food categories and prompts
for user inputs.
• Developed a modular design approach, outlining the main functions: displaying menus,
processing orders, calculating bills, and handling user input.
• Reviewed the design with the supervisor and received feedback for improvement.
Deliverables:
• Flowcharts illustrating the system workflow.
• Prototype of the console interface design.

Week 3: Coding the Main Menu and Order Processing

Objectives:
• Begin coding the core features of the system.
Activities:
• Implemented the main menu function to display food categories: Tiffins, Chinese Food, and
Biryani.
• Developed the order processing logic, allowing users to select items from the chosen category
and calculate the respective bill.
• Focused on writing clean, modular code to ensure ease of maintenance and future updates.
Challenges:
• Encountered difficulties with validating user inputs and handling unexpected responses.
Resolved by implementing error handling.
Deliverables:
• Code for the main menu and order processing functions.
Week 4: Bill Calculation and Enhancements
Objectives:
• Finalize the bill calculation logic and enhance user experience.
Activities:
• Completed the billing module, ensuring it accurately calculates the total bill based on user
selections.
• Added features for handling multiple orders, allowing users to continue ordering until they
choose to finalize the bill.
• Implemented user feedback mechanisms to confirm orders and display current total bills.
Challenges:
• Dealt with edge cases where users could select invalid items or categories. Developed error
messages to guide users in making valid choices.
Deliverables:
• Complete code for the billing module, including error handling.

Week 5: Testing and Quality Assurance

Objectives:
• Ensure the system functions as intended through rigorous testing.
Activities:
• Conducted unit testing on individual components (e.g., order processing, billing calculation).
• Performed integration testing to verify that different modules interact correctly.
• Created test cases based on potential user scenarios to identify and fix bugs.
Deliverables:
• Testing report documenting results, issues identified, and fixes implemented.
• Updated codebase reflecting changes made during testing.

Week 6: Finalizing the Project and Documentation

Objectives:
• Prepare the project for submission and create documentation.
Activities:
• Refined the code based on testing feedback, ensuring all functionalities work seamlessly.
• Developed comprehensive documentation, including user guides, code comments, and system
architecture descriptions.
• Created a final report summarizing the entire project, including objectives, design,
implementation, testing, challenges faced, and recommendations for future enhancements.
Deliverables:
• Finalized code for the ordering and billing system.
• Complete documentation and project report.
 1.INTRODUCTION

In the competitive landscape of the restaurant industry, delivering exceptional service

while maintaining operational efficiency is crucial for success. The "Restaurant Menu
Ordering and Billing System" developed for Taj Hotel aims to address these challenges
by providing a streamlined solution for food ordering and bill calculations. This system
is designed to enhance the customer experience by automating the ordering process,
thus minimizing wait times and reducing the potential for human error.
The core functionality of the system revolves around offering a user-friendly interface
where customers can easily select items from various food categories, including
Tiffins, Chinese Food, and Biryanis. Each category presents a clear list of menu items
along with their respective prices, allowing users to make informed choices. Once an
order is placed, the system calculates the total bill dynamically, providing immediate
feedback to the customer and ensuring transparency in pricing.
Developed using Python, a widely-used programming language known for its clarity
and efficiency, the system is structured in a modular fashion. This design approach not
only enhances code readability but also facilitates easier maintenance and scalability.
Each component of the system—such as menu display, order processing, and bill
calculation—is encapsulated in distinct functions, allowing for straightforward updates
and expansions in the future. For instance, additional food categories or payment
processing features can be integrated seamlessly without overhauling the entire system.
A key aspect of the system is its emphasis on user experience. The console-based
application is designed to be intuitive, guiding users through the ordering process with
clear prompts and options. Input validation mechanisms are implemented to ensure that
users can only select valid items, further enhancing the robustness and reliability of the
application. This focus on user-centric design helps in reducing errors during the
ordering process and improves the overall satisfaction of customers.
In addition to technical skills in programming and software development, this project
emphasizes the importance of understanding restaurant operations and customer
service dynamics. By collaborating with restaurant staff to gather insights into their
workflows and pain points, the system is tailored to meet the specific needs of Taj
Hotel. This ensures that the developed solution not only addresses technical
requirements but also aligns with the operational goals of the restaurant.
Ultimately, the "Restaurant Menu Ordering and Billing System" serves as a
foundational tool that can significantly improve service delivery and customer
satisfaction at Taj Hotel. By harnessing technology to streamline processes, the system
exemplifies how modern solutions can enhance hospitality services. As the restaurant
continues to evolve, this system provides a solid framework for future enhancements,
ensuring that Taj Hotel remains competitive in a rapidly changing industry.
4o mini
 1. SYSTEM ANALYSIS

1. Overview
The "Restaurant Menu Ordering and Billing System" is designed to facilitate the
ordering process at Taj Hotel. The system automates menu selection, order processing,
and billing, significantly improving operational efficiency and customer satisfaction. A
thorough analysis of the system involves evaluating its components, functionality,
performance requirements, and user interactions.

2. Functional Requirements
The system is built around several key functional requirements:
• Menu Management: The system should allow users to view a list of food
categories and items. Each category will have a predefined list of menu items
along with their corresponding prices.
• Order Processing: Users must be able to select items from the menu. The
system should accept multiple orders and calculate the total bill dynamically.
• Billing System: Upon completion of the order, the system should generate a
clear and accurate bill for the customer, detailing each item ordered and the total
amount due.
• User Input Validation: The system must validate user inputs to prevent
selection of invalid items or categories, ensuring a smooth ordering experience.

3. Non-Functional Requirements
In addition to functional requirements, the system has several non-functional
requirements:
• Performance: The system should respond quickly to user inputs, displaying
menu options and calculating bills in real time to minimize customer wait times.
• Usability: The console-based interface should be intuitive and user-friendly,
allowing users of varying technical abilities to navigate the system easily.
• Scalability: The system should be designed to accommodate future
enhancements, such as adding new food categories, integrating online ordering,
or implementing loyalty programs.
• Reliability: The application should function consistently without crashes or
errors, ensuring that users can complete their orders without interruptions.

4. System Components
The system consists of several key components:
• Main Menu Module: Displays available food categories and prompts the user to
make a selection.
• Order Processing Module: Handles the selection of menu items, calculates the
bill, and updates the total based on user choices.
• Billing Module: Generates a detailed bill for the customer, summarizing their
order and total amount due.
• Input Validation Module: Ensures that user inputs are valid and provides
feedback in cases of errors or invalid selections.
5. User Interaction
The interaction model for the system is based on a console interface, where users
engage through text prompts. The flow of interaction is as follows:
1. Display Main Menu: Users are presented with the main menu, listing the
available food categories.
2. Select Category: Users choose a category to view specific menu items.
3. Place Order: Users select items from the chosen category. The system confirms
their selection and updates the bill.
4. Continue Ordering: Users can choose to continue ordering or finalize their bill.
5. Generate Bill: Upon completion of the order, the system displays a detailed bill,
and users are thanked for their order.

6. System Limitations
While the system provides significant improvements over manual ordering processes,
there are some limitations:
• Console-Based Interface: The current system does not utilize a graphical user
interface (GUI), which may limit usability for some users who prefer visual
interfaces.
• Single-User Operation: The system is designed for single-user interaction at a
time, which may not accommodate busy restaurant environments effectively.
• Limited Payment Options: The current version does not include payment
processing capabilities, requiring further development to integrate various
payment methods.

7. Conclusion
The system analysis for the "Restaurant Menu Ordering and Billing System" highlights
the essential functionalities and performance requirements necessary for enhancing the
food ordering process at Taj Hotel. By automating menu selection, order processing,
and billing, the system aims to provide an efficient and satisfying customer experience
while laying the groundwork for future enhancements and scalability in restaurant
operations. This analysis serves as a foundation for the design and implementation
phases, ensuring that all necessary requirements are addressed to meet user
expectations effectively.
4o mini
 3. SOFTWARE REQUIREMENTS SPECIFICATIONS

1. Introduction
This Software Requirements Specification (SRS) document outlines the functional and
non-functional requirements for the "Restaurant Menu Ordering and Billing System"
developed for Taj Hotel. This system automates the food ordering process and billing,
enhancing operational efficiency and customer satisfaction.

2. Purpose
The purpose of this SRS is to provide a clear and comprehensive understanding of the
system's functionalities and requirements. This document serves as a guide for the
development, testing, and implementation of the system.

3. Scope
The system will provide functionalities for menu management, order processing,
billing, and user input validation. It is designed for use by restaurant staff and
customers, enabling a streamlined ordering experience.

4. Overall Description
The system will be a standalone console-based application that can be run on any
device with Python installed. The primary user classes are customers, who are
individuals ordering food and require a user-friendly interface with quick access to
menu items, and restaurant staff, who assist customers and need to understand the
system to help customers efficiently.

5. Functional Requirements
The system has several key functional requirements:
1. The system shall display a main menu with food categories.
2. The system shall allow customers to select a category.
3. The system shall display menu items and prices for the selected category.
4. The system shall allow customers to place an order by selecting menu items.
5. The system shall calculate the total bill based on selected items.
6. The system shall prompt users to confirm if they want to order more items.
7. The system shall generate a final bill with itemized details.
8. The system shall validate user inputs to ensure valid selections.
9. The system shall provide error messages for invalid inputs.

6. Non-Functional Requirements
In addition to functional requirements, the system includes several non-functional
requirements:
1. The system shall respond to user inputs within 2 seconds.
2. The user interface shall be intuitive and easy to navigate.
3. The system shall handle a minimum of 100 simultaneous orders without
performance degradation.
4. The system shall be maintainable, allowing for updates to menu items and
categories without code modification.
5. The system shall run on any device with Python version 3.x installed.
7. System Requirements
Hardware Requirements:
• A computer or device with a minimum of 2GB RAM.
• 100MB of free disk space.
• Keyboard and display for user interaction.
Software Requirements:
• Operating System: Windows, macOS, or Linux.
• Python 3.x installed on the device.
• An Integrated Development Environment (IDE) or text editor (e.g., PyCharm,
VS Code) for code execution.

8. User Interface Requirements

The system will operate through a command-line interface (CLI). The main menu will
present numbered options for easy selection, and the interface will provide clear
prompts and feedback messages to guide users through the ordering process.

9. Performance Requirements
The system shall maintain a response time of less than 2 seconds for menu displays and
bill calculations. It shall support a minimum of 100 simultaneous users, should the
system be expanded to a multi-user environment in the future.

10. Security Requirements

The system will not store sensitive user data, as it operates in a local environment.
Input validation will prevent injection attacks or erroneous input.

11. Limitations
The current version is limited to console-based interactions and does not include a
graphical user interface (GUI). Additionally, the system does not integrate payment
processing features, which may require future enhancements.

12. Conclusion
This Software Requirements Specification outlines the essential functionalities and
characteristics of the "Restaurant Menu Ordering and Billing System" for Taj Hotel.
By adhering to these specifications, the development team can create a system that
effectively meets user needs while improving the efficiency of restaurant operations.
This document will serve as a foundation for the design, development, and testing
phases of the project, ensuring that all requirements are clearly defined and understood.
 4. TECHNOLOGIES

The "Restaurant Menu Ordering and Billing System" leverages a variety of

technologies to ensure efficient functionality, ease of use, and maintainability. Below is
an overview of the primary technologies used in the development of the system:

1. Programming Language
• Python: The system is developed using Python, a high-level programming
language known for its simplicity and readability. Python's extensive standard
library and support for various programming paradigms make it an ideal choice
for rapid application development. Its robust error handling, built-in data
structures, and ease of integration with other technologies contribute to an
efficient coding process.

2. Development Environment
• Integrated Development Environment (IDE): The development of the system
can be performed using various IDEs such as PyCharm, Visual Studio Code, or
even simple text editors like Sublime Text or Notepad++. These tools provide
syntax highlighting, debugging capabilities, and code management features that
enhance productivity.

3. Version Control
• Git: Git is used for version control, allowing the development team to track
changes in the codebase, collaborate effectively, and manage different versions
of the application. Platforms like GitHub or GitLab can be utilized to host the
repository, facilitating code sharing and collaboration among developers.

4. Testing Frameworks
• Unit Testing Framework: Although the system is primarily a console-based
application, unit testing frameworks such as unittest or pytest can be used to
validate the functionality of individual components. These frameworks help
ensure that the system behaves as expected and aids in identifying and fixing
bugs during development.

5. User Interface
• Command-Line Interface (CLI): The system uses a console-based interface for
user interactions. The CLI allows for straightforward input and output
operations, making it suitable for a restaurant environment where speed and
efficiency are crucial. The interface is designed to provide clear prompts and
feedback, enhancing user experience.
6. Data Management
• In-Memory Data Structures: The system uses Python's built-in data structures
(such as lists and dictionaries) to manage menu items and orders in memory.
This approach allows for quick access and manipulation of data without the need
for complex database management systems, suitable for the application's scope.

7. Error Handling
• Exception Handling: Python's built-in exception handling mechanisms are
utilized to manage errors gracefully. This includes validating user inputs and
providing informative error messages to guide users in making correct
selections, thus improving overall system reliability.
 5. CODING

Below is the complete code for the "Restaurant Menu Ordering and Billing System."
This code is structured to provide a user-friendly console interface for customers to
select food items from different categories, place orders, and receive a total bill.

TITLE: RESTAURANT MENU ORDERING AND BILLING SYSTEM

# Welcome message
Print ("--------------------WELCOME TO THE TAJ HOTEL ------------------- ")

# Function to display the main menu

def show_ menu ():
print ("*MAIN MENU*")
print ("List of categories\n1 for TIFFINS\n2 for CHINESE FOOD\n3 for
BIRYANIES")

# Function to calculate the bill based on the selected category

def get_ bill(category):
bill = 0
if category == 1: # Tiffins category
print ("You have chosen the tiffins category")
print ("List of tiffins:\n1 for Idli-----₹30\n2 for Dosa-----₹40\n3 for Vada-----
₹30\n4 for Puri-----₹30\n5 for Bonda-----₹30\n6 for Upma ----- ₹20")
tiffin = int (input ("Enter the desired tiffin: "))
if tiffin == 1:
bill = 30
print ("You have ordered Idli")
elif tiffin == 2:
bill = 40
print ("You have ordered Dosa")
elif tiffin == 3:
bill = 30
print ("You have ordered Vada")
elif tiffin == 4:
bill = 30
print ("You have ordered Puri")
elif tiffin == 5:
bill = 30
print ("You have ordered Bonda")
elif tiffin == 6:
bill = 20
print ("You have ordered Upma")
else:
print ("Invalid choice")
bill = 0
 elif category == 2: # Chinese Food category
print ("You have chosen the Chinese food category")
print ("List of Chinese food\n1 for Veg Noodles-----₹80\n2 for Egg Noodles-----
₹90\n3 for Chicken Noodles-----₹100\n4 for Veg Rice-----₹60\n5 for Egg Rice-----
₹70\n6 for Chicken Rice-----₹80\n7 for Veg Manchuria-----₹80\n8 for Chicken
Manchuria ---- ₹120")
Chinese = int (input ("Enter your wanted Chinese: "))
if Chinese == 1:
bill = 80
print ("You have ordered Veg Noodles")
elif Chinese== 2:
bill = 90
print ("You have ordered Egg Noodles")
elif Chinese== 3:
bill = 100
print ("You have ordered Chicken Noodles")
elif chinese== 4:
bill = 60
print ("You have ordered Veg Rice")
elif chinese== 5:
bill = 70
print("You have ordered Egg Rice")
elif chinese== 6:
bill = 80
print("You have ordered Chicken Rice")
elif chinese== 7:
bill = 80
print("You have ordered Veg Manchuria")
elif chinese == 8:
bill = 120
print("You have ordered Chicken Manchuria")
else:
print("Invalid choice")
bill = 0

elif category == 3: # Biryanies category

print("You have chosen the BIRYANIES CATEGORY")
print("List of BIRYANIES\n1 for SINGLE VEG BIRYANI-----₹100\n2 for
SINGLE EGG BIRYANI-----₹120\n3 for SINGLE CHICKEN BIRYANI ---- ₹140\n4
for FULL CHICKEN BIRYANI-----₹250\n5 for FAMILY PACK (CHICKEN
BIRYANI)-----₹500\n6 for JUMBO PACK (CHICKEN BIRYANI) ---- ₹750")
biryani = int(input("Enter the desired BIRYANI: "))
if biryani == 1:
bill = 100
print("You have ordered SINGLE VEG BIRYANI")
elif biryani == 2:
bill = 120
 print("You have ordered SINGLE EGG BIRYANI")
elif biryani == 3:
bill = 140
print("You have ordered SINGLE CHICKEN BIRYANI")
elif biryani == 4:
bill = 250
print("You have ordered FULL CHICKEN BIRYANI")
elif biryani == 5:
bill = 500
print("You have ordered FAMILY PACK (CHICKEN BIRYANI)")
elif biryani == 6:
bill = 750
print("You have ordered JUMBO PACK (CHICKEN BIRYANI)")
else:
print("Invalid choice")
bill = 0

else:
print("Invalid category")
bill = 0

return bill # Return the calculated bill

# Main loop for ordering

total_bill = 0
more_orders = True

while more_orders:
show_menu() # Display the main menu
category = int(input("Enter your category: ")) # User selects category
bill = get_bill(category) # Get the bill for the selected category
if bill > 0:
total_bill += bill # Add to total bill
print(f"Your current total bill is {total_bill}") # Display current total bill
more_orders = input("Would you like to order more? (yes/no): ").strip().lower()
== 'yes' # Check if the user wants to order more

# Final bill display

Print (f" Your final bill is {total_ bill}")
print ("THANK YOU \n HAVE A NICE DAY")
 6. SCREENSHOTS

SAMPLE OUTPUT-1:

-------------------WELCOME TO THE TAJ HOTEL--------------------

*MAIN MENU*
List of categories
1 for TIFFINS
2 for CHINESE FOOD
3 for BIRYANIES

Enter your category: 1

You have chosen the tiffins category
List of tiffins:
1 for Idli---- ₹30
2 for Dosa---- ₹40
3 for Vada ----₹30
4 for Puri ---- ₹30
5 for Bonda ---- ₹30
6 for Upma -----₹20
Enter the desired tiffin: 4
You have ordered Puri
Your current total bill is 30

Would you like to order more? (yes/no): yes

*MAIN MENU*
List of categories
1 for TIFFINS
2 for CHINESE FOOD
3 for BIRYANIES

Enter your category: 2

You have chosen the Chinese food category
List of Chinese food
1 for Veg Noodles ---- ₹80
2 for Egg Noodles ---- ₹90
3 for Chicken Noodles ---- ₹100
4 for Veg Rice---- ₹60
5 for Egg Rice ---- ₹70
6 for Chicken Rice---- ₹80
7 for Veg Manchuria ---- ₹80
8 for Chicken Manchuria ---- ₹120
Enter your wanted Chinese: 3
You have ordered Chicken Noodles
Your current total bill is 130
Would you like to order more? (yes/no): yes

*MAIN MENU*
List of categories
1 for TIFFINS
2 for CHINESE FOOD
3 for BIRYANIES
Enter your category: 3
You have chosen the BIRYANIES CATEGORY
List of BIRYANIES
1 for SINGLE VEG BIRYANI ---- ₹100
2 for SINGLE EGG BIRYANI----- 120
3 for SINGLE CHICKEN BIRYANI ---- ₹140
4 for FULL CHICKEN BIRYANI ---- ₹250
5 for FAMILY PACK (CHICKEN BIRYANI) ---- ₹500
6 for JUMBO PACK (CHICKEN BIRYANI) ----- ₹750
Enter the desired BIRYANI: 3
You have ordered SINGLE CHICKEN BIRYANI
Your current total bill is 270
Would you like to order more? (yes/no): no
Your final bill is 270

THANK YOU
HAVE A NICE DAY

SAMPLE OUTPUT-2:
-------------------WELCOME TO THE TAJ HOTEL--------------------
*MAIN MENU*
List of categories
1 for TIFFINS
2 for CHINESE FOOD
3 for BIRYANIES
Enter your category: 3
You have chosen the BIRYANIES CATEGORY
List of BIRYANIES
1 for SINGLE VEG BIRYANI ---- ₹100
2 for SINGLE EGG BIRYANI ---- ₹120
3 for SINGLE CHICKEN BIRYANI ---- ₹140
4 for FULL CHICKEN BIRYANI ---- ₹250
5 for FAMILY PACK (CHICKEN BIRYANI) ----- ₹500
6 for JUMBO PACK (CHICKEN BIRYANI) ----- ₹750
Enter the desired BIRYANI: 4
You have ordered FULL CHICKEN BIRYANI
Your current total bill is 250
Would you like to order more? (yes/no): no
Your final bill is 250
THANK YOU
HAVE A NICE DAY
 7. CONCLUSION

The Restaurant Menu Ordering and Billing System is an essential software tool
designed to simplify and automate the process of food ordering and bill generation in a
restaurant environment. This system efficiently handles multiple categories of food
such as Tiffins, Chinese Food, and Biryanis, giving users a straightforward menu to
navigate and make their selections. It calculates the total bill based on customer choices
and allows the option to place additional orders, providing flexibility throughout the
process.
One of the key strengths of this system is its modular structure, where various tasks
such as menu display, item selection, and bill calculation are handled by separate
functions. This design improves the readability and maintainability of the code, making
it easier to update and enhance as needed. The use of loops ensures that users can order
as many items as they wish without restarting the program, while conditional
statements guide users through the various menu options, providing feedback for each
selection.
Another benefit of this system is its simplicity. The console-based approach offers a
basic yet functional interface for interacting with users, making it ideal for smaller
restaurants or food stalls. Though currently text-based, the system could easily be
expanded with more advanced features such as graphical user interfaces (GUIs), error
handling for invalid inputs, and integration with a database to manage a larger scale of
orders.
The system also lays the groundwork for future improvements. Adding options like
modifying or canceling orders, introducing discounts or promotions, or tracking
customer data for loyalty programs would make it more versatile. Additionally,
incorporating features like splitting bills between multiple customers or supporting
different payment methods could elevate its real-world applicability.
In conclusion, this project demonstrates the core principles of software development in
a practical application. It effectively meets the basic requirements of a restaurant
ordering and billing system, offering a clear, structured solution that can be enhanced
over time to meet more complex needs.
4o
 8. BIBLOGRAPHY
Python Documentation - The official Python documentation provides
comprehensive information about Python's syntax, built-in functions, and
libraries used in this project.
• Python Software Foundation. (2024). Python 3 Documentation. Available at:
https://docs.python.org/3/
W3Schools - Python Functions and Input - W3Schools offers tutorials on basic
programming concepts, such as how to use functions, input/output, and loops,
which were essential in structuring this program.
• W3Schools. (2024). Python Functions Tutorial. Available at:
https://www.w3schools.com/python/

Real Python - Building a Command-Line Interface - This article helped in

understanding how to design user-friendly, text-based menu systems in Python.
• Real Python. (2024). How to Build Command-Line Interfaces in Python.
Available at: https://realpython.com/

Stack Overflow - A community-based platform where questions related to

handling user input and calculating bills in Python were referenced to help
resolve challenges during development.
• Stack Overflow. Available at: https://stackoverflow.com/

GeeksforGeeks - Python Menu-Driven Programs - This website provides

detailed guides on how to implement menu-driven programs in Python, which
inspired the structure of the code.
• GeeksforGeeks. (2024). Menu-Driven Programs in Python. Available at:
https://www.geeksforgeeks.org/

TutorialsPoint - Python Loops and Conditionals - TutorialsPoint offers step-

by-step tutorials on how to implement loops and conditional statements in Python,
both of which were used extensively in this project.
• TutorialsPoint. (2024). Python Loops and Decision Making. Available at:
https://www.tutorialspoint.com/python/index.htm