contactlookup 1.0.2__py3-none-any.whl

contactlookup/__init__.py

@@ -0,0 +1,15 @@
+# Initialize logger
+import logging.config
+from pathlib import Path
+
+from contactlookup.definitions import LOGGING_CONFIG_PATH
+
+# homepath = $HOME
+HOMEPATH = str(Path.home())
+logging.config.fileConfig(
+    fname=LOGGING_CONFIG_PATH,
+    disable_existing_loggers=False,
+    defaults={"log_dir": HOMEPATH},
+)
+logger = logging.getLogger(__name__)
+logger.info("Logger initialized")

contactlookup/__main__.py

@@ -0,0 +1,141 @@
+"""Main module for the contactlookup package."""
+
+import logging
+import site
+import traceback
+from pathlib import Path
+
+import fire
+import uvicorn
+
+import contactlookup.controller as app_controller
+from contactlookup.definitions import (
+    FILE_DATA_STORE_SERVICE,
+    ROOT_DIR,
+    SAMPLE_CONTACTS_DIR,
+    SAMPLE_CONTACTS_FILE,
+)
+from contactlookup.services.data_store_service import DataStoreService
+from contactlookup.services.file_data_store_service import FileDataStoreService
+
+
+def _load_contacts_file(service: FileDataStoreService, contacts_file_path: str | None):
+    # Ensure the contacts file path is provided.
+    # If no file is provided by the user, use the default contacts file:
+    # SAMPLE_CONTACTS_DIR/SAMPLE_CONTACTS_FILE in the tests directory.
+    logger = logging.getLogger(__name__)
+    if not contacts_file_path:
+        print("No contacts file provided.")
+        logger.info("No contacts file provided. Using default contacts file.")
+        # The data directory is in the tests directory which is installed in
+        # the site-packages directory.
+
+        try:
+            # First check for tests/data/contacts.vcf in root's directory.
+            # If we are developing the package, the contacts file will be in
+            # ROOT_DIR/../tests/data/contacts.vcf
+            development_contacts_file_path = (
+                ROOT_DIR.parent / SAMPLE_CONTACTS_DIR / SAMPLE_CONTACTS_FILE
+            )
+
+            if development_contacts_file_path.exists():
+                contacts_file_path = str(development_contacts_file_path)
+                logger.info("Application is in development mode.")
+            else:
+                # We are not developing the package. The contacts file will be
+                # in the site-packages directory.
+                # Check for tests/data/contacts.vcf in the site-packages directory
+                site_packages_dir = Path(site.getsitepackages()[0])
+
+                contacts_file_path = (
+                    f"{site_packages_dir}/{SAMPLE_CONTACTS_DIR}/{SAMPLE_CONTACTS_FILE}"
+                )
+                logger.info("Application is in production mode.")
+            print(f"Using default contacts file: {contacts_file_path}")
+        except ImportError as e:
+            print(
+                "Could not find site-packages directory. Please provide a contacts file.",
+            )
+            stack_trace = traceback.format_exc()
+            logger.error(
+                "_load_contacts_file|Error loading contacts file: %s. Exiting",
+                e,
+            )
+            logger.error("_load_contacts_file|Stack trace: %s", stack_trace)
+            return
+
+    contacts_file_path = contacts_file_path.strip()
+    contacts_file = Path(contacts_file_path)
+
+    service.set_contacts_file_path(contacts_file)
+
+
+def _setup(
+    data_store_service: str | None = None,
+    contacts_file_path: str | None = None,
+) -> DataStoreService | None:
+    """
+    data_store_service is used to indicate the type of data store service to
+    use.
+    Options:
+    1. f: indicates FileDataStoreService
+    2. d: indicates DatabaseDataStoreService (not implemented)
+
+    If no data_store_service is provided, the default is FileDataStoreService.
+    If an invalid data_store_service is provided, the default is FileDataStoreService.
+    """
+    logger = logging.getLogger(__name__)
+    if not data_store_service:
+        data_store_service = FILE_DATA_STORE_SERVICE
+    data_store_service = data_store_service.strip().lower()
+
+    logger.info("Using data store service option: %s", data_store_service)
+    # Tell the user what data store service is being used
+    if data_store_service == FILE_DATA_STORE_SERVICE:
+        print("Using FileDataStoreService")
+    else:
+        # Not implemented databaseconnection. Would require a database connection.
+        print("Invalid data store service. Using FileDataStoreService")
+        data_store_service = FILE_DATA_STORE_SERVICE
+
+    service = FileDataStoreService()
+    _load_contacts_file(service=service, contacts_file_path=contacts_file_path)
+    initialized = service.initialize()
+    if not initialized:
+        logger.error("Data store service failed to initialize")
+        print("Data store service failed to initialize")
+        return None
+    return service
+
+
+def cli():
+    """Command line interface."""
+    fire.Fire(main)
+
+
+def main(service: str | None = FILE_DATA_STORE_SERVICE, file: str | None = None):
+    """Expose API to query contacts.
+
+    Args:
+        service (str | None, optional): The data store service to use. Defaults to FILE_DATA_STORE_SERVICE.
+        file (str | None, optional): The path to the contacts file. Defaults to None.
+    """
+    data_store_service = _setup(data_store_service=service, contacts_file_path=file)
+    if not data_store_service:
+        return
+
+    # At this point, the data store service is initialized
+    # We can now run the FastAPI application
+    logger = logging.getLogger(__name__)
+    logger.info("Data store service initialized")
+    print("Data store service initialized")
+
+    app_controller.set_data_store_service(data_store_service)
+
+    logger.info("Running FastAPI application")
+    # Run the FastAPI application
+    uvicorn.run(app_controller.app)
+
+
+if __name__ == "__main__":
+    fire.Fire(main)

contactlookup/controller.py

@@ -0,0 +1,92 @@
+"""Controller for the contactlookup app."""
+
+from fastapi import FastAPI
+
+from contactlookup.services.data_store_service import DataStoreService
+
+app = FastAPI()
+service: DataStoreService | None = None
+
+
+def set_data_store_service(data_store_service: DataStoreService):
+    """Set the data store service.
+
+    In the future, we will implement a database service to store contacts. This
+    function will be used to set the database service to be used by the
+    controller.
+
+    Args:
+        data_store_service (DataStoreService): The data store service.
+    """
+    global service
+    service = data_store_service
+
+
+@app.get("/")
+def read_root():
+    """Welcome message."""
+    msg = "Welcome to the Contact Lookup App. Use the /docs endpoint to see the API documentation."
+    return {"message": msg}
+
+
+@app.get("/contacts")
+def read_contacts():
+    """Get all contacts."""
+    if not service:
+        return {"Error": "Data store service not set"}
+    contacts = service.get_contacts()
+    return {"contacts": contacts}
+
+
+@app.get("/contacts/{contact_id}")
+def read_contact(contact_id: int):
+    """Get contact by ID."""
+    if not service:
+        return {"Error": "Data store service not set"}
+    contact = service.get_contact(contact_id)
+    return {"contact": contact}
+
+
+@app.get("/contacts/fname/{fname}")
+def read_contacts_by_fname(fname: str):
+    """Get contacts by first name."""
+    if not service:
+        return {"Error": "Data store service not set"}
+    contacts = service.get_contacts_by_fname(fname)
+    return {"contacts": contacts}
+
+
+@app.get("/contacts/phone/{phone_number}")
+def read_contacts_by_phone_number(phone_number: str):
+    """Get contacts by phone number."""
+    if not service:
+        return {"Error": "Data store service not set"}
+    contacts = service.get_contacts_by_phone_number(phone_number)
+    return {"contacts": contacts}
+
+
+@app.get("/contacts/email/{email}")
+def read_contacts_by_email(email: str):
+    """Get contacts by email."""
+    if not service:
+        return {"Error": "Data store service not set"}
+    contacts = service.get_contacts_by_email(email)
+    return {"contacts": contacts}
+
+
+@app.get("/contacts/country/{country}")
+def read_contacts_by_country(country: str):
+    """Get contacts by country."""
+    if not service:
+        return {"Error": "Data store service not set"}
+    contacts = service.get_contacts_by_country(country)
+    return {"contacts": contacts}
+
+
+@app.get("/contacts/state/{state}")
+def read_contacts_by_state(state: str):
+    """Get contacts by state."""
+    if not service:
+        return {"Error": "Data store service not set"}
+    contacts = service.get_contacts_by_state(state)
+    return {"contacts": contacts}

contactlookup/definitions.py

@@ -0,0 +1,12 @@
+# Project Root Folder
+from pathlib import Path
+
+ROOT_DIR = Path(__file__).parents[0]
+LOGGING_CONFIG_PATH = ROOT_DIR / "logging_configuration.conf"
+
+
+# Constants
+VCF_EXTENSION = ".vcf"
+SAMPLE_CONTACTS_DIR = "tests/data"
+SAMPLE_CONTACTS_FILE = "contacts.vcf"
+FILE_DATA_STORE_SERVICE = "f"

contactlookup/logging_configuration.conf

@@ -0,0 +1,28 @@
+[loggers]
+keys=root
+
+[handlers]
+keys=consoleHandler,fileHandler
+
+[formatters]
+keys=outputFormatter
+
+[logger_root]
+level=DEBUG
+handlers=fileHandler,consoleHandler
+
+[handler_fileHandler]
+class=handlers.TimedRotatingFileHandler
+level=INFO
+formatter=outputFormatter
+args=('%(log_dir)s/contactlookup.log', 'midnight', 1, 0, 'utf-8')
+
+[handler_consoleHandler]
+class=StreamHandler
+level=ERROR
+formatter=outputFormatter
+args=(sys.stdout,)
+
+[formatter_outputFormatter]
+format=%(asctime)s - %(name)s (%(filename)s:%(lineno)d): [%(levelname)s] %(message)s
+datefmt=

contactlookup/models/address.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Address:
+    id: int | None = field(init=False, default=None)
+    street: str
+    city: str | None
+    state: str | None
+    postal_code: str | None
+    contact_id: int
+    type: str | None = None
+    country: str | None = None
+
+    def __post_init__(self):
+        self.street = self.street.strip()
+        self.city = self.city.strip().upper() if self.city is not None else None
+        self.state = self.state.strip().upper() if self.state is not None else None
+        self.postal_code = (
+            self.postal_code.strip() if self.postal_code is not None else None
+        )
+        self.country = (
+            self.country.strip().upper() if self.country is not None else None
+        )
+        self.type = self.type.strip().upper() if self.type is not None else None

contactlookup/models/contact.py

@@ -0,0 +1,63 @@
+# A VCF contact model
+from dataclasses import dataclass, field
+
+from contactlookup.models.address import Address
+from contactlookup.models.email import Email
+from contactlookup.models.phone_number import PhoneNumber
+
+
+@dataclass
+class Contact:
+    id: int
+    first_name: str
+    last_name: str
+    other_names: str | None
+    company: str | None
+    title: str | None
+    nickname: str | None = field(default=None)
+    birthday: str | None = field(default=None)
+    phone_numbers: list[PhoneNumber] = field(default_factory=list)
+    addresses: list[Address] = field(default_factory=list)
+    emails: list[Email] = field(default_factory=list)
+
+    def __post_init__(self):
+        self.first_name = self.first_name.strip().upper()
+        self.last_name = self.last_name.strip().upper()
+        self.company = self.company.strip() if self.company is not None else None
+        self.title = self.title.strip().upper() if self.title is not None else None
+        self.other_names = (
+            self.other_names.strip().upper() if self.other_names is not None else None
+        )
+        self.nickname = (
+            self.nickname.strip().upper() if self.nickname is not None else None
+        )
+
+    def __eq__(self, other):
+        if not isinstance(other, Contact):
+            return False
+
+        return (
+            self.first_name == other.first_name
+            and self.last_name == other.last_name
+            and self.other_names == other.other_names
+            and self.company == other.company
+            and self.title == other.title
+            and self.nickname == other.nickname
+            and self.phone_numbers == other.phone_numbers
+            and self.addresses == other.addresses
+            and self.emails == other.emails
+        )
+
+    def add_phone_number(self, phone_number: PhoneNumber):
+        self.phone_numbers.append(phone_number)
+
+    def add_address(self, address: Address):
+        self.addresses.append(address)
+
+    def add_email(self, email: Email):
+        self.emails.append(email)
+
+    def refresh(self):
+        # Run the post init method again to ensure all fields are properly
+        # formatted
+        self.__post_init__()

contactlookup/models/email.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Email:
+    id: int | None = field(init=False, default=None)
+    email: str
+    type: str | None
+    contact_id: int
+
+    def __post_init__(self):
+        self.email = self.email.strip()
+        self.type = self.type.strip().lower() if self.type is not None else None

contactlookup/models/phone_number.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class PhoneNumber:
+    id: int | None = field(init=False, default=None)
+    number: str
+    contact_id: int
+    type: str | None = field(default=None)
+
+    def __post_init__(self):
+        # Remove all spaces, dashes, parentheses and + from the phone number
+        self.number = "".join(
+            [char for char in self.number if char.isnumeric()],
+        )
+        self.type = self.type.strip().upper() if self.type is not None else None

contactlookup/services/data_store_service.py

@@ -0,0 +1,54 @@
+"""Abstract class for data store service."""
+
+from abc import ABC, abstractmethod
+
+from contactlookup.models.contact import Contact
+
+
+class DataStoreService(ABC):
+    """Abstract class for data store service."""
+
+    @abstractmethod
+    def initialize(self) -> bool:
+        """Initialize data store."""
+
+    @abstractmethod
+    def get_contact(self, contact_id: int) -> Contact | None:
+        """Get contact by ID."""
+
+    @abstractmethod
+    def get_contacts(self) -> list[Contact]:
+        """Get all contacts."""
+
+    @abstractmethod
+    def get_contacts_by_fname(self, fname: str) -> list:
+        """Get contacts by first name."""
+
+    @abstractmethod
+    def get_contacts_by_phone_number(self, phone_number: str) -> list:
+        """Get contacts by phone number."""
+
+    @abstractmethod
+    def get_contacts_by_email(self, email: str) -> list:
+        """Get contacts by email."""
+
+    @abstractmethod
+    def get_contacts_by_country(self, country: str) -> list:
+        """Get contacts by country."""
+
+    @abstractmethod
+    def get_contacts_by_state(self, state: str) -> list:
+        """Get contacts by state."""
+
+    # Write operations are not needed for this project
+    # @abstractmethod
+    # def create_contact(self, contact: dict) -> dict:
+    #     """Create a new contact."""
+
+    # @abstractmethod
+    # def update_contact(self, contact_id: str, contact: dict) -> dict:
+    #     """Update contact by ID."""
+
+    # @abstractmethod
+    # def delete_contact(self, contact_id: str) -> dict:
+    #     """Delete contact by ID."""