moontraze 1.0.0__tar.gz

moontraze-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Moontraze
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

moontraze-1.0.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: moontraze
+Version: 1.0.0
+Summary: Official Moontraze SDK — Auth, Database, Storage, Notifications
+Author-email: Moontraze <faisalrizwan0077@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://moontraze.com
+Project-URL: Repository, https://github.com/moontraze/sdk-python
+Project-URL: Documentation, https://docs.moontraze.com
+Keywords: moontraze,backend,auth,database,storage,notifications,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: urllib3>=1.26.0
+Provides-Extra: async
+Requires-Dist: aiohttp>=3.8.0; extra == "async"
+Dynamic: license-file
+
+# moontraze
+
+Official Moontraze Python SDK — Auth, Database, Storage, and Push Notifications.
+
+## Installation
+
+```bash
+pip install moontraze

moontraze-1.0.0/README.md

@@ -0,0 +1,8 @@
+# moontraze
+
+Official Moontraze Python SDK — Auth, Database, Storage, and Push Notifications.
+
+## Installation
+
+```bash
+pip install moontraze

moontraze-1.0.0/moontraze/__init__.py

@@ -0,0 +1,43 @@
+"""
+Moontraze SDK
+Official Python SDK for Moontraze — Auth, Database, Storage, Notifications
+"""
+
+from .client import MoonClient, MoonError, MoonConfig
+from .auth import MoonAuth
+from .database import MoonDatabase
+from .storage import MoonStorage
+from .notifications import MoonNotifications
+
+__version__ = "1.0.0"
+__author__ = "Moontraze"
+
+
+class MoonSDK:
+    """Main Moontraze SDK client"""
+    
+    def __init__(self, config: MoonConfig):
+        self.config = config
+        self.auth = MoonAuth(config)
+        self.db = MoonDatabase(config)
+        self.storage = MoonStorage(config)
+        self.notifications = MoonNotifications(config)
+    
+    def set_token(self, token: str | None):
+        """Set auth token for subsequent requests"""
+        self.auth.set_token(token)
+        self.db.set_token(token)
+        self.storage.set_token(token)
+        self.notifications.set_token(token)
+
+
+__all__ = [
+    "MoonSDK",
+    "MoonClient",
+    "MoonError",
+    "MoonConfig",
+    "MoonAuth",
+    "MoonDatabase",
+    "MoonStorage",
+    "MoonNotifications",
+]

moontraze-1.0.0/moontraze/auth.py

@@ -0,0 +1,111 @@
+"""Authentication module"""
+from typing import Optional, Dict, Any
+from .client import MoonClient, MoonConfig
+
+
+class MoonAuth(MoonClient):
+    """Authentication"""
+    
+    def __init__(self, config: MoonConfig):
+        super().__init__(config)
+    
+    def register(
+        self,
+        email: str,
+        password: str,
+        name: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Register a new user"""
+        data = self.request("POST", "/api/auth", {
+            "action": "register",
+            "email": email,
+            "password": password,
+            "name": name or email.split("@")[0],
+        })
+        
+        if data.get("token"):
+            self.set_token(data["token"])
+        
+        return data
+    
+    def login(self, email: str, password: str) -> Dict[str, Any]:
+        """Login a user"""
+        data = self.request("POST", "/api/auth", {
+            "action": "login",
+            "email": email,
+            "password": password,
+        })
+        
+        # Check if TOTP required
+        if data.get("requiresTotp"):
+            return data
+        
+        if data.get("token"):
+            self.set_token(data["token"])
+        
+        return data
+    
+    def verify_totp(self, login_ticket: str, code: str) -> Dict[str, Any]:
+        """Verify TOTP code after login"""
+        data = self.request("POST", "/api/auth", {
+            "action": "login-verify",
+            "loginTicket": login_ticket,
+            "code": code,
+        })
+        
+        if data.get("token"):
+            self.set_token(data["token"])
+        
+        return data
+    
+    def logout(self):
+        """Logout current user"""
+        self.set_token(None)
+    
+    def change_password(
+        self,
+        current_password: str,
+        new_password: str,
+    ) -> Dict[str, Any]:
+        """Change password (logged in)"""
+        return self.request("POST", "/api/auth", {
+            "action": "change-password",
+            "currentPassword": current_password,
+            "newPassword": new_password,
+        })
+    
+    def enroll_totp(self) -> Dict[str, Any]:
+        """Enroll MON Authenticator (get QR)"""
+        return self.request("POST", "/api/authenticator/enroll", {})
+    
+    def confirm_totp(self, code: str) -> Dict[str, Any]:
+        """Confirm MON Authenticator enrollment"""
+        return self.request("POST", "/api/authenticator/confirm", {
+            "code": code,
+        })
+    
+    def forgot_password_verify(
+        self,
+        email: str,
+        code: str,
+    ) -> Dict[str, Any]:
+        """Forgot password — step 1 (verify TOTP)"""
+        return self.request("POST", "/api/authenticator/verify", {
+            "email": email,
+            "code": code,
+            "projectId": self.config.project_id,
+        })
+    
+    def forgot_password_reset(
+        self,
+        email: str,
+        verify_token: str,
+        new_password: str,
+    ) -> Dict[str, Any]:
+        """Forgot password — step 2 (reset)"""
+        return self.request("POST", "/api/auth", {
+            "action": "reset-password",
+            "email": email,
+            "verifyToken": verify_token,
+            "newPassword": new_password,
+        })

moontraze-1.0.0/moontraze/client.py

@@ -0,0 +1,114 @@
+"""Base HTTP client"""
+import requests
+from typing import Optional, Dict, Any, Union
+
+
+class MoonError(Exception):
+    """Moontraze SDK Error"""
+    
+    def __init__(self, message: str, status: int = 0, code: Optional[str] = None):
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+    
+    def __repr__(self):
+        return f"MoonError(status={self.status}, code={self.code}, message={self.message})"
+
+
+class MoonConfig:
+    """Moontraze SDK configuration"""
+    
+    def __init__(
+        self,
+        project_id: str,
+        api_key: str,
+        base_url: str = "https://api.moontraze.com",
+        token: Optional[str] = None,
+        timeout: int = 60,
+    ):
+        self.project_id = project_id
+        self.api_key = api_key
+        self.base_url = base_url
+        self.token = token
+        self.timeout = timeout
+
+
+class MoonClient:
+    """Base client for Moontraze SDK"""
+    
+    def __init__(self, config: MoonConfig):
+        self.config = config
+        self.token = config.token
+        self.session = requests.Session()
+    
+    def set_token(self, token: Optional[str]):
+        """Set auth token"""
+        self.token = token
+    
+    def get_token(self) -> Optional[str]:
+        """Get current token"""
+        return self.token
+    
+    def _headers(self, extra: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        """Build request headers"""
+        headers = {
+            "Content-Type": "application/json",
+            "X-Project-Id": self.config.project_id,
+            "X-API-Key": self.config.api_key,
+        }
+        
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        
+        if extra:
+            headers.update(extra)
+        
+        return headers
+    
+    def request(
+        self,
+        method: str,
+        path: str,
+        body: Optional[Any] = None,
+        params: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict] = None,
+        data: Optional[Dict] = None,
+    ) -> Any:
+        """Make HTTP request"""
+        url = f"{self.config.base_url}{path}"
+        
+        headers = self._headers()
+        if files:
+            # Remove Content-Type for multipart (requests handles it)
+            headers.pop("Content-Type", None)
+        
+        try:
+            response = self.session.request(
+                method=method,
+                url=url,
+                json=body if not (files or data) else None,
+                data=data,
+                files=files,
+                params=params,
+                headers=headers,
+                timeout=self.config.timeout,
+            )
+            
+            data_resp = response.json()
+            
+            if not response.ok:
+                raise MoonError(
+                    data_resp.get("error", "Request failed"),
+                    response.status_code,
+                    data_resp.get("code"),
+                )
+            
+            return data_resp
+        
+        except requests.exceptions.Timeout:
+            raise MoonError("Request timeout", 408, "TIMEOUT")
+        except requests.exceptions.ConnectionError:
+            raise MoonError("Connection error", 0, "CONNECTION_ERROR")
+        except requests.exceptions.RequestException as e:
+            raise MoonError(f"Request failed: {str(e)}", 0, "REQUEST_ERROR")

moontraze-1.0.0/moontraze/database.py

@@ -0,0 +1,70 @@
+"""Database module"""
+from typing import Optional, Dict, Any, List
+from .client import MoonClient, MoonConfig
+
+
+class MoonDatabase(MoonClient):
+    """Database operations"""
+    
+    def __init__(self, config: MoonConfig):
+        super().__init__(config)
+    
+    def get(self, path: str) -> Dict[str, Any]:
+        """Get document(s) at path"""
+        return self.request("GET", "/api/db", params={"collection": path})
+    
+    def get_field(self, path: str, field: str) -> Any:
+        """Get specific field"""
+        return self.request("GET", "/api/db", params={
+            "collection": f"{path}/{field}",
+        })
+    
+    def set(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create or update document"""
+        return self.request("POST", "/api/db", {
+            "collection": path,
+            "data": data,
+        })
+    
+    def update_field(
+        self,
+        path: str,
+        field: str,
+        value: Any,
+        type: str = "string",
+    ) -> Dict[str, Any]:
+        """Update single field"""
+        return self.request("PUT", "/api/db", 
+            body={
+                "oldKey": field,
+                "newKey": field,
+                "value": value,
+                "type": type,
+            },
+            params={"collection": path},
+        )
+    
+    def update_fields(
+        self,
+        path: str,
+        fields: Dict[str, Dict[str, Any]],
+    ) -> None:
+        """Update multiple fields"""
+        for field, config in fields.items():
+            self.update_field(
+                path,
+                field,
+                config["value"],
+                config.get("type", "string"),
+            )
+    
+    def delete(self, path: str) -> Dict[str, Any]:
+        """Delete document"""
+        return self.request("DELETE", "/api/db", params={"collection": path})
+    
+    def delete_field(self, path: str, field: str) -> Dict[str, Any]:
+        """Delete field"""
+        return self.request("DELETE", "/api/db", params={
+            "collection": path,
+            "field": field,
+        })

moontraze-1.0.0/moontraze/notifications.py

@@ -0,0 +1,111 @@
+"""Notifications module"""
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+from .client import MoonClient, MoonConfig
+
+
+class MoonNotifications(MoonClient):
+    """Push notifications"""
+    
+    def __init__(self, config: MoonConfig):
+        super().__init__(config)
+    
+    def register_token(
+        self,
+        token: str,
+        device_info: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Register FCM device token"""
+        return self.request("POST", "/api/notifications/register", {
+            "token": token,
+            "deviceInfo": device_info or {},
+        })
+    
+    def unregister_token(self, token: str) -> Dict[str, Any]:
+        """Unregister FCM token"""
+        return self.request("POST", "/api/notifications/unregister", {
+            "token": token,
+        })
+    
+    def send_to_project(
+        self,
+        project_id: str,
+        title: str,
+        body: str,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Send notification to all project users (owner only)"""
+        return self.request(
+            "POST",
+            f"/api/notifications/send-to-project/{project_id}",
+            {
+                "title": title,
+                "body": body,
+                "data": data or {},
+            },
+        )
+    
+    def send_to_user(
+        self,
+        user_id: str,
+        title: str,
+        body: str,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Send notification to specific user"""
+        return self.request(
+            "POST",
+            f"/api/notifications/send-to-user/{user_id}",
+            {
+                "title": title,
+                "body": body,
+                "data": data or {},
+            },
+        )
+    
+    def send_to_topic(
+        self,
+        topic: str,
+        title: str,
+        body: str,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Send notification to topic"""
+        return self.request("POST", "/api/notifications/send-to-topic", {
+            "topic": topic,
+            "title": title,
+            "body": body,
+            "data": data or {},
+        })
+    
+    def schedule(
+        self,
+        title: str,
+        body: str,
+        send_at: datetime,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Schedule notification"""
+        return self.request("POST", "/api/notifications/schedule", {
+            "title": title,
+            "body": body,
+            "sendAt": send_at.isoformat(),
+            "data": data or {},
+        })
+    
+    def get_history(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """Get notification history"""
+        data = self.request(
+            "GET",
+            "/api/notifications/history",
+            params={"limit": limit},
+        )
+        return data.get("notifications", [])
+    
+    def get_preferences(self) -> Dict[str, Any]:
+        """Get notification preferences"""
+        return self.request("GET", "/api/notifications/preferences")
+    
+    def update_preferences(self, **kwargs) -> Dict[str, Any]:
+        """Update notification preferences"""
+        return self.request("PUT", "/api/notifications/preferences", kwargs)

moontraze-1.0.0/moontraze/storage.py

@@ -0,0 +1,137 @@
+"""Storage module"""
+import os
+from typing import Optional, Dict, Any, List, IO
+from .client import MoonClient, MoonConfig
+
+
+class MoonStorage(MoonClient):
+    """Storage operations"""
+    
+    def __init__(self, config: MoonConfig):
+        super().__init__(config)
+    
+    def upload(
+        self,
+        file: IO,
+        filename: str,
+        folder_id: Optional[str] = None,
+        content_type: str = "application/octet-stream",
+    ) -> Dict[str, Any]:
+        """Upload a file"""
+        url = f"/api/storage/{self.config.project_id}/upload"
+        
+        files = {"file": (filename, file, content_type)}
+        data = {}
+        if folder_id:
+            data["folderId"] = folder_id
+        
+        return self.request("POST", url, files=files, data=data)
+    
+    def upload_from_path(
+        self,
+        file_path: str,
+        folder_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Upload file from path"""
+        filename = os.path.basename(file_path)
+        
+        with open(file_path, "rb") as f:
+            return self.upload(f, filename, folder_id)
+    
+    def list(self, folder_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """List files"""
+        params = {}
+        if folder_id:
+            params["folderId"] = folder_id
+        
+        data = self.request(
+            "GET",
+            f"/api/storage/{self.config.project_id}/files",
+            params=params,
+        )
+        return data.get("files", [])
+    
+    def delete(self, file_id: str) -> Dict[str, Any]:
+        """Delete file"""
+        return self.request(
+            "DELETE",
+            f"/api/storage/{self.config.project_id}/files/{file_id}",
+        )
+    
+    def create_folder(
+        self,
+        name: str,
+        parent_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create folder"""
+        return self.request(
+            "POST",
+            f"/api/storage/{self.config.project_id}/folders",
+            {"name": name, "parentId": parent_id},
+        )
+    
+    def list_folders(self, parent_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        """List folders"""
+        params = {}
+        if parent_id:
+            params["parentId"] = parent_id
+        
+        data = self.request(
+            "GET",
+            f"/api/storage/{self.config.project_id}/folders",
+            params=params,
+        )
+        return data.get("folders", [])
+    
+    def delete_folder(self, folder_id: str) -> Dict[str, Any]:
+        """Delete folder (recursive)"""
+        return self.request(
+            "DELETE",
+            f"/api/storage/{self.config.project_id}/folders/{folder_id}",
+        )
+    
+    def get_presigned_url(
+        self,
+        file_id: str,
+        download: bool = True,
+    ) -> Dict[str, Any]:
+        """Get presigned download URL"""
+        params = {"download": "true"} if download else {}
+        return self.request(
+            "GET",
+            f"/api/storage/{self.config.project_id}/files/{file_id}/presign",
+            params=params,
+        )
+    
+    def get_download_url(self, file_id: str) -> str:
+        """Get direct download URL"""
+        result = self.get_presigned_url(file_id, True)
+        return result["url"]
+    
+    def download(self, file_id: str, save_path: str) -> str:
+        """Download file from presigned URL"""
+        import requests
+        
+        url = self.get_download_url(file_id)
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        
+        with open(save_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+        
+        return save_path
+    
+    def get_quota(self) -> Dict[str, Any]:
+        """Get storage quota"""
+        return self.request(
+            "GET",
+            f"/api/storage/{self.config.project_id}/quota",
+        )
+    
+    def get_size(self) -> Dict[str, Any]:
+        """Get storage size"""
+        return self.request(
+            "GET",
+            f"/api/storage/{self.config.project_id}/size",
+        )

moontraze-1.0.0/moontraze.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: moontraze
+Version: 1.0.0
+Summary: Official Moontraze SDK — Auth, Database, Storage, Notifications
+Author-email: Moontraze <faisalrizwan0077@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://moontraze.com
+Project-URL: Repository, https://github.com/moontraze/sdk-python
+Project-URL: Documentation, https://docs.moontraze.com
+Keywords: moontraze,backend,auth,database,storage,notifications,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: urllib3>=1.26.0
+Provides-Extra: async
+Requires-Dist: aiohttp>=3.8.0; extra == "async"
+Dynamic: license-file
+
+# moontraze
+
+Official Moontraze Python SDK — Auth, Database, Storage, and Push Notifications.
+
+## Installation
+
+```bash
+pip install moontraze

moontraze-1.0.0/moontraze.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+moontraze/__init__.py
+moontraze/auth.py
+moontraze/client.py
+moontraze/database.py
+moontraze/notifications.py
+moontraze/storage.py
+moontraze.egg-info/PKG-INFO
+moontraze.egg-info/SOURCES.txt
+moontraze.egg-info/dependency_links.txt
+moontraze.egg-info/requires.txt
+moontraze.egg-info/top_level.txt

moontraze-1.0.0/moontraze.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moontraze-1.0.0/moontraze.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.28.0
+urllib3>=1.26.0
+
+[async]
+aiohttp>=3.8.0

moontraze-1.0.0/moontraze.egg-info/top_level.txt

@@ -0,0 +1 @@
+moontraze

moontraze-1.0.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=77.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "moontraze"
+version = "1.0.0"
+description = "Official Moontraze SDK — Auth, Database, Storage, Notifications"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"  # ← Simple string (SPDX)
+license-files = ["LICENSE"]  # ← License file include karo
+authors = [
+    { name = "Moontraze", email = "faisalrizwan0077@gmail.com" }
+]
+keywords = ["moontraze", "backend", "auth", "database", "storage", "notifications", "sdk"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    # "License :: OSI Approved :: MIT License",  ← HATA DIYA
+]
+
+dependencies = [
+    "requests>=2.28.0",
+    "urllib3>=1.26.0",
+]
+
+[project.optional-dependencies]
+async = ["aiohttp>=3.8.0"]
+
+[project.urls]
+Homepage = "https://moontraze.com"
+Repository = "https://github.com/moontraze/sdk-python"
+Documentation = "https://docs.moontraze.com"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["moontraze*"]

moontraze-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+