DEV Community: LueDev

Wall Street X: How I Turned My Finance Obsession Into a Real-World Full-Stack Trading App

LueDev — Thu, 31 Oct 2024 07:56:10 +0000

Introduction

Ever since I started diving into the world of stock trading, finance has become my latest obsession. The thrill of managing portfolios, tracking stock movements, and analyzing financial data felt like a blend of strategy, intuition, and good-old problem-solving. As a tech enthusiast, I realized there was a way to combine my passion for trading with my skills in full-stack development. That’s how I landed on my latest project: Wall Street X—an app where users can manage their stock portfolios, log trades, and view real-time data, built with a Flask API backend and a React frontend. This wasn’t just a fun project—it was real-world experience that reinforced every lesson I’ve learned about both finance and software engineering. Here’s a look into the tech stack, the features, and how it all came together.

The Stack and Technologies

This project leveraged a diverse stack, with technologies selected to meet the needs of a high-performing, dynamic application:

Frontend: React

React was perfect for building a single-page app where users could interact with their portfolios in real-time. React Router allowed me to create a smooth, multi-page experience where users can toggle between their dashboard, trade history, and stock picker.

Backend: Flask API

Flask was the backend workhorse. I built out an API to handle CRUD operations for resources like Users, Stocks, Portfolios, and Trades. Flask-RESTful simplified endpoint creation, while Flask-Bcrypt and JWT authentication handled user logins securely.

Database: SQLAlchemy with SQLite

Using SQLAlchemy as the ORM, I designed a database schema with one-to-many and many-to-many relationships. The database stored users, trades, stocks, and portfolio data with data integrity and allowed for efficient querying of stock prices and trade histories.

Formik for Forms and Validation

Managing user input and validation with Formik made the login and trade forms feel polished and user-friendly. I implemented data type and format validations to prevent users from entering incorrect data.

Render for Deployment

With Render, I was able to deploy the app effortlessly, and I’ll continue using it for hosting Wall Street X once I’m ready to launch. Render’s support for both frontend and backend hosting simplified the deployment pipeline.

Meeting Project Requirements

Wall Street X wasn’t just a creative project but also a comprehensive solution that ticked off every project requirement:

Backend with Three Models and Relationships

The app has Users, Stocks, Portfolios, and Trades. Here’s how I set up the relationships:

One-to-Many:

Each user can have multiple portfolio entries, and each stock can be traded multiple times by different users.

Many-to-Many (with attributes):

Trades form a many-to-many relationship between users and stocks. This Trade model has user-submittable attributes like trade quantity, price at trade, and timestamps, making each trade unique and recordable.

Full CRUD Actions

Users can create and view trades, update profile information, and view real-time stock prices. Additionally, every interaction with a portfolio entry is logged, providing full CRUD actions on resources, particularly Trades and Portfolios.

Client-Side Routing

React Router enabled seamless navigation with routes for the login page, dashboard, trade history, and stock picker. This enhances the user experience by giving them quick access to all features from the navigation bar.

Data Fetching and Validation

Using Axios, I integrated data-fetching with the backend API for a smooth experience where data updates as users add new trades or stocks. Formik validates login details and trade entries with type and format validation, ensuring robust user input.

Why Wall Street X Was Real-World Practice

Building Wall Street X was like running a mini-fintech startup. Each feature—login security, real-time data display, CRUD functionality—required best practices for software architecture, database design, and user experience. Handling real-world issues like data validation, transaction integrity, and authentication provided hands-on learning. And the project turned into a valuable sandbox to practice techniques essential in both finance and tech.

As I move forward with finance, this project will be a proud addition to my portfolio. It reflects both my technical skills and a deepening understanding of the financial world. Stay tuned—Wall Street X will be live on Render soon!

Streamlining Hotel Management with Python CLI and ORM

LueDev — Sun, 12 May 2024 18:10:03 +0000

GitHub Link: https://github.com/LueDev/Python-CLI-ORM.git

Expanding on Simplifying Database Interaction with Python CLI

Introduction to Python CLI for Database Interaction:
Python CLI applications provide a straightforward and efficient means of interacting with databases, offering users a command-line interface to perform database operations seamlessly. These applications abstract away the complexities of SQL queries and database management, allowing users to focus solely on the desired results. By leveraging Object Relational Mappers (ORMs), developers can bridge the gap between Python objects and relational databases, simplifying the process of data retrieval, manipulation, and storage.

Flexibility with SQL Code:
While established ORM frameworks like SQLAlchemy offer powerful abstractions for database interactions, there are scenarios where direct SQL code provides greater flexibility and control. In this project, instead of relying on ORM methods exclusively, developers have the freedom to write custom SQL queries tailored to specific use cases. This approach enables finer-grained control over database operations and allows for optimizations that may not be achievable through ORM methods alone.

Object Relational Mapping (ORM):
The concept of Object Relational Mapping lies at the heart of our application, enabling seamless conversion between database rows and Python objects. By defining classes that mirror the structure of our database tables and implementing methods for object creation, retrieval, and manipulation, we create a cohesive mapping between the relational world of databases and the object-oriented paradigm of Python.

Understanding the Project Structure:
At the core of our Python CLI application are the database models "Hotel" and "Guest," which are defined in the Hotel.py and Guest.py files, respectively. These models represent the underlying database tables and establish a one-to-many relationship between hotels and guests. Through the methods provided by these models, users can create, retrieve, update, and delete records with ease, making database management a straightforward task.

Guest ORM Methods:

Method Name	Description
create()	Creates a new guest instance in the database.
instance_from_db()	Converts a database row to a Guest object.
get_all()	Retrieves all guest instances from the database.
find_by_id()	Finds a guest instance by its ID.
find_by_name()	Finds a guest instance by its name.
save()	Saves changes to an existing guest instance in the database.
update()	Updates an existing guest instance in the database.
delete()	Deletes a guest instance from the database.

Hotel ORM Methods:

Method Name	Description
create()	Creates a new hotel instance in the database.
instance_from_db()	Converts a database row to a Hotel object.
get_all()	Retrieves all hotel instances from the database.
find_by_id()	Finds a hotel instance by its ID.
find_by_name()	Finds a hotel instance by its name.
save()	Saves changes to an existing hotel instance in the database.
update()	Updates an existing hotel instance in the database.
delete()	Deletes a hotel instance from the database.

Functionality and Interactivity:
With the foundation of our ORM-based models in place, we can implement a wide range of functionalities to enhance interactivity and usability. From simple CRUD (Create, Read, Update, Delete) operations to more complex data querying and manipulation tasks, our Python CLI application provides users with a versatile toolkit for managing their database records effectively. The following are Hotel and Guest commands that will act as our backend methods.

Hotel Commands:

Command	Description
create_hotel()	Create a new hotel.
update_hotel()	Update an existing hotel.
delete_hotel()	Delete a hotel by ID.
display_all_hotels()	Display all hotels.
search_hotel_by_name()	Search for a hotel by name via fuzzy search.
search_hotel_by_id()	Search for a hotel by ID.

Guest Commands:

Command	Description
create_guest()	Create a new guest.
update_guest()	Update an existing guest.
delete_guest()	Delete a guest by ID.
display_all_guests()	Display all guests.
search_for_guest_by_id()	Search for a guest by ID.
search_for_guest_by_name()	Search for a guest by name via fuzzy search.
search_for_guests_from_one_hotel()	Display all guests for a single hotel.
search_for_guests_by_name_length()	Display all guests whose name length is equal to or less than a specified length.

CLI Interaction with Click:
The Click library serves as the backbone of our command-line interface, offering a simple and intuitive way to define commands and options. Through the use of Click decorators such as @click.group(), @click.command(), and @click.option(), we can create a cohesive CLI experience that guides users through various database operations with minimal effort. Feel free to look through the documentation for this library here

App Entry Point:
The app.py file serves as the entry point to our Python CLI application, organizing and centralizing all interaction commands in a modular and maintainable manner. By encapsulating each command within a dedicated function and leveraging Click's command grouping capabilities, we create a cohesive and user-friendly CLI interface that is easy to navigate and understand.

Testing with Pytest:
Testing is an integral part of software development, and our Python CLI application is no exception. With Pytest, we can write comprehensive test cases to validate the functionality of our ORM models, CLI commands, and other application components. I have implemented tests solely for the ORM models and properties set within these models. I will continue to add tests for the cli calls to the menu and asserting the database contains the entries based on the action committed.

Conclusion:
In conclusion, Python CLI applications offer a powerful and versatile solution for simplifying database interaction. By leveraging ORM frameworks, models, and libraries like Click, developers can build CLI applications that streamline database management tasks and empower users to interact with their data more effectively. Whether you're a seasoned developer or a database novice, Python CLI applications provide a user-friendly and accessible platform for database interaction, making database management a breeze.

Creating Luegle, A Google Maps Clone

LueDev — Mon, 06 Nov 2023 06:24:59 +0000

Github: https://github.com/LueDev/Luegle

My Map-Based Application: Zone Selection Meets Autocomplete Precision

I'm thrilled to introduce my map-based application, designed to make navigating the bustling streets of New York City a breeze. At its core, our app marries the simplicity of zone selection with the sophistication of autocomplete functionality to deliver a seamless user experience.

Zone Selection for Targeted Results

This app's standout feature is its ability to divide NYC into distinct zones using GeoJSON data. This isn’t just about aesthetics; it’s about functionality. Users begin their journey by selecting a specific zone on the map. This action sets the stage for a more focused search, ensuring that the results and markers displayed are relevant to the chosen area. Whether you’re a tourist looking to explore a particular neighborhood or a local searching for new hangout spots, our zone selection feature ensures that you only get the information you need.

Autocomplete: No Zone? No Problem!

While zone selection fine-tunes the search process, we understand that sometimes, you just need quick suggestions. Enter our autocomplete feature. It doesn’t require any zone selection. Start typing an address or a place of interest, and our application will instantly suggest predicted addresses, drawing from a vast database. This feature is perfect for those who already know where they want to go and need quick address validation or for those moments when you’re just looking to explore without constraints.

Best of Both Worlds

Our application is a testament to the synergy between structured search within zones and the freedom offered by autocomplete suggestions. We've meticulously designed it to cater to both the methodical planner and the spontaneous explorer.

Dive into our app today and experience the convergence of precision and freedom in city navigation. Happy exploring!

Learning Points

Throughout this project, I've significantly broadened my skill set in both geospatial data handling and web development, thanks to the Google Maps JavaScript API. The challenge of segmenting New York City into manageable zones led me to discover the potential of GeoJSON. By utilizing data from Beta NYC's map, I was able to effectively divide the city into distinct areas.

To enhance user interaction, I implemented event listeners for these zones and created a set of global variables such as selectedZones, placesWithinSelectedZones, and geoJsonFeatures. These variables were crucial for storing and managing data throughout the application. The selectedZoneCoords object became a central reference point for zone geometries, proving invaluable for ongoing access and manipulation.

Security was a priority, so I turned to environmental variables to protect sensitive information like my Google API key. This approach was reinforced by exploring Express.js, which allowed me to set up routes that facilitated communication between the front end and back end, using environmental variables for secure API interactions.

To maintain the integrity of my codebase, I included a .gitignore file to ensure only public data was version-controlled.

Diving into geospatial libraries, especially Turf.js, was a game-changer for conducting searches within specific zones. This exploration also sparked my interest in data visualization, leading me to investigate tools like ArcGIS, which expanded my understanding of the field.

In summary, this project wasn't just about building an application; it was a comprehensive learning experience. It sharpened my technical skills in API integration, geospatial analysis, and full-stack development, and it deepened my knowledge of data security and visualization.

Acknowledgments

This project stands on the shoulders of giants, and it's only fair to extend our gratitude to those whose work has made this application not just a possibility, but a reality.

Google: Our application leverages the Google Maps JavaScript API, a powerful tool that has enabled us to bring our map to life with rich details and robust functionality.

BetaNYC and NYC Open Data: The GeoJSON files provided by these incredible resources have been instrumental in our ability to divide NYC into navigable zones, forming the backbone of our application's zone selection feature.

Turf.js: This suite of geospatial libraries has been invaluable in our quest to offer precise and relevant search results within selected zones. Their tools have allowed us to handle complex spatial queries with ease.

ChatGPT: Last but certainly not least, we extend our heartfelt thanks to ChatGPT. The guidance, technical support, and creative input from this AI have been pivotal in overcoming challenges and bringing our vision to fruition.