mongo-pipebuilder 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

mongo_pipebuilder/__init__.py

@@ -9,6 +9,6 @@ Author: seligoroff
 
 from mongo_pipebuilder.builder import PipelineBuilder
 
-__version__ = "0.2.2"
+__version__ = "0.3.0"
 __all__ = ["PipelineBuilder"]
 

mongo_pipebuilder/builder.py

@@ -6,6 +6,8 @@ Builder Pattern implementation for safe construction of MongoDB aggregation pipe
 
 Author: seligoroff
 """
+import json
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
 # For compatibility with Python < 3.11
@@ -33,8 +35,7 @@ class PipelineBuilder:
             Self for method chaining
             
         Raises:
-            TypeError: If conditions is not a dictionary
-            ValueError: If conditions is None
+            TypeError: If conditions is None or not a dictionary
             
         Example:
             >>> builder.match({"status": "active", "age": {"$gte": 18}})
@@ -636,23 +637,15 @@ class PipelineBuilder:
                 "Only one output stage is allowed."
             )
         
-        # If $out exists, it must be the last stage
-        if has_out:
-            out_index = stage_types.index("$out")
-            if out_index != len(stage_types) - 1:
-                raise ValueError(
-                    f"$out stage must be the last stage in the pipeline. "
-                    f"Found at position {out_index + 1} of {len(stage_types)}."
-                )
-        
-        # If $merge exists, it must be the last stage
-        if has_merge:
-            merge_index = stage_types.index("$merge")
-            if merge_index != len(stage_types) - 1:
-                raise ValueError(
-                    f"$merge stage must be the last stage in the pipeline. "
-                    f"Found at position {merge_index + 1} of {len(stage_types)}."
-                )
+        # Check if $out or $merge exist and validate position
+        for stage_name in ["$out", "$merge"]:
+            if stage_name in stage_types:
+                stage_index = stage_types.index(stage_name)
+                if stage_index != len(stage_types) - 1:
+                    raise ValueError(
+                        f"{stage_name} stage must be the last stage in the pipeline. "
+                        f"Found at position {stage_index + 1} of {len(stage_types)}."
+                    )
         
         return True
 
@@ -669,7 +662,7 @@ class PipelineBuilder:
             >>> builder.get_stage_types()
             ['$match', '$limit']
         """
-        return [list(stage.keys())[0] for stage in self._stages]
+        return [next(iter(stage)) for stage in self._stages]
 
     def has_stage(self, stage_type: str) -> bool:
         """
@@ -762,6 +755,106 @@ class PipelineBuilder:
         self._stages.insert(position, stage)
         return self
 
+    def get_stage_at(self, index: int) -> Dict[str, Any]:
+        """
+        Get a specific stage from the pipeline by index.
+        
+        Args:
+            index: Zero-based index of the stage to retrieve
+            
+        Returns:
+            Dictionary representing the stage at the given index
+            
+        Raises:
+            IndexError: If index is out of range
+            
+        Example:
+            >>> builder = PipelineBuilder()
+            >>> builder.match({"status": "active"}).limit(10)
+            >>> stage = builder.get_stage_at(0)
+            >>> stage
+            {"$match": {"status": "active"}}
+        """
+        if index < 0 or index >= len(self._stages):
+            raise IndexError(
+                f"Index {index} out of range [0, {len(self._stages)}]"
+            )
+        return self._stages[index].copy()
+
+    def pretty_print(self, indent: int = 2, ensure_ascii: bool = False) -> str:
+        """
+        Return a formatted JSON string representation of the pipeline.
+        
+        Useful for debugging and understanding pipeline structure.
+        
+        Args:
+            indent: Number of spaces for indentation (default: 2)
+            ensure_ascii: If False, non-ASCII characters are output as-is (default: False)
+            
+        Returns:
+            Formatted JSON string of the pipeline
+            
+        Example:
+            >>> builder = PipelineBuilder()
+            >>> builder.match({"status": "active"}).limit(10)
+            >>> print(builder.pretty_print())
+            [
+              {
+                "$match": {
+                  "status": "active"
+                }
+              },
+              {
+                "$limit": 10
+              }
+            ]
+        """
+        return json.dumps(self._stages, indent=indent, ensure_ascii=ensure_ascii)
+
+    def to_json_file(
+        self,
+        filepath: Union[str, Path],
+        indent: int = 2,
+        ensure_ascii: bool = False,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Save the pipeline to a JSON file.
+        
+        Useful for debugging, comparison with other pipelines, or versioning.
+        
+        Args:
+            filepath: Path to the output JSON file (str or Path)
+            indent: Number of spaces for indentation (default: 2)
+            ensure_ascii: If False, non-ASCII characters are output as-is (default: False)
+            metadata: Optional metadata to include in the JSON file
+            
+        Raises:
+            IOError: If file cannot be written
+            
+        Example:
+            >>> builder = PipelineBuilder()
+            >>> builder.match({"status": "active"}).limit(10)
+            >>> builder.to_json_file("debug_pipeline.json")
+            
+            >>> # With metadata
+            >>> builder.to_json_file(
+            ...     "pipeline.json",
+            ...     metadata={"version": "1.0", "author": "developer"}
+            ... )
+        """
+        filepath = Path(filepath)
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        
+        output: Dict[str, Any] = {
+            "pipeline": self._stages,
+        }
+        if metadata:
+            output["metadata"] = metadata
+        
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(output, f, indent=indent, ensure_ascii=ensure_ascii)
+
     def build(self) -> List[Dict[str, Any]]:
         """
         Return the completed pipeline.

{mongo_pipebuilder-0.2.2.dist-info → mongo_pipebuilder-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mongo-pipebuilder
-Version: 0.2.2
+Version: 0.3.0
 Summary: Type-safe, fluent MongoDB aggregation pipeline builder
 Author-email: seligoroff <seligoroff@gmail.com>
 License: MIT
@@ -28,6 +28,12 @@ Dynamic: license-file
 
 # mongo-pipebuilder
 
+[![PyPI version](https://badge.fury.io/py/mongo-pipebuilder.svg)](https://badge.fury.io/py/mongo-pipebuilder)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Test Coverage](https://img.shields.io/badge/coverage-96%25-green.svg)](https://github.com/seligoroff/mongo-pipebuilder)
+
 Type-safe, fluent MongoDB aggregation pipeline builder for Python.
 
 ## Overview
@@ -36,11 +42,11 @@ Type-safe, fluent MongoDB aggregation pipeline builder for Python.
 
 ## Features
 
-- ✅ **Type-safe**: Full type hints support with IDE autocomplete
-- ✅ **Fluent interface**: Chain methods for readable, maintainable code
-- ✅ **Zero dependencies**: Pure Python, lightweight package
-- ✅ **Extensible**: Easy to add custom stages via `add_stage()`
-- ✅ **Well tested**: Comprehensive test suite with 96%+ coverage
+- **Type-safe**: Full type hints support with IDE autocomplete
+- **Fluent interface**: Chain methods for readable, maintainable code
+- **Zero dependencies**: Pure Python, lightweight package
+- **Extensible**: Easy to add custom stages via `add_stage()`
+- **Well tested**: Comprehensive test suite with 96%+ coverage
 
 ## Installation
 
@@ -259,6 +265,22 @@ group_index = stage_types.index("$group")
 builder.insert_at(group_index, {"$addFields": {"x": 1}})
 ```
 
+##### `copy() -> PipelineBuilder`
+
+Creates an independent copy of the builder with current stages. Useful for creating immutable variants and composing pipelines.
+
+```python
+builder1 = PipelineBuilder().match({"status": "active"})
+builder2 = builder1.copy()
+builder2.limit(10)
+
+# Original unchanged
+assert len(builder1) == 1
+assert len(builder2) == 2
+```
+
+See [Composing and Reusing Pipelines](#composing-and-reusing-pipelines) for practical examples.
+
 ##### `validate() -> bool`
 
 Validates the pipeline before execution. Checks that:
@@ -275,6 +297,54 @@ builder.add_stage({"$out": "output"}).match({"status": "active"})
 builder.validate()  # Raises ValueError: $out stage must be the last stage
 ```
 
+##### `get_stage_at(index: int) -> Dict[str, Any]`
+
+Gets a specific stage from the pipeline by index. Returns a copy of the stage.
+
+```python
+builder = PipelineBuilder()
+builder.match({"status": "active"}).limit(10)
+stage = builder.get_stage_at(0)  # Returns {"$match": {"status": "active"}}
+```
+
+##### `pretty_print(indent: int = 2, ensure_ascii: bool = False) -> str`
+
+Returns a formatted JSON string representation of the pipeline. Useful for debugging.
+
+```python
+builder = PipelineBuilder()
+builder.match({"status": "active"}).limit(10)
+print(builder.pretty_print())
+# [
+#   {
+#     "$match": {
+#       "status": "active"
+#     }
+#   },
+#   {
+#     "$limit": 10
+#   }
+# ]
+```
+
+##### `to_json_file(filepath: Union[str, Path], indent: int = 2, ensure_ascii: bool = False, metadata: Optional[Dict[str, Any]] = None) -> None`
+
+Saves the pipeline to a JSON file. Useful for debugging, comparison, or versioning.
+
+```python
+builder = PipelineBuilder()
+builder.match({"status": "active"}).limit(10)
+
+# Basic usage
+builder.to_json_file("debug_pipeline.json")
+
+# With metadata
+builder.to_json_file(
+    "pipeline.json",
+    metadata={"version": "1.0", "author": "developer"}
+)
+```
+
 ##### `build() -> List[Dict[str, Any]]`
 
 Returns the complete pipeline as a list of stage dictionaries.
@@ -340,6 +410,150 @@ pipeline = (
 )
 ```
 
+### Composing and Reusing Pipelines
+
+The `copy()` method allows you to create immutable variants of pipelines, enabling safe composition and reuse. This is useful when you need to:
+- Create multiple variants from a base pipeline
+- Compose pipelines functionally
+- Cache base pipelines safely
+- Pass pipelines to functions without side effects
+
+#### Example: Building Multiple Variants from a Base Pipeline
+
+```python
+from mongo_pipebuilder import PipelineBuilder
+
+# Base pipeline with common filtering and joining
+base_pipeline = (
+    PipelineBuilder()
+    .match({"status": "published", "deleted": False})
+    .lookup(
+        from_collection="authors",
+        local_field="authorId",
+        foreign_field="_id",
+        as_field="author"
+    )
+    .unwind("author", preserve_null_and_empty_arrays=True)
+    .project({
+        "title": 1,
+        "authorName": "$author.name",
+        "publishedAt": 1
+    })
+)
+
+# Create variants with different sorting and limits
+recent_posts = base_pipeline.copy().sort({"publishedAt": -1}).limit(10).build()
+popular_posts = base_pipeline.copy().sort({"views": -1}).limit(5).build()
+author_posts = base_pipeline.copy().match({"authorName": "John Doe"}).build()
+
+# Base pipeline remains unchanged
+assert len(base_pipeline) == 4  # Still has 4 stages
+```
+
+#### Example: Functional Composition Pattern
+
+```python
+def add_pagination(builder, page: int, page_size: int = 10):
+    """Add pagination to a pipeline."""
+    return builder.copy().skip(page * page_size).limit(page_size)
+
+def add_sorting(builder, sort_field: str, ascending: bool = True):
+    """Add sorting to a pipeline."""
+    return builder.copy().sort({sort_field: 1 if ascending else -1})
+
+# Compose pipelines functionally
+base = PipelineBuilder().match({"status": "active"})
+
+# Create different variants
+page1 = add_pagination(add_sorting(base, "createdAt"), page=0)
+page2 = add_pagination(add_sorting(base, "createdAt"), page=1)
+sorted_by_name = add_sorting(base, "name", ascending=True)
+
+# All variants are independent
+assert len(base) == 1  # Base unchanged
+assert len(page1) == 3  # match + sort + skip + limit
+```
+
+#### Example: Caching Base Pipelines
+
+```python
+from functools import lru_cache
+
+@lru_cache(maxsize=100)
+def get_base_pipeline(user_id: str):
+    """Cache base pipeline for a user."""
+    return (
+        PipelineBuilder()
+        .match({"userId": user_id, "status": "active"})
+        .lookup(
+            from_collection="profiles",
+            local_field="userId",
+            foreign_field="_id",
+            as_field="profile"
+        )
+    )
+
+# Reuse cached base pipeline with different modifications
+user_id = "12345"
+base = get_base_pipeline(user_id)
+
+# Create multiple queries from cached base
+recent = base.copy().sort({"createdAt": -1}).limit(10).build()
+by_category = base.copy().match({"category": "tech"}).build()
+with_stats = base.copy().group({"_id": "$category"}, {"count": {"$sum": 1}}).build()
+
+# Base pipeline is safely cached and reused
+```
+
+#### Example: Pipeline Factories
+
+```python
+class PipelineFactory:
+    """Factory for creating common pipeline patterns."""
+    
+    @staticmethod
+    def base_article_pipeline():
+        """Base pipeline for articles."""
+        return (
+            PipelineBuilder()
+            .match({"status": "published"})
+            .lookup(
+                from_collection="authors",
+                local_field="authorId",
+                foreign_field="_id",
+                as_field="author"
+            )
+        )
+    
+    @staticmethod
+    def with_author_filter(builder, author_name: str):
+        """Add author filter to pipeline."""
+        return builder.copy().match({"author.name": author_name})
+    
+    @staticmethod
+    def with_date_range(builder, start_date: str, end_date: str):
+        """Add date range filter to pipeline."""
+        return builder.copy().match({
+            "publishedAt": {"$gte": start_date, "$lte": end_date}
+        })
+
+# Usage
+base = PipelineFactory.base_article_pipeline()
+johns_articles = PipelineFactory.with_author_filter(base, "John Doe")
+recent_johns = PipelineFactory.with_date_range(
+    johns_articles, 
+    start_date="2024-01-01",
+    end_date="2024-12-31"
+).sort({"publishedAt": -1}).limit(10).build()
+```
+
+**Key Benefits:**
+- Safe reuse: Base pipelines remain unchanged
+- Functional composition: Build pipelines from smaller parts
+- Caching friendly: Base pipelines can be safely cached
+- No side effects: Functions can safely modify copies
+- Thread-safe: Multiple threads can use copies independently
+
 ## Development
 
 ### Project Structure
@@ -374,3 +588,18 @@ See [DEVELOPMENT.md](DEVELOPMENT.md) for development guidelines.
 MIT License - see [LICENSE](LICENSE) file for details.
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

mongo_pipebuilder-0.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+mongo_pipebuilder/__init__.py,sha256=pP27GA8G6dttP-gMq9uNCJoS66-cb3JJiVVdI340er4,336
+mongo_pipebuilder/builder.py,sha256=oQxRYL9ycjYCv2ErP_YHz-Uoo2pPRaRBaaaCLEsL5Mo,30286
+mongo_pipebuilder-0.3.0.dist-info/licenses/LICENSE,sha256=-ZkZpDLHDQAc-YBIojJ6eDsMwxwx5pRuQz3RHnl9Y8w,1104
+mongo_pipebuilder-0.3.0.dist-info/METADATA,sha256=KkgWrj5TD22yDj915Jrri_JftYMEpTz6hXSeHKEM7mk,15850
+mongo_pipebuilder-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mongo_pipebuilder-0.3.0.dist-info/top_level.txt,sha256=wLn7H_v-qaNIws5FeBbKPZBCmYFYgFEhPaLjoCWcisc,18
+mongo_pipebuilder-0.3.0.dist-info/RECORD,,

{mongo_pipebuilder-0.2.2.dist-info → mongo_pipebuilder-0.3.0.dist-info}/licenses/LICENSE

@@ -21,3 +21,18 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

mongo_pipebuilder-0.2.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-mongo_pipebuilder/__init__.py,sha256=VF9G-Gp0kabZMoEmeQnSnSqHT3hLqxlEHY-FBeXfnVA,336
-mongo_pipebuilder/builder.py,sha256=qvyQd1k9YbaIV0tRixQnsNr7yuE-_SSGN5tBSwDAk5E,27199
-mongo_pipebuilder-0.2.2.dist-info/licenses/LICENSE,sha256=xAHmf48PmIziXYIdaJzRYeYpXFUPIb70SsSPhAHdggY,1089
-mongo_pipebuilder-0.2.2.dist-info/METADATA,sha256=QZJAl4akVEiT9ucIaviwAwJuvTWFL9XyBEyKb_LI6jc,9127
-mongo_pipebuilder-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mongo_pipebuilder-0.2.2.dist-info/top_level.txt,sha256=wLn7H_v-qaNIws5FeBbKPZBCmYFYgFEhPaLjoCWcisc,18
-mongo_pipebuilder-0.2.2.dist-info/RECORD,,