stackraise 0.1.0__py3-none-any.whl

stackraise/model/file.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import base64
+from datetime import datetime, timezone
+from mimetypes import guess_type
+from pathlib import Path
+from typing import Any, ClassVar, Optional, Self
+from webbrowser import get
+
+import stackraise.db as db
+from fastapi.responses import StreamingResponse
+from pydantic import Field
+
+from .core import Base
+
+# """
+# Implementacion de grid fs en stackraise.
+# """
+
+_GRIDFS_DEFAULT_CHUNK_SIZE = 256 * 1024  # Default chunk size of 256 KB
+
+
+class File(db.Document, collection="fs.files"):
+    __slots__ = ("_sync_content",)
+
+    length: int
+    chunk_size: int = _GRIDFS_DEFAULT_CHUNK_SIZE
+    filename: Optional[str] = None
+    content_type: Optional[str] = None
+    upload_date: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    metadata: Optional[dict[str, Any]] = None
+
+    # _sync_content: ClassVar[bytes | None] = None  # Cached content for sync operations
+    # _sync_modified: ClassVar[bool] = False  # Flag to track if content has been modified
+
+    # _content_cache: bytes
+
+    class Chunk(db.Document, collection="fs.chunks"):
+        file_id: File.Ref
+        n: int
+        data: bytes
+
+        @classmethod
+        def find_by_file_id(cls, file_id: db.Id):
+            """
+            Returns an async iterator over all chunks for the given file ID.
+            """
+            return cls.collection.find({"fileId": file_id}).sort("n")
+
+    @classmethod
+    def new(
+        cls,
+        content: bytes,
+        content_type: str,
+        filename: Optional[Path | str],
+        chunk_size: int = _GRIDFS_DEFAULT_CHUNK_SIZE,
+        **metadata: dict[str, str],
+    ) -> Self:
+        file = cls(
+            length=len(content),
+            chunk_size=chunk_size,
+            content_type=content_type,
+            filename=str(filename) if filename else None,
+            metadata=metadata,
+        )
+
+        setattr(file, "_sync_content", content)  # Cache the content for synchronous operations
+
+        return file
+
+    @classmethod
+    async def from_local_path(cls, path: Path | str) -> File:
+        """
+        Reads the file content from the given path and returns a File object.
+        """
+        with open(path, "rb") as f:
+            content = f.read()
+
+        content_type, encoding = guess_type(path)
+
+        return cls.new(
+            filename=Path(path).name,
+            content_type=content_type or "application/octet-stream",
+            content=content,
+        )
+
+    async def content(self) -> bytes:
+        """
+        Reads the file content from the database.
+        """
+        if content := getattr(self, "_sync_content", None):
+            return content
+
+        assert self.id is not None, "The file must be saved before reading."
+
+        # Fetch all chunks associated with this file
+        # chunks = [chunk.data async for chunk in self.Chunk.find_by_file_id(self.id)]
+
+        # # Combine all chunks into a single bytes object
+        # return b"".join(chunks)
+
+        cursor = self.Chunk.find_by_file_id(self.id)
+        chunk_docs = await cursor.as_list()
+        return b"".join(chunk.data for chunk in chunk_docs)
+
+    def as_stream(
+        self,
+        headers: Optional[dict[str, str]] = None,
+    ) -> StreamingResponse:
+        """
+        Returns a StreamingResponse for the file content.
+        This is useful for serving large files without loading them entirely into memory.
+        """
+        assert self.id is not None, "The file must be saved before streaming."
+
+        async def file_stream():
+            #chunks = await self.Chunk.find_by_file_id(self.id).sort("n").as_list()
+            chunks = await self.Chunk.find_by_file_id(self.id).as_list()
+            for chunk in chunks:
+                yield chunk.data
+
+        if headers is None:
+            headers = {"Content-Disposition": f'attachment; filename="{self.filename}"'}
+
+        return StreamingResponse(
+            file_stream(), media_type=self.content_type, headers=headers
+        )
+
+    async def __prepare_for_storage__(self):
+        # si tiene contenido cacheado,
+
+        if self.id is None and self._sync_content is None:
+            raise ValueError("Cannot create a file without content or id.")
+
+        if self.id is None:
+            self.id = db.Id.new()
+
+        if (content := getattr(self, "_sync_content", None)) is not None:
+            # Insert all chunks into the database
+            for n, data in _iter_chunked_content(content, self.chunk_size):
+                await self.Chunk(file_id=self.id, n=n, data=data).insert()
+
+    @classmethod
+    async def __handle_post_deletion__(cls, file_id: db.Id):
+        """
+        Delete all chunks associated with this file.
+        """
+        # Delete all chunks associated with this file
+        await cls.Chunk.collection._delete_many({"fileId": file_id})
+
+
+def _iter_chunked_content(content: bytes, chunk_size: int = _GRIDFS_DEFAULT_CHUNK_SIZE):
+    for n in range(0, len(content), chunk_size):
+        yield n, content[n : n + chunk_size]

stackraise/model/name_email.py

@@ -0,0 +1,45 @@
+from readline import insert_text
+from typing import Optional, Self
+from pydantic import validate_email, EmailStr
+from pydantic_core import core_schema
+from dataclasses import dataclass
+
+@dataclass
+class NameEmail:
+    email: EmailStr
+    name: Optional[str] = None
+
+    @classmethod
+    def from_str(cls, value: str) -> Self:
+        name, email = validate_email(value)
+        return cls(name=name, email=email)
+
+    def __str__(self):
+        if not self.name:
+            return self.email
+        return f"{self.name} <{self.email}>"
+
+
+    # @classmethod
+    # def __get_pydantic_core_schema__(cls, filter_alias, handler):
+
+    #     def validate(val: str | dict | NameEmail) -> NameEmail:
+            
+    #         if isinstance(val, str):
+    #             return NameEmail.from_string(val)
+            
+    #         if isinstance(val, dict):
+    #             return cls(name=val.get("name", None), email=EmailStr(val.get("email")))
+
+    #         return val
+
+    #     def serialize(name_email: NameEmail) -> str:
+    #         return str(name_email)
+
+    #     schema = core_schema.json_or_python_schema(
+    #         json_schema=core_schema.no_info_plain_validator_function(validate),
+    #         python_schema=core_schema.no_info_plain_validator_function(validate),
+    #         serialization=core_schema.plain_serializer_function_ser_schema(serialize),
+    #     )
+
+    #     return schema

stackraise/model/query_filters.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import re
+from datetime import date
+from enum import Enum
+from functools import cache
+from typing import Annotated, Optional, Self, get_args
+
+
+from fastapi import Query
+from pydantic import TypeAdapter, create_model
+from pydantic.fields import FieldInfo
+from pydantic_core import core_schema
+
+import stackraise.model as model
+
+_QUERY_FILTER_RE = re.compile(r"(?P<op>\w+):(?P<val>.*)")
+
+
+class QueryFilter[T]:
+
+    class Operator(str, Enum):
+        EQ = "eq"
+        NE = "neq"
+        LT = "lt"
+        LTE = "lte"
+        GT = "gt"
+        GTE = "gte"
+        IN = "in"
+        LIKE = "like"
+        ILIKE = "ilike"
+
+    @classmethod
+    def eq(cls, value: T) -> "QueryFilter[T]":
+        return cls(cls.Operator.EQ, value)
+    
+    @classmethod
+    def neq(cls, value: T) -> "QueryFilter[T]":
+        return cls(cls.Operator.NE, value)
+    
+    @classmethod
+    def lt(cls, value: T) -> "QueryFilter[T]":
+        return cls(cls.Operator.LT, value)
+    
+    @classmethod
+    def lte(cls, value: T) -> "QueryFilter[T]":
+        return cls(cls.Operator.LTE, value)
+    
+    @classmethod
+    def gt(cls, value: T) -> "QueryFilter[T]":
+        return cls(cls.Operator.GT, value)
+
+    @classmethod
+    def gte(cls, value: T) -> "QueryFilter[T]":
+        return cls(cls.Operator.GTE, value)
+    
+    @classmethod
+    def in_(cls, value: list[T]) -> "QueryFilter[list[T]]":
+        return cls(cls.Operator.IN, value)
+    
+    @classmethod
+    def like(cls, value: str) -> "QueryFilter[str]":
+        return cls(cls.Operator.LIKE, value)
+
+    operator: Operator
+    value: Optional[T | list[T]]
+
+    def __init__(self, operator: Operator, value: T | list[T]):
+        self.operator = operator
+        self.value = value
+
+    def to_mongo_query_operator(self, annotation: type):
+        type_args = get_args(annotation)
+        bson = model.TypeAdapter(type_args[0]).dump_python(self.value)
+        return _MONGO_QUERY_OPERATOR_MAP[self.operator](bson)
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, filter_alias, handler):
+        filter_args = get_args(filter_alias)
+        if len(filter_args) != 1:
+            raise ValueError(
+                f"QueryFilter '{filter_alias}' must have exactly one type argument, got {len(filter_args)}"
+            )
+        
+        inner_type = filter_args[0]
+
+
+        single_type_adapter = model.TypeAdapter(inner_type)
+        list_type_adapter = model.TypeAdapter(list[inner_type])
+
+        def validate(val: str | QueryFilter | None) -> Optional[QueryFilter]:
+            if isinstance(val, QueryFilter):
+                return val
+
+            # Manejar valores None o vacíos
+            if val is None:
+                return None
+            
+            # Convertir a string si no lo es
+            if not isinstance(val, str):
+                val = str(val)
+
+            val = val.strip()
+            
+            # Manejar strings vacíos
+            if val == "":
+                return None
+
+            m = _QUERY_FILTER_RE.match(val)
+            if not m:
+                raise ValueError(f"Invalid filter string: {val}")
+
+            op = QueryFilter.Operator(m.group("op"))
+            val = m.group("val")
+
+            if val == "":
+                val = None
+            elif op == QueryFilter.Operator.IN:
+                val = val.split(",")
+                val = list_type_adapter.validate_python(val)  ## Is fine??
+            # TODO: like filter restringido a str
+            else:
+                val = single_type_adapter.validate_strings(val)
+
+            return cls(operator=op, value=val)
+
+        def serialize(filter: QueryFilter) -> str:
+            if filter.value is None:
+                val = ""
+            elif filter.operator == QueryFilter.Operator.IN:
+                val = list_type_adapter.serialize(filter.value)
+            else:
+                val = single_type_adapter.serialize(filter.value)
+
+            return f"{filter.operator.value}:{val}"
+
+        schema = core_schema.json_or_python_schema(
+            json_schema=core_schema.no_info_plain_validator_function(validate),
+            python_schema=core_schema.no_info_plain_validator_function(validate),
+            serialization=core_schema.plain_serializer_function_ser_schema(serialize),
+        )
+
+        return schema
+
+    @classmethod
+    def __get_pydantic_json_schema__(cls, _, handler):
+        return handler(core_schema.str_schema())
+
+    # __pydantic_serializer__ = SchemaSerializer(core_schema.json_schema({"type": "string"}))
+
+
+_MONGO_QUERY_OPERATOR_MAP = {
+    QueryFilter.Operator.EQ: lambda v: {"$eq": v},
+    QueryFilter.Operator.NE: lambda v: {"$ne": v},
+    QueryFilter.Operator.LT: lambda v: {"$lt": v},
+    QueryFilter.Operator.LTE: lambda v: {"$lte": v},
+    QueryFilter.Operator.GT: lambda v: {"$gt": v},
+    QueryFilter.Operator.GTE: lambda v: {"$gte": v},
+    QueryFilter.Operator.IN: lambda v: {"$in": v if isinstance(v, list) else [v]},
+    QueryFilter.Operator.LIKE: lambda v: { '$regex': v },
+    QueryFilter.Operator.ILIKE: lambda v: { '$regex': v, '$options': 'i' },
+}
+
+
+class QueryFilters(model.Base):
+
+    qs_: Annotated[Optional[str], model.Field(alias='qs')] = None
+
+     
+    @classmethod
+    @cache
+    def for_model(cls, model_class: type[model.Base]) -> type[QueryFilters]:
+        # TODO: support for GenericAlias
+
+        def query_filter_of_field(field_info: FieldInfo):
+
+            return Annotated[
+                QueryFilter[field_info.annotation],
+                Query(
+                    None,
+                    alias=field_info.alias,
+                    description=f"Filter for {field_info.alias} property with {field_info.annotation} type",
+                ),
+            ]
+
+        fields = {nm: query_filter_of_field(fi) for nm, fi in model_class.model_fields.items()}
+
+        model_class = create_model(
+            f"QueryFilters",
+            __base__=QueryFilters,
+            __module__=model_class.__module__,
+            **fields,
+        )
+
+        model_class.__qualname__ = f"{model_class.__qualname__}.QueryFilters"
+
+        return model_class
+
+
+    def to_mongo_query(self, *, prefix: list[str] = []):
+        def mk_field_name(field: FieldInfo, field_name):
+            return ".".join(prefix + [field.alias or field_name])
+
+        where =  [{
+            mk_field_name(field, field_name): query_filter.to_mongo_query_operator(field.annotation)
+            for field_name, field in type(self).model_fields.items()
+            if (query_filter := getattr(self, field_name, None)) and isinstance(query_filter, QueryFilter)
+        }]
+
+        if self.qs_ is not None:
+            
+            where.append({'$or': [
+                { mk_field_name(field, field_name): { '$regex': f'^{self.qs_}', '$options': 'i' }} 
+                for field_name, field in type(self).model_fields.items()
+                if field.annotation == QueryFilter[str]
+            ]})
+
+            # TEXT SEARCH
+            # search['$or'].append({ '$text': { '$search': self.qs_,  '$caseSensitive': False, }})
+
+        return {'$and': where}
+    
+
+if __name__ == "__main__":
+    # from stackraise.persistence.id import Id
+    ta = TypeAdapter(QueryFilter[date])
+    filter = TypeAdapter(QueryFilter[float]).validate_python("lte:.45")
+    print(filter.to_mongo_query)
+
+    class MyModel(model.Base):
+        name: Annotated[str, model.Field(alias="n")]