Spaces:

milkomeda22
/

anycoder-4339b289

Running

App Files Files Community

milkomeda22 commited on 10 days ago

Commit

685c4cb

verified ·

1 Parent(s): 0f3eda2

Upload folder using huggingface_hub

Browse files

Files changed (1) hide show

index.html +781 -19

index.html CHANGED Viewed

@@ -1,19 +1,781 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>

+"""
+Anime Database Application using OOP and Modern Data Engineering Practices
+Built with anycoder
+"""
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional, Set
+from enum import Enum, auto
+from datetime import datetime
+import uuid
+import json
+from abc import ABC, abstractmethod
+import logging
+from functools import cached_property
+import re
+from pathlib import Path
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+class Genre(Enum):
+    """Enum representing anime genres"""
+    ACTION = auto()
+    ADVENTURE = auto()
+    COMEDY = auto()
+    DRAMA = auto()
+    FANTASY = auto()
+    HORROR = auto()
+    ROMANCE = auto()
+    SCI_FI = auto()
+    SLICE_OF_LIFE = auto()
+    SPORTS = auto()
+    SUPERNATURAL = auto()
+    THRILLER = auto()
+    def __str__(self):
+        return self.name.replace('_', ' ').title()
+class AnimeStatus(Enum):
+    """Enum representing anime status"""
+    ONGOING = auto()
+    COMPLETED = auto()
+    UPCOMING = auto()
+    HIATUS = auto()
+    CANCELLED = auto()
+    def __str__(self):
+        return self.name.title()
+@dataclass
+class Anime:
+    """Data class representing an anime entry"""
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    title: str
+    alternative_titles: List[str] = field(default_factory=list)
+    episodes: int = 0
+    status: AnimeStatus = AnimeStatus.ONGOING
+    genres: Set[Genre] = field(default_factory=set)
+    release_date: Optional[datetime] = None
+    end_date: Optional[datetime] = None
+    synopsis: str = ""
+    rating: float = 0.0
+    studio: str = ""
+    source: str = ""
+    duration: str = ""
+    season: Optional[str] = None
+    year: Optional[int] = None
+    popularity_rank: Optional[int] = None
+    favorites: int = 0
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+    def __post_init__(self):
+        """Validate and process data after initialization"""
+        if not self.title:
+            raise ValueError("Title cannot be empty")
+        if self.episodes < 0:
+            raise ValueError("Episodes cannot be negative")
+        if self.rating < 0 or self.rating > 10:
+            raise ValueError("Rating must be between 0 and 10")
+        if self.release_date and self.end_date:
+            if self.release_date > self.end_date:
+                raise ValueError("Release date cannot be after end date")
+        if self.year and (self.year < 1900 or self.year > datetime.now().year + 5):
+            raise ValueError("Invalid year")
+        # Extract year from release_date if not provided
+        if not self.year and self.release_date:
+            self.year = self.release_date.year
+    def to_dict(self) -> Dict:
+        """Convert anime object to dictionary"""
+        return {
+            "id": self.id,
+            "title": self.title,
+            "alternative_titles": self.alternative_titles,
+            "episodes": self.episodes,
+            "status": self.status.name,
+            "genres": [genre.name for genre in self.genres],
+            "release_date": self.release_date.isoformat() if self.release_date else None,
+            "end_date": self.end_date.isoformat() if self.end_date else None,
+            "synopsis": self.synopsis,
+            "rating": self.rating,
+            "studio": self.studio,
+            "source": self.source,
+            "duration": self.duration,
+            "season": self.season,
+            "year": self.year,
+            "popularity_rank": self.popularity_rank,
+            "favorites": self.favorites,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat()
+        }
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'Anime':
+        """Create anime object from dictionary"""
+        try:
+            return cls(
+                id=data.get("id", str(uuid.uuid4())),
+                title=data["title"],
+                alternative_titles=data.get("alternative_titles", []),
+                episodes=data.get("episodes", 0),
+                status=AnimeStatus[data.get("status", "ONGOING")],
+                genres={Genre[genre] for genre in data.get("genres", [])},
+                release_date=datetime.fromisoformat(data["release_date"]) if data.get("release_date") else None,
+                end_date=datetime.fromisoformat(data["end_date"]) if data.get("end_date") else None,
+                synopsis=data.get("synopsis", ""),
+                rating=data.get("rating", 0.0),
+                studio=data.get("studio", ""),
+                source=data.get("source", ""),
+                duration=data.get("duration", ""),
+                season=data.get("season"),
+                year=data.get("year"),
+                popularity_rank=data.get("popularity_rank"),
+                favorites=data.get("favorites", 0),
+                created_at=datetime.fromisoformat(data["created_at"]) if data.get("created_at") else datetime.now(),
+                updated_at=datetime.fromisoformat(data["updated_at"]) if data.get("updated_at") else datetime.now()
+            )
+        except Exception as e:
+            logger.error(f"Error creating anime from dict: {e}")
+            raise
+class AnimeRepositoryInterface(ABC):
+    """Abstract base class for anime repository"""
+    @abstractmethod
+    def add_anime(self, anime: Anime) -> None:
+        pass
+    @abstractmethod
+    def get_anime(self, anime_id: str) -> Optional[Anime]:
+        pass
+    @abstractmethod
+    def update_anime(self, anime: Anime) -> None:
+        pass
+    @abstractmethod
+    def delete_anime(self, anime_id: str) -> None:
+        pass
+    @abstractmethod
+    def get_all_anime(self) -> List[Anime]:
+        pass
+    @abstractmethod
+    def search_anime(self, query: str) -> List[Anime]:
+        pass
+    @abstractmethod
+    def filter_by_genre(self, genre: Genre) -> List[Anime]:
+        pass
+    @abstractmethod
+    def filter_by_status(self, status: AnimeStatus) -> List[Anime]:
+        pass
+class InMemoryAnimeRepository(AnimeRepositoryInterface):
+    """In-memory implementation of anime repository"""
+    def __init__(self):
+        self._anime_db: Dict[str, Anime] = {}
+    def add_anime(self, anime: Anime) -> None:
+        """Add anime to repository"""
+        if anime.id in self._anime_db:
+            raise ValueError(f"Anime with ID {anime.id} already exists")
+        self._anime_db[anime.id] = anime
+        logger.info(f"Added anime: {anime.title}")
+    def get_anime(self, anime_id: str) -> Optional[Anime]:
+        """Get anime by ID"""
+        return self._anime_db.get(anime_id)
+    def update_anime(self, anime: Anime) -> None:
+        """Update existing anime"""
+        if anime.id not in self._anime_db:
+            raise ValueError(f"Anime with ID {anime.id} not found")
+        anime.updated_at = datetime.now()
+        self._anime_db[anime.id] = anime
+        logger.info(f"Updated anime: {anime.title}")
+    def delete_anime(self, anime_id: str) -> None:
+        """Delete anime by ID"""
+        if anime_id not in self._anime_db:
+            raise ValueError(f"Anime with ID {anime_id} not found")
+        anime_title = self._anime_db[anime_id].title
+        del self._anime_db[anime_id]
+        logger.info(f"Deleted anime: {anime_title}")
+    def get_all_anime(self) -> List[Anime]:
+        """Get all anime in repository"""
+        return list(self._anime_db.values())
+    def search_anime(self, query: str) -> List[Anime]:
+        """Search anime by title or alternative titles"""
+        query = query.lower()
+        return [
+            anime for anime in self._anime_db.values()
+            if (query in anime.title.lower() or
+                any(query in alt.lower() for alt in anime.alternative_titles))
+        ]
+    def filter_by_genre(self, genre: Genre) -> List[Anime]:
+        """Filter anime by genre"""
+        return [anime for anime in self._anime_db.values() if genre in anime.genres]
+    def filter_by_status(self, status: AnimeStatus) -> List[Anime]:
+        """Filter anime by status"""
+        return [anime for anime in self._anime_db.values() if anime.status == status]
+class JSONAnimeRepository(AnimeRepositoryInterface):
+    """JSON file-based implementation of anime repository"""
+    def __init__(self, file_path: str = "anime_database.json"):
+        self.file_path = Path(file_path)
+        self._anime_db: Dict[str, Anime] = {}
+        self._load_database()
+    def _load_database(self) -> None:
+        """Load database from JSON file"""
+        try:
+            if self.file_path.exists():
+                with open(self.file_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self._anime_db = {
+                        anime_id: Anime.from_dict(anime_data)
+                        for anime_id, anime_data in data.items()
+                    }
+                logger.info(f"Loaded {len(self._anime_db)} anime entries from {self.file_path}")
+            else:
+                logger.info(f"Creating new database at {self.file_path}")
+        except Exception as e:
+            logger.error(f"Error loading database: {e}")
+            raise
+    def _save_database(self) -> None:
+        """Save database to JSON file"""
+        try:
+            data = {
+                anime_id: anime.to_dict()
+                for anime_id, anime in self._anime_db.items()
+            }
+            with open(self.file_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            logger.info(f"Saved {len(self._anime_db)} anime entries to {self.file_path}")
+        except Exception as e:
+            logger.error(f"Error saving database: {e}")
+            raise
+    def add_anime(self, anime: Anime) -> None:
+        """Add anime to repository"""
+        if anime.id in self._anime_db:
+            raise ValueError(f"Anime with ID {anime.id} already exists")
+        self._anime_db[anime.id] = anime
+        self._save_database()
+        logger.info(f"Added anime: {anime.title}")
+    def get_anime(self, anime_id: str) -> Optional[Anime]:
+        """Get anime by ID"""
+        return self._anime_db.get(anime_id)
+    def update_anime(self, anime: Anime) -> None:
+        """Update existing anime"""
+        if anime.id not in self._anime_db:
+            raise ValueError(f"Anime with ID {anime.id} not found")
+        anime.updated_at = datetime.now()
+        self._anime_db[anime.id] = anime
+        self._save_database()
+        logger.info(f"Updated anime: {anime.title}")
+    def delete_anime(self, anime_id: str) -> None:
+        """Delete anime by ID"""
+        if anime_id not in self._anime_db:
+            raise ValueError(f"Anime with ID {anime_id} not found")
+        anime_title = self._anime_db[anime_id].title
+        del self._anime_db[anime_id]
+        self._save_database()
+        logger.info(f"Deleted anime: {anime_title}")
+    def get_all_anime(self) -> List[Anime]:
+        """Get all anime in repository"""
+        return list(self._anime_db.values())
+    def search_anime(self, query: str) -> List[Anime]:
+        """Search anime by title or alternative titles"""
+        query = query.lower()
+        return [
+            anime for anime in self._anime_db.values()
+            if (query in anime.title.lower() or
+                any(query in alt.lower() for alt in anime.alternative_titles))
+        ]
+    def filter_by_genre(self, genre: Genre) -> List[Anime]:
+        """Filter anime by genre"""
+        return [anime for anime in self._anime_db.values() if genre in anime.genres]
+    def filter_by_status(self, status: AnimeStatus) -> List[Anime]:
+        """Filter anime by status"""
+        return [anime for anime in self._anime_db.values() if anime.status == status]
+class AnimeService:
+    """Service class for anime operations"""
+    def __init__(self, repository: AnimeRepositoryInterface):
+        self.repository = repository
+    def add_anime(self, anime_data: Dict) -> Anime:
+        """Add new anime to database"""
+        try:
+            anime = Anime.from_dict(anime_data)
+            self.repository.add_anime(anime)
+            return anime
+        except Exception as e:
+            logger.error(f"Error adding anime: {e}")
+            raise
+    def get_anime(self, anime_id: str) -> Optional[Anime]:
+        """Get anime by ID"""
+        return self.repository.get_anime(anime_id)
+    def update_anime(self, anime_id: str, anime_data: Dict) -> Optional[Anime]:
+        """Update existing anime"""
+        existing_anime = self.repository.get_anime(anime_id)
+        if not existing_anime:
+            return None
+        try:
+            # Update only the fields that are provided
+            for key, value in anime_data.items():
+                if hasattr(existing_anime, key):
+                    if key == "genres":
+                        setattr(existing_anime, key, {Genre[genre] for genre in value})
+                    elif key == "status":
+                        setattr(existing_anime, key, AnimeStatus[value])
+                    else:
+                        setattr(existing_anime, key, value)
+            existing_anime.updated_at = datetime.now()
+            self.repository.update_anime(existing_anime)
+            return existing_anime
+        except Exception as e:
+            logger.error(f"Error updating anime: {e}")
+            raise
+    def delete_anime(self, anime_id: str) -> bool:
+        """Delete anime by ID"""
+        try:
+            self.repository.delete_anime(anime_id)
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting anime: {e}")
+            return False
+    def get_all_anime(self) -> List[Anime]:
+        """Get all anime"""
+        return self.repository.get_all_anime()
+    def search_anime(self, query: str) -> List[Anime]:
+        """Search anime by query"""
+        return self.repository.search_anime(query)
+    def filter_by_genre(self, genre: str) -> List[Anime]:
+        """Filter anime by genre"""
+        try:
+            genre_enum = Genre[genre.upper()]
+            return self.repository.filter_by_genre(genre_enum)
+        except KeyError:
+            logger.error(f"Invalid genre: {genre}")
+            return []
+    def filter_by_status(self, status: str) -> List[Anime]:
+        """Filter anime by status"""
+        try:
+            status_enum = AnimeStatus[status.upper()]
+            return self.repository.filter_by_status(status_enum)
+        except KeyError:
+            logger.error(f"Invalid status: {status}")
+            return []
+    def get_top_rated(self, limit: int = 10) -> List[Anime]:
+        """Get top rated anime"""
+        return sorted(
+            self.repository.get_all_anime(),
+            key=lambda x: x.rating,
+            reverse=True
+        )[:limit]
+    def get_most_popular(self, limit: int = 10) -> List[Anime]:
+        """Get most popular anime"""
+        return sorted(
+            self.repository.get_all_anime(),
+            key=lambda x: x.popularity_rank if x.popularity_rank else float('inf'),
+            reverse=False
+        )[:limit]
+class AnimeDatabase:
+    """Main anime database application class"""
+    def __init__(self, repository_type: str = "json"):
+        """Initialize anime database with specified repository type"""
+        self.repository_type = repository_type.lower()
+        if self.repository_type == "json":
+            self.repository = JSONAnimeRepository()
+        else:
+            self.repository = InMemoryAnimeRepository()
+        self.service = AnimeService(self.repository)
+    def run(self):
+        """Run the anime database application"""
+        print("Anime Database Application")
+        print("Built with anycoder")
+        print(f"Using {self.repository_type} repository")
+        print("Type 'help' for available commands")
+        while True:
+            try:
+                command = input("\n> ").strip().lower()
+                if command == "exit":
+                    break
+                elif command == "help":
+                    self._show_help()
+                elif command == "add":
+                    self._add_anime()
+                elif command == "list":
+                    self._list_anime()
+                elif command == "search":
+                    self._search_anime()
+                elif command == "filter":
+                    self._filter_anime()
+                elif command == "top":
+                    self._show_top_rated()
+                elif command == "popular":
+                    self._show_most_popular()
+                elif command == "delete":
+                    self._delete_anime()
+                elif command == "update":
+                    self._update_anime()
+                else:
+                    print("Unknown command. Type 'help' for available commands.")
+            except KeyboardInterrupt:
+                print("\nExiting...")
+                break
+            except Exception as e:
+                print(f"Error: {e}")
+    def _show_help(self):
+        """Display help information"""
+        print("\nAvailable commands:")
+        print("  help       - Show this help message")
+        print("  add        - Add new anime to database")
+        print("  list       - List all anime in database")
+        print("  search     - Search anime by title")
+        print("  filter     - Filter anime by genre or status")
+        print("  top        - Show top rated anime")
+        print("  popular    - Show most popular anime")
+        print("  update     - Update existing anime")
+        print("  delete     - Delete anime from database")
+        print("  exit       - Exit the application")
+    def _add_anime(self):
+        """Add new anime to database"""
+        print("\nAdd New Anime")
+        print("Enter anime details (press Enter to skip optional fields)")
+        try:
+            title = input("Title (required): ").strip()
+            if not title:
+                print("Title is required")
+                return
+            anime_data = {
+                "title": title,
+                "alternative_titles": input("Alternative titles (comma separated): ").strip().split(","),
+                "episodes": int(input("Episodes: ").strip() or 0),
+                "status": input("Status (ONGOING/COMPLETED/UPCOMING/HIATUS/CANCELLED): ").strip().upper() or "ONGOING",
+                "genres": input("Genres (comma separated, e.g., ACTION,COMEDY): ").strip().upper().split(","),
+                "release_date": input("Release date (YYYY-MM-DD): ").strip(),
+                "end_date": input("End date (YYYY-MM-DD): ").strip(),
+                "synopsis": input("Synopsis: ").strip(),
+                "rating": float(input("Rating (0-10): ").strip() or 0),
+                "studio": input("Studio: ").strip(),
+                "source": input("Source: ").strip(),
+                "duration": input("Duration (e.g., 24 min): ").strip(),
+                "season": input("Season (e.g., Winter 2023): ").strip(),
+                "year": int(input("Year: ").strip() or datetime.now().year),
+                "popularity_rank": int(input("Popularity rank: ").strip() or 0) or None,
+                "favorites": int(input("Favorites count: ").strip() or 0)
+            }
+            # Process dates
+            if anime_data["release_date"]:
+                anime_data["release_date"] = datetime.strptime(anime_data["release_date"], "%Y-%m-%d").isoformat()
+            if anime_data["end_date"]:
+                anime_data["end_date"] = datetime.strptime(anime_data["end_date"], "%Y-%m-%d").isoformat()
+            # Remove empty alternative titles
+            anime_data["alternative_titles"] = [t.strip() for t in anime_data["alternative_titles"] if t.strip()]
+            # Remove empty genres
+            anime_data["genres"] = [g.strip() for g in anime_data["genres"] if g.strip()]
+            anime = self.service.add_anime(anime_data)
+            print(f"Successfully added anime: {anime.title}")
+        except Exception as e:
+            print(f"Error adding anime: {e}")
+    def _list_anime(self):
+        """List all anime in database"""
+        anime_list = self.service.get_all_anime()
+        if not anime_list:
+            print("No anime in database")
+            return
+        print(f"\nListing {len(anime_list)} anime:")
+        for i, anime in enumerate(anime_list, 1):
+            print(f"\n{i}. {anime.title}")
+            print(f"   ID: {anime.id}")
+            print(f"   Status: {anime.status}")
+            print(f"   Episodes: {anime.episodes}")
+            print(f"   Rating: {anime.rating}/10")
+            print(f"   Genres: {', '.join(str(g) for g in anime.genres)}")
+            if anime.release_date:
+                print(f"   Released: {anime.release_date.strftime('%Y-%m-%d')}")
+            print(f"   Studio: {anime.studio}")
+            print(f"   Synopsis: {anime.synopsis[:100]}...")
+    def _search_anime(self):
+        """Search anime by title"""
+        query = input("\nEnter search query: ").strip()
+        if not query:
+            print("Please enter a search query")
+            return
+        results = self.service.search_anime(query)
+        if not results:
+            print("No results found")
+            return
+        print(f"\nFound {len(results)} results:")
+        for i, anime in enumerate(results, 1):
+            print(f"\n{i}. {anime.title}")
+            print(f"   ID: {anime.id}")
+            print(f"   Status: {anime.status}")
+            print(f"   Rating: {anime.rating}/10")
+    def _filter_anime(self):
+        """Filter anime by genre or status"""
+        print("\nFilter Options:")
+        print("1. By Genre")
+        print("2. By Status")
+        choice = input("Choose filter type (1/2): ").strip()
+        if choice == "1":
+            print("\nAvailable Genres:")
+            for genre in Genre:
+                print(f"  - {genre}")
+            genre_input = input("Enter genre: ").strip().upper()
+            try:
+                genre = Genre[genre_input]
+                results = self.service.filter_by_genre(genre.name)
+            except KeyError:
+                print("Invalid genre")
+                return
+        elif choice == "2":
+            print("\nAvailable Statuses:")
+            for status in AnimeStatus:
+                print(f"  - {status}")
+            status_input = input("Enter status: ").strip().upper()
+            try:
+                results = self.service.filter_by_status(status_input)
+            except KeyError:
+                print("Invalid status")
+                return
+        else:
+            print("Invalid choice")
+            return
+        if not results:
+            print("No results found")
+            return
+        print(f"\nFound {len(results)} results:")
+        for i, anime in enumerate(results, 1):
+            print(f"\n{i}. {anime.title}")
+            print(f"   ID: {anime.id}")
+            print(f"   Rating: {anime.rating}/10")
+    def _show_top_rated(self):
+        """Show top rated anime"""
+        limit = input("\nEnter number of top rated anime to show (default 10): ").strip()
+        try:
+            limit = int(limit) if limit else 10
+            results = self.service.get_top_rated(limit)
+            if not results:
+                print("No anime in database")
+                return
+            print(f"\nTop {len(results)} Rated Anime:")
+            for i, anime in enumerate(results, 1):
+                print(f"\n{i}. {anime.title}")
+                print(f"   Rating: {anime.rating}/10")
+                print(f"   Episodes: {anime.episodes}")
+                print(f"   Genres: {', '.join(str(g) for g in anime.genres)}")
+        except ValueError:
+            print("Please enter a valid number")
+    def _show_most_popular(self):
+        """Show most popular anime"""
+        limit = input("\nEnter number of most popular anime to show (default 10): ").strip()
+        try:
+            limit = int(limit) if limit else 10
+            results = self.service.get_most_popular(limit)
+            if not results:
+                print("No anime in database")
+                return
+            print(f"\nTop {len(results)} Most Popular Anime:")
+            for i, anime in enumerate(results, 1):
+                print(f"\n{i}. {anime.title}")
+                print(f"   Popularity Rank: {anime.popularity_rank}")
+                print(f"   Favorites: {anime.favorites}")
+                print(f"   Rating: {anime.rating}/10")
+        except ValueError:
+            print("Please enter a valid number")
+    def _delete_anime(self):
+        """Delete anime from database"""
+        anime_id = input("\nEnter anime ID to delete: ").strip()
+        if not anime_id:
+            print("Please enter an anime ID")
+            return
+        anime = self.service.get_anime(anime_id)
+        if not anime:
+            print("Anime not found")
+            return
+        confirm = input(f"Are you sure you want to delete '{anime.title}'? (y/n): ").strip().lower()
+        if confirm == 'y':
+            if self.service.delete_anime(anime_id):
+                print(f"Successfully deleted anime: {anime.title}")
+            else:
+                print("Failed to delete anime")
+        else:
+            print("Deletion cancelled")
+    def _update_anime(self):
+        """Update existing anime"""
+        anime_id = input("\nEnter anime ID to update: ").strip()
+        if not anime_id:
+            print("Please enter an anime ID")
+            return
+        anime = self.service.get_anime(anime_id)
+        if not anime:
+            print("Anime not found")
+            return
+        print(f"\nCurrent anime details for '{anime.title}':")
+        print(f"1. Title: {anime.title}")
+        print(f"2. Alternative Titles: {', '.join(anime.alternative_titles)}")
+        print(f"3. Episodes: {anime.episodes}")
+        print(f"4. Status: {anime.status}")
+        print(f"5. Genres: {', '.join(str(g) for g in anime.genres)}")
+        print(f"6. Release Date: {anime.release_date}")
+        print(f"7. End Date: {anime.end_date}")
+        print(f"8. Synopsis: {anime.synopsis}")
+        print(f"9. Rating: {anime.rating}")
+        print(f"10. Studio: {anime.studio}")
+        print(f"11. Source: {anime.source}")
+        print(f"12. Duration: {anime.duration}")
+        print(f"13. Season: {anime.season}")
+        print(f"14. Year: {anime.year}")
+        print(f"15. Popularity Rank: {anime.popularity_rank}")
+        print(f"16. Favorites: {anime.favorites}")
+        update_data = {}
+        while True:
+            field_num = input("\nEnter field number to update (0 to finish): ").strip()
+            if field_num == "0":
+                break
+            try:
+                field_num = int(field_num)
+                if field_num < 1 or field_num > 16:
+                    print("Invalid field number")
+                    continue
+                field_names = [
+                    "title", "alternative_titles", "episodes", "status", "genres",
+                    "release_date", "end_date", "synopsis", "rating", "studio",
+                    "source", "duration", "season", "year", "popularity_rank", "favorites"
+                ]
+                field_name = field_names[field_num - 1]
+                if field_name == "alternative_titles":
+                    value = input(f"Enter new {field_name} (comma separated): ").strip().split(",")
+                elif field_name in ["release_date", "end_date"]:
+                    value = input(f"Enter new {field_name} (YYYY-MM-DD): ").strip()
+                    if value:
+                        value = datetime.strptime(value, "%Y-%m-%d").isoformat()
+                elif field_name in ["episodes", "year", "popularity_rank", "favorites"]:
+                    value = int(input(f"Enter new {field_name}: ").strip())
+                elif field_name == "rating":
+                    value = float(input(f"Enter new {field_name}: ").strip())
+                elif field_name == "genres":
+                    value = input(f"Enter new {field_name} (comma separated): ").strip().upper().split(",")
+                else:
+                    value = input(f"Enter new {field_name}: ").strip()
+                if value or value == 0:  # Allow 0 for numeric fields
+                    update_data[field_name] = value
+            except ValueError as e:
+                print(f"Invalid input: {e}")
+            except Exception as e:
+                print(f"Error: {e}")
+        if update_data:
+            updated_anime = self.service.update_anime(anime_id, update_data)
+            if updated_anime:
+                print(f"Successfully updated anime: {updated_anime.title}")
+            else:
+                print("Failed to update anime")
+        else:
+            print("No changes made")
+if __name__ == "__main__":
+    # Initialize and run the anime database application
+    print("Initializing Anime Database...")
+    db = AnimeDatabase(repository_type="json")
+    db.run()