cloudnoteslib 0.1.0__tar.gz

cloudnoteslib-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: cloudnoteslib
+Version: 0.1.0
+Summary: A reusable Object-Oriented generic library for note processing, analysis, and security.
+Home-page: https://github.com/Kavyavegunta04/Cloudnote
+Author: Kavya
+Author-email: Kavya <kavyavegunta27@gmail.com>
+Project-URL: Homepage, https://github.com/Kavyavegunta04/Cloudnote
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41.0.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# cloudnoteslib
+
+A comprehensive, reusable Python Object-Oriented Programming (OOP) library designed for text note processing, content analysis, security, and exports.
+
+## Features & OOP Principles
+- **Encapsulation:** Strongly typed `Note` and `Tag` models with data validation via `@property`.
+- **Abstraction:** Abstract `NoteProcessor` base class guaranteeing unified interfaces.
+- **Inheritance & Polymorphism:** `MarkdownProcessor`, `PlainTextProcessor`, and `RichTextProcessor` implementations sharing the same contract.
+- **Design Patterns:**
+  - **Facade Pattern:** `CloudNotesClient` acts as the single point of entry.
+  - **Strategy Pattern:** Interchangeable search algorithms (`search.py`).
+  - **Template Method Pattern:** Processors share generic steps while overriding specific details.
+  - **Singleton Pattern:** Global configuration management.
+
+## Installation
+```bash
+pip install cloudnoteslib
+```

cloudnoteslib-0.1.0/README.md

@@ -0,0 +1,18 @@
+# cloudnoteslib
+
+A comprehensive, reusable Python Object-Oriented Programming (OOP) library designed for text note processing, content analysis, security, and exports.
+
+## Features & OOP Principles
+- **Encapsulation:** Strongly typed `Note` and `Tag` models with data validation via `@property`.
+- **Abstraction:** Abstract `NoteProcessor` base class guaranteeing unified interfaces.
+- **Inheritance & Polymorphism:** `MarkdownProcessor`, `PlainTextProcessor`, and `RichTextProcessor` implementations sharing the same contract.
+- **Design Patterns:**
+  - **Facade Pattern:** `CloudNotesClient` acts as the single point of entry.
+  - **Strategy Pattern:** Interchangeable search algorithms (`search.py`).
+  - **Template Method Pattern:** Processors share generic steps while overriding specific details.
+  - **Singleton Pattern:** Global configuration management.
+
+## Installation
+```bash
+pip install cloudnoteslib
+```

cloudnoteslib-0.1.0/cloudnoteslib/__init__.py

@@ -0,0 +1,128 @@
+"""
+cloudnoteslib — A reusable Python OOP library for Note processing and analysis.
+
+Features:
+    - Encapsulated Note and Tag models
+    - Polymorphic content processors (Markdown, Plain, Rich text)
+    - Strategy-pattern based Search Engine
+    - AES-256 Encryption & XSS Sanitization
+    - Export tools (JSON, Markdown)
+
+Version: 0.1.0
+"""
+
+__version__ = "0.1.0"
+__author__ = "Kavya"
+__email__ = "kavyavegunta27@gmail.com"
+
+from typing import List, Optional
+
+# Core Models
+from .models.note import Note
+from .models.tag import Tag
+from .models.note_collection import NoteCollection
+
+# Processors
+from .processors.base import NoteProcessor
+from .processors.markdown_processor import MarkdownProcessor
+from .processors.plaintext_processor import PlainTextProcessor
+from .processors.richtext_processor import RichTextProcessor
+
+# Analyzers
+from .analyzers.content_analyzer import ContentAnalyzer
+from .analyzers.statistics import NoteStatistics
+from .analyzers.search import SearchEngine
+
+# Security & Exporters
+from .security.encryptor import NoteEncryptor
+from .security.sanitizer import ContentSanitizer
+from .exporters.json_exporter import JSONExporter
+from .exporters.markdown_exporter import MarkdownExporter
+
+# Config & Exceptions
+from .config import config, NoteConfig
+from .exceptions import CloudNotesLibError, ProcessorNotSupportedError
+
+
+# =========================================================================
+# CloudNotesClient — FACADE PATTERN
+# =========================================================================
+
+class CloudNotesClient:
+    """
+    High-level Facade for cloudnoteslib.
+    
+    Provides a simplified, unified interface hiding the complexity of
+    processors, analyzers, security, and exporters.
+    """
+    
+    def __init__(self, processor_type: str = "markdown"):
+        self.processor_type = processor_type
+        self._processor = self._create_processor(processor_type)
+        self._analyzer = ContentAnalyzer()
+        self._search_engine = SearchEngine()
+        self._sanitizer = ContentSanitizer()
+        self._encryptor = NoteEncryptor(salt=config.password_salt)
+        self._stats = NoteStatistics()
+        
+    def _create_processor(self, type_name: str) -> NoteProcessor:
+        """Factory Method for creating content processors."""
+        processors = {
+            "markdown": MarkdownProcessor(),
+            "plaintext": PlainTextProcessor(),
+            "richtext": RichTextProcessor(),
+        }
+        normalized = type_name.strip().lower()
+        if normalized not in processors:
+            raise ProcessorNotSupportedError(f"Processor '{type_name}' not supported.")
+        return processors[normalized]
+
+    def process_note(self, note: Note) -> Note:
+        """Sanitize and process note content."""
+        clean_content = self._sanitizer.sanitize(note.content)
+        processed_content = self._processor.process(clean_content)
+        # We don't overwrite the original content in the note with processed plain text,
+        # but we could. For now, just return a sanitized version.
+        note.content = clean_content
+        return note
+
+    def analyze_content(self, note: Note) -> dict:
+        """Return analytics for a single note."""
+        return self._analyzer.analyze(note)
+        
+    def get_collection_stats(self, collection: NoteCollection) -> dict:
+        """Return collection-level statistics."""
+        return self._stats.get_summary(collection)
+
+    def search_notes(self, collection: NoteCollection, query: str, strategy: str = "exact") -> NoteCollection:
+        """Search notes using a specific strategy."""
+        self._search_engine.set_strategy(strategy)
+        return self._search_engine.search(collection, query)
+        
+    def encrypt_content(self, plain_text: str, password: str) -> str:
+        """Encrypt content string."""
+        return self._encryptor.encrypt(plain_text, password)
+        
+    def decrypt_content(self, encrypted_text: str, password: str) -> str:
+        """Decrypt content string."""
+        return self._encryptor.decrypt(encrypted_text, password)
+
+    def export(self, collection: NoteCollection, format: str = "json") -> str:
+        """Export collection to requested format."""
+        if format.lower() == "json":
+            return JSONExporter().export(collection)
+        elif format.lower() in ("md", "markdown"):
+            return MarkdownExporter().export(collection)
+        else:
+            raise ValueError(f"Export format not supported: {format}")
+
+
+__all__ = [
+    "CloudNotesClient",
+    "Note", "Tag", "NoteCollection",
+    "NoteProcessor", "MarkdownProcessor", "PlainTextProcessor", "RichTextProcessor",
+    "ContentAnalyzer", "NoteStatistics", "SearchEngine",
+    "NoteEncryptor", "ContentSanitizer",
+    "JSONExporter", "MarkdownExporter",
+    "config", "CloudNotesLibError"
+]

cloudnoteslib-0.1.0/cloudnoteslib/analyzers/__init__.py

@@ -0,0 +1,14 @@
+"""
+cloudnoteslib.analyzers — Content Analysis and Search.
+
+Exports:
+    ContentAnalyzer: Single-note content analysis.
+    NoteStatistics: Collection-level analytics.
+    SearchEngine: Multi-strategy search (Strategy Pattern).
+"""
+
+from .content_analyzer import ContentAnalyzer
+from .statistics import NoteStatistics
+from .search import SearchEngine
+
+__all__ = ["ContentAnalyzer", "NoteStatistics", "SearchEngine"]

cloudnoteslib-0.1.0/cloudnoteslib/analyzers/content_analyzer.py

@@ -0,0 +1,180 @@
+"""
+cloudnoteslib.analyzers.content_analyzer — Single-Note Content Analysis.
+
+Provides detailed analytics for individual notes including word frequency,
+readability metrics, and content classification.
+
+Example:
+    >>> analyzer = ContentAnalyzer()
+    >>> result = analyzer.analyze(note)
+    >>> result['word_count']
+    150
+    >>> result['reading_time']
+    0.8
+    >>> result['top_words']
+    [('project', 5), ('cloud', 3), ('deploy', 2)]
+"""
+
+import re
+from collections import Counter
+from typing import List, Dict
+from ..models.note import Note
+
+
+class ContentAnalyzer:
+    """
+    Performs detailed content analysis on a single Note.
+
+    Extracts metrics such as word frequency, sentence statistics,
+    readability indicators, and content structure information.
+    """
+
+    # Common English stop words to exclude from frequency analysis
+    STOP_WORDS = frozenset({
+        "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+        "have", "has", "had", "do", "does", "did", "will", "would", "could",
+        "should", "may", "might", "shall", "can", "need", "must", "ought",
+        "i", "me", "my", "we", "our", "you", "your", "he", "she", "it",
+        "they", "them", "their", "this", "that", "these", "those", "what",
+        "which", "who", "whom", "and", "but", "or", "nor", "not", "so",
+        "if", "then", "than", "too", "very", "just", "about", "above",
+        "after", "again", "all", "also", "any", "because", "before",
+        "between", "both", "by", "each", "for", "from", "get", "got",
+        "how", "in", "into", "its", "more", "most", "no", "of", "off",
+        "on", "only", "other", "out", "own", "same", "some", "such",
+        "to", "up", "with", "when", "where", "while",
+    })
+
+    def analyze(self, note: Note) -> dict:
+        """
+        Perform comprehensive content analysis on a single note.
+
+        Args:
+            note: Note object to analyze.
+
+        Returns:
+            Dictionary containing all analysis metrics.
+        """
+        content = note.content
+        words = self._extract_words(content)
+
+        return {
+            "title": note.title,
+            "word_count": len(words),
+            "char_count": note.char_count,
+            "sentence_count": note.sentence_count,
+            "paragraph_count": self._count_paragraphs(content),
+            "reading_time": note.reading_time,
+            "avg_word_length": self._avg_word_length(words),
+            "avg_sentence_length": self._avg_sentence_length(content, words),
+            "top_words": self._top_words(words, n=10),
+            "unique_word_count": len(set(words)),
+            "vocabulary_richness": self._vocabulary_richness(words),
+            "has_links": self._has_links(content),
+            "has_code": self._has_code(content),
+            "tags": note.tags,
+            "is_pinned": note.is_pinned,
+        }
+
+    def get_word_frequency(self, note: Note, top_n: int = 20) -> List[tuple]:
+        """
+        Get the most frequently used meaningful words.
+
+        Excludes stop words and short words to focus on content-bearing terms.
+
+        Args:
+            note: Note to analyze.
+            top_n: Number of top words to return.
+
+        Returns:
+            List of (word, count) tuples, sorted by frequency.
+        """
+        words = self._extract_words(note.content)
+        return self._top_words(words, n=top_n)
+
+    def get_readability_score(self, note: Note) -> dict:
+        """
+        Calculate readability metrics for the note.
+
+        Uses a simplified Flesch-Kincaid-inspired scoring based on
+        average sentence length and average word length.
+
+        Args:
+            note: Note to analyze.
+
+        Returns:
+            Dictionary with readability metrics and a difficulty level.
+        """
+        words = self._extract_words(note.content)
+        if not words:
+            return {"score": 0, "level": "empty", "avg_sentence_len": 0}
+
+        avg_sentence_len = self._avg_sentence_length(note.content, words)
+        avg_word_len = self._avg_word_length(words)
+
+        # Simplified readability: lower score = easier to read
+        score = round((avg_sentence_len * 0.39) + (avg_word_len * 11.8) - 15.59, 1)
+
+        if score < 30:
+            level = "very_easy"
+        elif score < 50:
+            level = "easy"
+        elif score < 60:
+            level = "moderate"
+        elif score < 70:
+            level = "somewhat_difficult"
+        else:
+            level = "difficult"
+
+        return {
+            "score": max(0, score),
+            "level": level,
+            "avg_sentence_length": avg_sentence_len,
+            "avg_word_length": avg_word_len,
+        }
+
+    # ─── Private Helper Methods ───
+
+    def _extract_words(self, content: str) -> List[str]:
+        """Extract individual words from content (lowercase, alphanumeric only)."""
+        return re.findall(r'[a-zA-Z]+', content.lower())
+
+    def _count_paragraphs(self, content: str) -> int:
+        """Count paragraphs (blocks separated by blank lines)."""
+        if not content.strip():
+            return 0
+        paragraphs = re.split(r'\n\s*\n', content.strip())
+        return len([p for p in paragraphs if p.strip()])
+
+    def _avg_word_length(self, words: List[str]) -> float:
+        """Average character length of words."""
+        if not words:
+            return 0.0
+        return round(sum(len(w) for w in words) / len(words), 1)
+
+    def _avg_sentence_length(self, content: str, words: List[str]) -> float:
+        """Average number of words per sentence."""
+        sentences = re.split(r'[.!?]+', content.strip())
+        sentence_count = len([s for s in sentences if s.strip()])
+        if sentence_count == 0:
+            return 0.0
+        return round(len(words) / sentence_count, 1)
+
+    def _top_words(self, words: List[str], n: int = 10) -> List[tuple]:
+        """Get top N most frequent non-stop-words."""
+        meaningful = [w for w in words if w not in self.STOP_WORDS and len(w) > 2]
+        return Counter(meaningful).most_common(n)
+
+    def _vocabulary_richness(self, words: List[str]) -> float:
+        """Ratio of unique words to total words (type-token ratio)."""
+        if not words:
+            return 0.0
+        return round(len(set(words)) / len(words), 3)
+
+    def _has_links(self, content: str) -> bool:
+        """Check if content contains URLs."""
+        return bool(re.search(r'https?://\S+', content))
+
+    def _has_code(self, content: str) -> bool:
+        """Check if content contains code blocks or inline code."""
+        return bool(re.search(r'```|`[^`]+`', content))

cloudnoteslib-0.1.0/cloudnoteslib/analyzers/search.py

@@ -0,0 +1,143 @@
+"""
+cloudnoteslib.analyzers.search — Search Engine (Strategy Pattern).
+
+Demonstrates the STRATEGY PATTERN:
+    SearchEngine uses a configured strategy (Exact, Fuzzy, or Regex)
+    to perform searches. The algorithm can be interchanged at runtime
+    without modifying the NoteCollection or the SearchEngine itself.
+
+Example:
+    >>> engine = SearchEngine(strategy="fuzzy")
+    >>> results = engine.search(collection, "prjct")
+"""
+
+import re
+from abc import ABC, abstractmethod
+from typing import List
+from ..models.note import Note
+from ..models.note_collection import NoteCollection
+
+
+# ─── Strategy Interface ───
+
+class SearchStrategy(ABC):
+    """Abstract interface for search algorithms."""
+    
+    @abstractmethod
+    def search(self, notes: List[Note], query: str) -> List[Note]:
+        pass
+
+
+# ─── Concrete Strategies ───
+
+class ExactMatchStrategy(SearchStrategy):
+    """Simple case-insensitive substring match."""
+    
+    def search(self, notes: List[Note], query: str) -> List[Note]:
+        q = query.strip().lower()
+        if not q:
+            return notes.copy()
+            
+        results = []
+        for note in notes:
+            if q in note.title.lower() or q in note.content.lower():
+                results.append(note)
+        return results
+
+
+class RegexStrategy(SearchStrategy):
+    """Advanced search using regular expressions."""
+    
+    def search(self, notes: List[Note], pattern: str) -> List[Note]:
+        if not pattern.strip():
+            return notes.copy()
+            
+        try:
+            regex = re.compile(pattern, re.IGNORECASE)
+        except re.error:
+            # Fallback to exact match if regex is invalid
+            return ExactMatchStrategy().search(notes, pattern)
+            
+        results = []
+        for note in notes:
+            if regex.search(note.title) or regex.search(note.content):
+                results.append(note)
+        return results
+
+
+class FuzzyStrategy(SearchStrategy):
+    """
+    Very basic fuzzy search.
+    Matches if all characters in query appear in the text in order.
+    (e.g., 'prt' matches 'project').
+    """
+    
+    def search(self, notes: List[Note], query: str) -> List[Note]:
+        q = query.strip().lower()
+        if not q:
+            return notes.copy()
+            
+        # Build regex pattern: p.*r.*t
+        escaped_chars = [re.escape(c) for c in q]
+        pattern = '.*'.join(escaped_chars)
+        
+        try:
+            regex = re.compile(pattern, re.IGNORECASE)
+        except re.error:
+            return ExactMatchStrategy().search(notes, query)
+            
+        results = []
+        for note in notes:
+            if regex.search(note.title) or regex.search(note.content):
+                results.append(note)
+        return results
+
+
+# ─── Context Class ───
+
+class SearchEngine:
+    """
+    Context class that executes searches using the configured Strategy.
+    """
+    
+    STRATEGIES = {
+        "exact": ExactMatchStrategy(),
+        "regex": RegexStrategy(),
+        "fuzzy": FuzzyStrategy(),
+    }
+    
+    def __init__(self, strategy: str = "exact"):
+        """
+        Initialize with a specific search strategy.
+        
+        Args:
+            strategy: 'exact', 'regex', or 'fuzzy'.
+        """
+        self.set_strategy(strategy)
+        
+    def set_strategy(self, strategy_name: str) -> None:
+        """Change internal strategy at runtime."""
+        normalized = strategy_name.strip().lower()
+        if normalized not in self.STRATEGIES:
+            raise ValueError(f"Unknown strategy: {strategy_name}. Choose from: {list(self.STRATEGIES.keys())}")
+        self._strategy = self.STRATEGIES[normalized]
+        self._current_strategy_name = normalized
+        
+    @property
+    def strategy_name(self) -> str:
+        return self._current_strategy_name
+        
+    def search(self, collection: NoteCollection, query: str) -> NoteCollection:
+        """
+        Execute search on a collection.
+        
+        Args:
+            collection: The NoteCollection to search.
+            query: The search string.
+            
+        Returns:
+            A new NoteCollection with the results.
+        """
+        notes_list = list(collection)
+        results = self._strategy.search(notes_list, query)
+        return NoteCollection(results)

cloudnoteslib-0.1.0/cloudnoteslib/analyzers/statistics.py

@@ -0,0 +1,88 @@
+"""
+cloudnoteslib.analyzers.statistics — Collection Statistics Analyzer.
+
+Analyzes a NoteCollection to produce aggregate statistics across
+multiple notes.
+
+Example:
+    >>> stats = NoteStatistics()
+    >>> summary = stats.get_summary(collection)
+    >>> summary['total_notes']
+    42
+    >>> len(summary['popular_tags'])
+    5
+"""
+
+from typing import List, Dict
+from ..models.note_collection import NoteCollection
+
+
+class NoteStatistics:
+    """
+    Computes aggregate analytics over a NoteCollection.
+    """
+
+    def get_summary(self, collection: NoteCollection) -> dict:
+        """
+        Produce a comprehensive statistical summary of the collection.
+
+        Args:
+            collection: NoteCollection to analyze.
+
+        Returns:
+            Dictionary with collection-level metrics.
+        """
+        if len(collection) == 0:
+            return self._empty_summary()
+
+        return {
+            "total_notes": len(collection),
+            "total_words": collection.total_words,
+            "total_reading_time": collection.total_reading_time,
+            "average_word_count": collection.average_word_count,
+
+            "pinned_count": len(collection.get_pinned()),
+            "archived_count": len(collection.get_archived()),
+            "active_count": len(collection.get_active()),
+
+            "total_tags": len(collection.all_tags),
+            "popular_tags": self._get_top_tags(collection, count=5),
+
+            "longest_note": self._note_summary(collection.longest_note),
+            "shortest_note": self._note_summary(collection.shortest_note),
+            "most_recent": self._note_summary(collection.most_recent),
+        }
+
+    def _get_top_tags(self, collection: NoteCollection, count: int = 5) -> List[dict]:
+        """Get the most frequently used tags with their counts."""
+        tag_counts = collection.tag_counts
+        top = list(tag_counts.items())[:count]
+        return [{"tag": t[0], "count": t[1]} for t in top]
+
+    def _note_summary(self, note) -> dict:
+        """Return a brief summary of a single note for stats."""
+        if not note:
+            return {}
+        return {
+            "id": note.note_id,
+            "title": note.title,
+            "word_count": note.word_count,
+            "created_at": note.created_at.isoformat() if note.created_at else None,
+        }
+
+    def _empty_summary(self) -> dict:
+        """Return zeroed summary for empty collections."""
+        return {
+            "total_notes": 0,
+            "total_words": 0,
+            "total_reading_time": 0.0,
+            "average_word_count": 0.0,
+            "pinned_count": 0,
+            "archived_count": 0,
+            "active_count": 0,
+            "total_tags": 0,
+            "popular_tags": [],
+            "longest_note": {},
+            "shortest_note": {},
+            "most_recent": {},
+        }

cloudnoteslib-0.1.0/cloudnoteslib/config.py

@@ -0,0 +1,28 @@
+"""
+cloudnoteslib.config — Note Configuration Singleton.
+
+Provides a global configuration point for the library.
+Demonstrates the SINGLETON pattern.
+"""
+
+class NoteConfig:
+    """
+    Singleton configuration manager for cloudnoteslib.
+    """
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(NoteConfig, cls).__new__(cls)
+            cls._instance._init_defaults()
+        return cls._instance
+        
+    def _init_defaults(self):
+        self.default_processor = "markdown"
+        self.max_note_size_mb = 5
+        self.default_search_strategy = "exact"
+        self.password_salt = b"cloudnotes_salt_123"
+
+# Create the singleton instance
+config = NoteConfig()

cloudnoteslib-0.1.0/cloudnoteslib/exceptions.py

@@ -0,0 +1,19 @@
+"""
+cloudnoteslib.exceptions — Custom Exceptions.
+"""
+
+class CloudNotesLibError(Exception):
+    """Base exception for cloudnoteslib."""
+    pass
+
+class NoteValidationError(CloudNotesLibError):
+    """Raised when note validation fails (e.g. title too long)."""
+    pass
+
+class ProcessorNotSupportedError(CloudNotesLibError):
+    """Raised when an unknown processor type is requested."""
+    pass
+
+class SecurityError(CloudNotesLibError):
+    """Raised for encryption/decryption or authorization failures."""
+    pass

cloudnoteslib-0.1.0/cloudnoteslib/exporters/__init__.py

@@ -0,0 +1,11 @@
+"""
+cloudnoteslib.exporters — Note Exporters.
+
+Provides mechanisms to export note collections into various formats.
+"""
+
+from .base import NoteExporter
+from .json_exporter import JSONExporter
+from .markdown_exporter import MarkdownExporter
+
+__all__ = ["NoteExporter", "JSONExporter", "MarkdownExporter"]