gsab 0.1.0__tar.gz

gsab-0.1.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ajmal Aksar
+
+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. 

gsab-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: gsab
+Version: 0.1.0
+Summary: A database-like interface for Google Sheets
+Home-page: https://github.com/ajmalaksar25/gsab
+Author: Ajmal Aksar
+Author-email: ajmalaksar25@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: google-auth-oauthlib>=0.4.6
+Requires-Dist: fastapi>=0.68.0
+Requires-Dist: uvicorn>=0.15.0
+Requires-Dist: python-multipart>=0.0.5
+Requires-Dist: jinja2>=3.0.0
+Requires-Dist: aiofiles>=0.8.0
+Requires-Dist: pytest>=6.0.0
+Requires-Dist: pytest-asyncio>=0.15.0
+Requires-Dist: pytest-cov>=2.12.0
+Requires-Dist: google-auth>=2.3.3
+Requires-Dist: google-api-python-client>=2.31.0
+Requires-Dist: cryptography>=35.0.0
+Requires-Dist: python-dotenv>=0.19.2
+
+# Google Sheets as Backend (GSAB)
+
+A Python library that enables using Google Sheets as a database backend with features like schema validation and encryption.
+
+## Features
+
+- 🔒 Secure Google Sheets integration with OAuth2
+- 📊 Schema validation and type checking
+- 🔐 Field-level encryption for sensitive data
+- 🌐 Async/await support
+- 📝 Comprehensive logging
+
+## Installation
+
+```bash
+pip install gsheets-db
+```
+
+## Quick Start
+
+1. Set up Google Cloud Project and enable Google Sheets API:
+   - Go to [Google Cloud Console](https://console.cloud.google.com)
+   - Create a new project or select existing one
+   - Enable Google Sheets API
+   - Create OAuth 2.0 credentials
+   - Download credentials JSON file
+
+2. Set up environment variables:
+
+```bash
+GOOGLE_CREDENTIALS_PATH=/path/to/credentials.json
+ENCRYPTION_KEY=your-encryption-key
+```
+
+3. Basic Usage:
+
+```python
+from gsab import SheetConnection, Schema, Field, FieldType, SheetManager
+
+# Define your schema
+schema = Schema("users", [
+    Field("id", FieldType.INTEGER, required=True, unique=True),
+    Field("email", FieldType.STRING, required=True),
+    Field("password", FieldType.STRING, required=True, encrypted=True)
+])
+
+# Connect and use
+async def main():
+    connection = SheetConnection()
+    await connection.connect()
+    
+    sheet_manager = SheetManager(connection, schema)
+    
+    # Create a new sheet
+    sheet = await sheet_manager.create_sheet("Users Data")
+    
+    # Insert data
+    await sheet_manager.insert({
+        "id": 1,
+        "email": "user@example.com",
+        "password": "secretpass123"  # Will be automatically encrypted
+    })
+
+```
+
+## Schema Definition
+
+Define your data structure with type checking and validation:
+
+```python
+from gsab import Schema, Field, FieldType, ValidationRule
+
+schema = Schema("users", [
+    Field("id", FieldType.INTEGER, required=True, unique=True),
+    Field("email", FieldType.STRING, required=True),
+    Field("age", FieldType.INTEGER, min_value=0, max_value=150),
+    Field("password", FieldType.STRING, required=True, encrypted=True)
+])
+```
+
+## Security Features
+
+### Field Encryption
+
+Sensitive data is automatically encrypted when the field is marked with `encrypted=True`:
+
+```python
+# Fields marked as encrypted will be automatically handled
+schema = Schema("users", [
+    Field("ssn", FieldType.STRING, encrypted=True),
+    Field("credit_card", FieldType.STRING, encrypted=True)
+])
+```
+
+<!-- ## Contributing
+
+We love your input! We want to make contributing to GSheetsDB as easy and transparent as possible, whether it's:
+
+- Reporting a bug
+- Discussing the current state of the code
+- Submitting a fix
+- Proposing new features
+- Becoming a maintainer
+
+Check out our [Contributing Guide](CONTRIBUTING.md) for ways to get started. -->
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.
+
+[![PyPI version](https://badge.fury.io/py/gsab.svg)](https://badge.fury.io/py/gsab)
+[![Tests](https://github.com/ajmalaksar25/gsab/actions/workflows/tests.yml/badge.svg)](https://github.com/ajmalaksar25/gsab/actions/workflows/tests.yml)
+[![codecov](https://codecov.io/gh/ajmalaksar25/gsab/branch/main/graph/badge.svg)](https://codecov.io/gh/ajmalaksar25/gsab)

gsab-0.1.0/README.md

@@ -0,0 +1,113 @@
+# Google Sheets as Backend (GSAB)
+
+A Python library that enables using Google Sheets as a database backend with features like schema validation and encryption.
+
+## Features
+
+- 🔒 Secure Google Sheets integration with OAuth2
+- 📊 Schema validation and type checking
+- 🔐 Field-level encryption for sensitive data
+- 🌐 Async/await support
+- 📝 Comprehensive logging
+
+## Installation
+
+```bash
+pip install gsheets-db
+```
+
+## Quick Start
+
+1. Set up Google Cloud Project and enable Google Sheets API:
+   - Go to [Google Cloud Console](https://console.cloud.google.com)
+   - Create a new project or select existing one
+   - Enable Google Sheets API
+   - Create OAuth 2.0 credentials
+   - Download credentials JSON file
+
+2. Set up environment variables:
+
+```bash
+GOOGLE_CREDENTIALS_PATH=/path/to/credentials.json
+ENCRYPTION_KEY=your-encryption-key
+```
+
+3. Basic Usage:
+
+```python
+from gsab import SheetConnection, Schema, Field, FieldType, SheetManager
+
+# Define your schema
+schema = Schema("users", [
+    Field("id", FieldType.INTEGER, required=True, unique=True),
+    Field("email", FieldType.STRING, required=True),
+    Field("password", FieldType.STRING, required=True, encrypted=True)
+])
+
+# Connect and use
+async def main():
+    connection = SheetConnection()
+    await connection.connect()
+    
+    sheet_manager = SheetManager(connection, schema)
+    
+    # Create a new sheet
+    sheet = await sheet_manager.create_sheet("Users Data")
+    
+    # Insert data
+    await sheet_manager.insert({
+        "id": 1,
+        "email": "user@example.com",
+        "password": "secretpass123"  # Will be automatically encrypted
+    })
+
+```
+
+## Schema Definition
+
+Define your data structure with type checking and validation:
+
+```python
+from gsab import Schema, Field, FieldType, ValidationRule
+
+schema = Schema("users", [
+    Field("id", FieldType.INTEGER, required=True, unique=True),
+    Field("email", FieldType.STRING, required=True),
+    Field("age", FieldType.INTEGER, min_value=0, max_value=150),
+    Field("password", FieldType.STRING, required=True, encrypted=True)
+])
+```
+
+## Security Features
+
+### Field Encryption
+
+Sensitive data is automatically encrypted when the field is marked with `encrypted=True`:
+
+```python
+# Fields marked as encrypted will be automatically handled
+schema = Schema("users", [
+    Field("ssn", FieldType.STRING, encrypted=True),
+    Field("credit_card", FieldType.STRING, encrypted=True)
+])
+```
+
+<!-- ## Contributing
+
+We love your input! We want to make contributing to GSheetsDB as easy and transparent as possible, whether it's:
+
+- Reporting a bug
+- Discussing the current state of the code
+- Submitting a fix
+- Proposing new features
+- Becoming a maintainer
+
+Check out our [Contributing Guide](CONTRIBUTING.md) for ways to get started. -->
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.
+
+[![PyPI version](https://badge.fury.io/py/gsab.svg)](https://badge.fury.io/py/gsab)
+[![Tests](https://github.com/ajmalaksar25/gsab/actions/workflows/tests.yml/badge.svg)](https://github.com/ajmalaksar25/gsab/actions/workflows/tests.yml)
+[![codecov](https://codecov.io/gh/ajmalaksar25/gsab/branch/main/graph/badge.svg)](https://codecov.io/gh/ajmalaksar25/gsab)

gsab-0.1.0/auth/__init__.py

@@ -0,0 +1 @@
+"""Authentication package.""" 

gsab-0.1.0/auth/authenticator.py

@@ -0,0 +1,39 @@
+from google.oauth2 import service_account
+from google.auth.transport.requests import Request
+
+class GoogleAuthenticator:
+    """Handles authentication with Google Sheets API."""
+    
+    SCOPES = [
+        'https://www.googleapis.com/auth/spreadsheets',
+        'https://www.googleapis.com/auth/drive.file',
+        'https://www.googleapis.com/auth/drive'
+    ]
+    
+    def __init__(self, credentials_path: str):
+        self.credentials_path = credentials_path
+        self.creds = None
+
+    def authenticate(self):
+        """
+        Authenticate using service account credentials.
+        
+        Returns:
+            Google OAuth2 credentials
+        """
+        try:
+            self.creds = service_account.Credentials.from_service_account_file(
+                self.credentials_path,
+                scopes=self.SCOPES
+            )
+            # Ensure the credentials are valid
+            if not self.creds.valid:
+                request = Request()
+                self.creds.refresh(request)
+            return self.creds
+        except Exception as e:
+            raise AuthenticationError(f"Authentication failed: {str(e)}")
+
+class AuthenticationError(Exception):
+    """Custom exception for authentication errors."""
+    pass

gsab-0.1.0/core/__init__.py

@@ -0,0 +1 @@
+"""Core package.""" 

gsab-0.1.0/core/connection.py

@@ -0,0 +1,39 @@
+from typing import Optional, Dict, Any
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+from ..auth.authenticator import GoogleAuthenticator
+from ..exceptions.custom_exceptions import ConnectionError
+
+class SheetConnection:
+    """Manages connection to Google Sheets API."""
+    
+    def __init__(self, credentials_path: str = None):
+        """Initialize connection with credentials path."""
+        self.credentials_path = credentials_path
+        self.credentials = None
+        self.service = None
+        
+    async def connect(self) -> None:
+        """Establish connection to Google Sheets API."""
+        try:
+            SCOPES = [
+                'https://www.googleapis.com/auth/spreadsheets',
+                'https://www.googleapis.com/auth/drive',
+                'https://www.googleapis.com/auth/drive.file'
+            ]
+            
+            # Use service account credentials
+            self.credentials = service_account.Credentials.from_service_account_file(
+                self.credentials_path, 
+                scopes=SCOPES
+            )
+            
+            self.service = build('sheets', 'v4', credentials=self.credentials)
+            
+        except Exception as e:
+            raise ConnectionError(f"Failed to connect to Google Sheets API: {str(e)}")
+
+            
+    def is_connected(self) -> bool:
+        """Check if connection is established."""
+        return self.service is not None 

gsab-0.1.0/core/schema.py

@@ -0,0 +1,233 @@
+from typing import Dict, Any, List, Union, Optional, Callable
+from dataclasses import dataclass
+from enum import Enum
+import re
+from datetime import datetime, date
+
+class FieldType(Enum):
+    STRING = "string"
+    INTEGER = "integer"
+    FLOAT = "float"
+    BOOLEAN = "boolean"
+    DATE = "date"
+    DATETIME = "datetime"
+    JSON = "json"
+    ENCRYPTED = "encrypted"
+
+@dataclass
+class ValidationRule:
+    """Defines a validation rule for a field."""
+    condition: Callable[[Any], bool]
+    error_message: str
+
+@dataclass
+class Field:
+    name: str
+    field_type: FieldType
+    required: bool = True
+    unique: bool = False
+    default: Any = None
+    min_length: Optional[int] = None
+    max_length: Optional[int] = None
+    pattern: Optional[str] = None
+    min_value: Optional[Union[int, float]] = None
+    max_value: Optional[Union[int, float]] = None
+    validation_rules: List[ValidationRule] = None
+    encrypted: bool = False
+
+    def __post_init__(self):
+        self.validation_rules = self.validation_rules or []
+        self._add_default_validations()
+
+    def _add_default_validations(self):
+        """Add default validation rules based on field type and constraints."""
+        if self.min_length is not None:
+            self.validation_rules.append(
+                ValidationRule(
+                    lambda x: len(str(x)) >= self.min_length,
+                    f"Value must be at least {self.min_length} characters long"
+                )
+            )
+
+        if self.max_length is not None:
+            self.validation_rules.append(
+                ValidationRule(
+                    lambda x: len(str(x)) <= self.max_length,
+                    f"Value must be at most {self.max_length} characters long"
+                )
+            )
+
+        if self.pattern is not None:
+            self.validation_rules.append(
+                ValidationRule(
+                    lambda x: bool(re.match(self.pattern, str(x))),
+                    f"Value must match pattern: {self.pattern}"
+                )
+            )
+
+        if self.min_value is not None:
+            self.validation_rules.append(
+                ValidationRule(
+                    lambda x: x >= self.min_value,
+                    f"Value must be greater than or equal to {self.min_value}"
+                )
+            )
+
+        if self.max_value is not None:
+            self.validation_rules.append(
+                ValidationRule(
+                    lambda x: x <= self.max_value,
+                    f"Value must be less than or equal to {self.max_value}"
+                )
+            )
+
+class Schema:
+    """Defines the structure of a sheet."""
+    
+    def __init__(self, name: str, fields: List[Field]):
+        self.name = name
+        self.fields = fields
+        self._validate_schema()
+        self._field_map = {field.name: field for field in fields}
+        
+    def _validate_schema(self) -> None:
+        """Validate schema definition."""
+        field_names = set()
+        for field in self.fields:
+            if field.name in field_names:
+                raise ValueError(f"Duplicate field name: {field.name}")
+            field_names.add(field.name)
+
+    def validate_value(self, field_name: str, value: Any) -> List[str]:
+        """
+        Validate a value against field rules.
+        
+        Args:
+            field_name: Name of the field
+            value: Value to validate
+            
+        Returns:
+            List of validation error messages (empty if valid)
+        """
+        field = self._field_map.get(field_name)
+        if not field:
+            raise ValueError(f"Unknown field: {field_name}")
+
+        errors = []
+        
+        # Skip validation for None values if field is not required
+        if value is None:
+            if field.required:
+                errors.append(f"Field {field_name} is required")
+            return errors
+
+        # Type validation
+        try:
+            self._convert_value(value, field.field_type)
+        except ValueError as e:
+            errors.append(str(e))
+            return errors
+
+        # Custom validation rules
+        for rule in field.validation_rules:
+            try:
+                if not rule.condition(value):
+                    errors.append(rule.error_message)
+            except Exception as e:
+                errors.append(f"Validation error: {str(e)}")
+
+        return errors
+
+    def _convert_value(self, value: Any, field_type: FieldType) -> Any:
+        """Convert and validate value type."""
+        try:
+            if field_type == FieldType.INTEGER:
+                return int(value)
+            elif field_type == FieldType.FLOAT:
+                return float(value)
+            elif field_type == FieldType.BOOLEAN:
+                return bool(value)
+            elif field_type == FieldType.DATE:
+                if isinstance(value, str):
+                    return datetime.strptime(value, "%Y-%m-%d").date()
+                elif isinstance(value, date):
+                    return value
+                raise ValueError("Invalid date format")
+            elif field_type == FieldType.DATETIME:
+                if isinstance(value, str):
+                    return datetime.fromisoformat(value)
+                elif isinstance(value, datetime):
+                    return value
+                raise ValueError("Invalid datetime format")
+            else:
+                return str(value)
+        except Exception as e:
+            raise ValueError(f"Invalid value for type {field_type}: {value}")
+        
+    def validate_field(self, field_name: str, value: Any) -> List[str]:
+        """Validate a single field value."""
+        errors = []
+        field = self.get_field(field_name)
+        
+        if field:
+            # Type validation
+            if field.field_type == FieldType.INTEGER:
+                if not isinstance(value, (int, float)) or isinstance(value, bool):
+                    errors.append(f"Invalid value for type {field.field_type}: {value}")
+                elif field_name == "age" and value < 0:
+                    errors.append("Age must be a positive number")
+                    
+            elif field.field_type == FieldType.FLOAT:
+                if not isinstance(value, (int, float)) or isinstance(value, bool):
+                    errors.append(f"Invalid value for type {field.field_type}: {value}")
+                    
+            elif field.field_type == FieldType.BOOLEAN:
+                if not isinstance(value, bool):
+                    errors.append(f"Invalid value for type {field.field_type}: {value}")
+                    
+            elif field.field_type == FieldType.STRING:
+                if not isinstance(value, str):
+                    errors.append(f"Invalid value for type {field.field_type}: {value}")
+                elif field.pattern and not re.match(field.pattern, value):
+                    errors.append(f"Value does not match pattern {field.pattern}: {value}")
+    
+        return errors
+        
+    def validate(self, data: Dict[str, Any]) -> List[str]:
+        """
+        Validate data against schema.
+        
+        Args:
+            data: Dictionary of field values to validate
+            
+        Returns:
+            List of validation error messages
+        """
+        errors = []
+        
+        # Check required fields
+        for field in self.fields:
+            if field.required and field.name not in data:
+                errors.append(f"Field {field.name} is required")
+                continue
+            
+            value = data.get(field.name)
+            if value is not None:
+                # Validate field value
+                field_errors = self.validate_field(field.name, value)
+                errors.extend(field_errors)
+        
+        return errors
+        
+    def get_field(self, field_name: str) -> Optional[Field]:
+        """
+        Get field by name.
+        
+        Args:
+            field_name: Name of the field to retrieve
+        
+        Returns:
+            Field object if found, None otherwise
+        """
+        return self._field_map.get(field_name)
+