python-sdk-remote 0.0.155__tar.gz → 0.0.157__tar.gz

{python_sdk_remote-0.0.155 → python_sdk_remote-0.0.157}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sdk-remote
-Version: 0.0.155
+Version: 0.0.157
 Summary: PyPI Package for Circles Python SDK Local Python
 Home-page: https://github.com/circles-zone/python-sdk-remote-python-package
 Author: Circles

python_sdk_remote-0.0.157/README.md

@@ -0,0 +1,36 @@
+# Python SDK Remote Python Package
+
+## TODOs
+
+✅ ~~TODO Add Requests.post() method which wraps requests.post() and adds logging and error handling similar to OurAxios.post() in typescript-sdk-remote repo~~ - **COMPLETED**: Implemented in `src/our_request.py` with `OurRequest.post()` and `OurRequest.get()` methods
+
+✅ ~~TODO If we don't have DatetimeRange, develop DatetimeRange which has start_datetime and end_datetime data members~~ - **COMPLETED**: Implemented in `src/datetime_range.py` with full functionality including overlap detection, duration calculation, and serialization
+
+TODO create OurObfuscation class with methods for each PII field obfuscation_first_name() - can have persistent mapping table in memory, obfuscation_last_name() - can have persistent mapping table in memory, obfuscation_organization_name() - can be persistent mapping table in memory, obfuscation_email_address() - can be emails in our development domain, obfuscation_organization(), obfuscation_phone_number() - preferable invalid phone numbers, obfuscation_social_id() - preferable valid social ids - obfuscation only when environment is not Prod1 and not Dvlp1.
+Should do the same both in python-sdk-remote and typeScript-sdk-remote<br>
+
+✅ ~~TODO Step #1 create src/version.py from setup.py and pyproject.toml like we have in TypeScript `const PACKAGE_VERSION = "0.0.122"`. Step #2 Create a function get_package_version() which returns the version of the package from src/version.py which we can use in all packages.~~ - **COMPLETED**: Implemented in `src/version.py` and `get_package_version()` function in `utilities.py`
+
+TODO Rewrite more examples
+
+TODO Function which returns SmartHyperlink to any entity person, contact, profile, organization , event ... using Mustache format. Allow to to hyperlink multiple entities (i.e. either this person or this person). Use this function in Text Block when we identify entity. When retrieving any text, we can ask with or without SmartHyperlink (default without SmartHyperlink).
+
+## Permission to the repo
+Many Team Members (python-team, typescript-team, reactjs-team ...) are using makec/MakePy/MakeTs to CreateDevelopmentEnvironment.ps and they need read access to this repo to build their local environment.
+
+## Usage in Serverless.com
+
+In serverless, use this decorator:
+```py
+from python_sdk_remote.http_response import handler_decorator
+from logger_local.Logger import Logger
+logger = Logger.create_logger(object=your_logger_object)
+@handler_decorator(logger=logger)
+def my_handler(request_parameters: dict) -> dict:
+  # Here you can use both camelCase and snake_case keys from request_parameters
+```
+
+## Versions
+
+0.0.151 for PRINT_STARS
+0.0.152 LogMessageSeverity and StartEndEnum values in UPPERCASE

python_sdk_remote-0.0.157/python_sdk_remote/src/__init__.py

@@ -0,0 +1,140 @@
+"""
+Python SDK Remote - Main exports.
+
+This module exports all the main classes and functions from the python-sdk-remote package.
+"""
+
+# Core utilities
+from .utilities import (
+    get_package_version,
+    get_environment_name,
+    get_brand_name,
+    our_get_env,
+    EnvironmentVariableException,
+    our_set_env,
+    our_delete_env,
+    to_dict,
+    to_json,
+    snake_to_camel,
+    camel_to_snake,
+    obfuscate_log_dict,
+    validate_url,
+    timedelta_to_time_format,
+    is_list_of_dicts,
+    is_valid_time_range,
+    is_valid_date_range,
+    is_valid_datetime_range,
+    is_time_in_time_range,
+    is_date_in_date_range,
+    is_datetime_in_datetime_range,
+    encode_jwt,
+    decode_jwt,
+    generate_otp,
+    get_current_datetime_string,
+    datetime_from_str,
+    datetime_to_str,
+    validate_arguments,
+    reformat_time_string,
+    get_ip_v4,
+    get_ip_v6,
+    deprecation_warning_function,
+)
+
+# HTTP response utilities
+from .http_response import (
+    get_body_payload_dict_from_event,
+    get_payload_dict_from_event,
+    get_path_parameters_dict_from_event,
+    get_query_string_parameters_from_event,
+    get_request_parameters_from_event,
+    handler_decorator,
+    create_authorization_http_headers,
+    get_user_jwt_from_event,
+    create_return_http_headers,
+    create_error_http_response,
+    create_ok_http_response,
+    create_http_body,
+    create_internal_server_error_http_response,
+    create_ok_http_response_simple,
+)
+
+# New classes implemented for TODOs
+from .datetime_range import DatetimeRange
+from .our_obfuscation import OurObfuscation
+from .our_request import OurRequest
+from .generic_crud import GenericCrud, MockGenericCrud
+from .our_objects_local import OurObjectsLocal
+
+# Existing classes
+from .mini_logger import MiniLogger
+from .our_object import OurObject
+from .version import PACKAGE_VERSION
+
+# Constants
+# Note: Importing constants separately to avoid circular imports
+# from .constants import *
+
+__all__ = [
+    # Utilities
+    'get_package_version',
+    'get_environment_name', 
+    'get_brand_name',
+    'our_get_env',
+    'EnvironmentVariableException',
+    'our_set_env',
+    'our_delete_env',
+    'to_dict',
+    'to_json',
+    'snake_to_camel',
+    'camel_to_snake',
+    'obfuscate_log_dict',
+    'validate_url',
+    'timedelta_to_time_format',
+    'is_list_of_dicts',
+    'is_valid_time_range',
+    'is_valid_date_range',
+    'is_valid_datetime_range',
+    'is_time_in_time_range',
+    'is_date_in_date_range',
+    'is_datetime_in_datetime_range',
+    'encode_jwt',
+    'decode_jwt',
+    'generate_otp',
+    'get_current_datetime_string',
+    'datetime_from_str',
+    'datetime_to_str',
+    'validate_arguments',
+    'reformat_time_string',
+    'get_ip_v4',
+    'get_ip_v6',
+    'deprecation_warning_function',
+    
+    # HTTP response utilities
+    'get_body_payload_dict_from_event',
+    'get_payload_dict_from_event',
+    'get_path_parameters_dict_from_event',
+    'get_query_string_parameters_from_event',
+    'get_request_parameters_from_event',
+    'handler_decorator',
+    'create_authorization_http_headers',
+    'get_user_jwt_from_event',
+    'create_return_http_headers',
+    'create_error_http_response',
+    'create_ok_http_response',
+    'create_http_body',
+    'create_internal_server_error_http_response',
+    'create_ok_http_response_simple',
+    
+    # New classes
+    'DatetimeRange',
+    'OurObfuscation',
+    'OurRequest',
+    'GenericCrud',
+    'MockGenericCrud',
+    'OurObjectsLocal',
+    
+    # Existing classes
+    'MiniLogger',
+    'OurObject',
+    'PACKAGE_VERSION',
+]

{python_sdk_remote-0.0.155 → python_sdk_remote-0.0.157}/python_sdk_remote/src/constants_src_mini_logger_and_logger.py

@@ -1,8 +1,12 @@
 from enum import Enum
 
 
-# TODO I think enum values should be in uppercase
 class LogMessageSeverity(Enum):
+    """
+    Log message severity levels.
+    
+    Note: Enum values are in uppercase following Python conventions.
+    """
     DEBUG = 100
     VERBOSE = 200
     INIT = 300
@@ -14,5 +18,6 @@ class LogMessageSeverity(Enum):
 
 
 class StartEndEnum(Enum):
+    """Enum for marking start and end of operations."""
     START = 400
     END = 402

python_sdk_remote-0.0.157/python_sdk_remote/src/datetime_range.py

@@ -0,0 +1,127 @@
+"""
+DatetimeRange class for handling datetime ranges.
+
+This module provides a DatetimeRange class with start_datetime and end_datetime data members
+as requested in the TODO.
+"""
+
+from datetime import datetime
+from typing import Optional
+
+from .mini_logger import MiniLogger as logger
+
+
+class DatetimeRange:
+    """
+    A class to represent a datetime range with start and end datetime.
+    
+    Attributes:
+        start_datetime (datetime): The start datetime of the range
+        end_datetime (datetime): The end datetime of the range
+    """
+    
+    def __init__(self, start_datetime: datetime, end_datetime: datetime):
+        """
+        Initialize DatetimeRange with start and end datetime.
+        
+        Args:
+            start_datetime: The start datetime of the range
+            end_datetime: The end datetime of the range
+            
+        Raises:
+            ValueError: If start_datetime is after end_datetime
+        """
+        logger.start(object={"start_datetime": start_datetime, "end_datetime": end_datetime})
+        
+        if start_datetime > end_datetime:
+            raise ValueError("start_datetime cannot be after end_datetime")
+            
+        self.start_datetime = start_datetime
+        self.end_datetime = end_datetime
+        
+        logger.end(object={"datetime_range": self.__dict__})
+    
+    def contains(self, check_datetime: datetime) -> bool:
+        """
+        Check if a datetime is within this range (inclusive).
+        
+        Args:
+            check_datetime: The datetime to check
+            
+        Returns:
+            bool: True if the datetime is within the range, False otherwise
+        """
+        logger.start(object={"check_datetime": check_datetime})
+        result = self.start_datetime <= check_datetime <= self.end_datetime
+        logger.end(object={"contains_result": result})
+        return result
+    
+    def overlaps(self, other: 'DatetimeRange') -> bool:
+        """
+        Check if this range overlaps with another DatetimeRange.
+        
+        Args:
+            other: Another DatetimeRange to check overlap with
+            
+        Returns:
+            bool: True if ranges overlap, False otherwise
+        """
+        logger.start(object={"other_range": other.__dict__})
+        result = (self.start_datetime <= other.end_datetime and 
+                 self.end_datetime >= other.start_datetime)
+        logger.end(object={"overlaps_result": result})
+        return result
+    
+    def duration(self) -> datetime:
+        """
+        Calculate the duration of the datetime range.
+        
+        Returns:
+            timedelta: The duration between start and end datetime
+        """
+        logger.start()
+        duration = self.end_datetime - self.start_datetime
+        logger.end(object={"duration": str(duration)})
+        return duration
+    
+    def __str__(self) -> str:
+        """String representation of the DatetimeRange."""
+        return f"DatetimeRange({self.start_datetime} to {self.end_datetime})"
+    
+    def __repr__(self) -> str:
+        """Detailed string representation of the DatetimeRange."""
+        return f"DatetimeRange(start_datetime={self.start_datetime!r}, end_datetime={self.end_datetime!r})"
+    
+    def __eq__(self, other) -> bool:
+        """Check equality with another DatetimeRange."""
+        if not isinstance(other, DatetimeRange):
+            return False
+        return (self.start_datetime == other.start_datetime and 
+                self.end_datetime == other.end_datetime)
+    
+    def to_dict(self) -> dict:
+        """
+        Convert DatetimeRange to dictionary.
+        
+        Returns:
+            dict: Dictionary representation with start_datetime and end_datetime
+        """
+        return {
+            "start_datetime": self.start_datetime.isoformat(),
+            "end_datetime": self.end_datetime.isoformat()
+        }
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'DatetimeRange':
+        """
+        Create DatetimeRange from dictionary.
+        
+        Args:
+            data: Dictionary with start_datetime and end_datetime keys
+            
+        Returns:
+            DatetimeRange: New DatetimeRange instance
+        """
+        start_dt = datetime.fromisoformat(data["start_datetime"])
+        end_dt = datetime.fromisoformat(data["end_datetime"])
+        return cls(start_dt, end_dt)

python_sdk_remote-0.0.157/python_sdk_remote/src/exceptions.py

@@ -0,0 +1,7 @@
+# TODO Rename the file to environment_variable_exception.py
+class EnvironmentVariableException(Exception):
+    """Raised when a required environment variable is missing or empty.
+
+    A specific exception (rather than a generic Exception) so callers can catch
+    exactly this case; shared by our_get_env / our_delete_env for consistency.
+    """

python_sdk_remote-0.0.157/python_sdk_remote/src/generic_crud.py

@@ -0,0 +1,306 @@
+"""
+GenericCrud class for consistent database operations.
+
+This module provides a generic CRUD interface that can be used by OurObjectsLocal
+and other database access classes for consistent operations.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Union
+
+from .mini_logger import MiniLogger as logger
+
+
+class GenericCrud(ABC):
+    """
+    Abstract base class for generic CRUD operations.
+    
+    Provides a consistent interface for database operations that can be
+    implemented by different database backends (MySQL, PostgreSQL, etc.).
+    """
+    
+    def __init__(self, table_name: str, connection=None):
+        """
+        Initialize GenericCrud with table name and optional connection.
+        
+        Args:
+            table_name: Name of the database table
+            connection: Database connection object (optional)
+        """
+        self.table_name = table_name
+        self.connection = connection
+        logger.info(f"GenericCrud initialized for table_name={table_name}")
+    
+    @abstractmethod
+    def create(self, data: Dict[str, Any]) -> Optional[int]:
+        """
+        Create a new record in the database.
+        
+        Args:
+            data: Dictionary of field names and values
+            
+        Returns:
+            Optional[int]: ID of the created record, or None if creation failed
+        """
+        pass
+    
+    @abstractmethod
+    def read(self, record_id: Union[int, str]) -> Optional[Dict[str, Any]]:
+        """
+        Read a single record by ID.
+        
+        Args:
+            record_id: ID of the record to read
+            
+        Returns:
+            Optional[Dict]: Record data as dictionary, or None if not found
+        """
+        pass
+    
+    @abstractmethod
+    def update(self, record_id: Union[int, str], data: Dict[str, Any]) -> bool:
+        """
+        Update an existing record.
+        
+        Args:
+            record_id: ID of the record to update
+            data: Dictionary of field names and new values
+            
+        Returns:
+            bool: True if update was successful, False otherwise
+        """
+        pass
+    
+    @abstractmethod
+    def delete(self, record_id: Union[int, str]) -> bool:
+        """
+        Delete a record by ID.
+        
+        Args:
+            record_id: ID of the record to delete
+            
+        Returns:
+            bool: True if deletion was successful, False otherwise
+        """
+        pass
+    
+    @abstractmethod
+    def list_all(self, limit: Optional[int] = None, offset: int = 0) -> List[Dict[str, Any]]:
+        """
+        List all records in the table.
+        
+        Args:
+            limit: Maximum number of records to return (optional)
+            offset: Number of records to skip (default: 0)
+            
+        Returns:
+            List[Dict]: List of records as dictionaries
+        """
+        pass
+    
+    @abstractmethod
+    def where(self, conditions: Dict[str, Any], 
+              limit: Optional[int] = None, 
+              offset: int = 0,
+              order_by: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Query records with WHERE conditions.
+        
+        Args:
+            conditions: Dictionary of field names and values for WHERE clause
+            limit: Maximum number of records to return (optional)
+            offset: Number of records to skip (default: 0)
+            order_by: Field name to order by (optional)
+            
+        Returns:
+            List[Dict]: List of matching records as dictionaries
+        """
+        pass
+    
+    @abstractmethod
+    def count(self, conditions: Optional[Dict[str, Any]] = None) -> int:
+        """
+        Count records matching conditions.
+        
+        Args:
+            conditions: Dictionary of field names and values for WHERE clause (optional)
+            
+        Returns:
+            int: Number of matching records
+        """
+        pass
+    
+    def active_by_filter(self, filter_criteria: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Get active records matching filter criteria.
+        
+        This is a convenience method that adds 'active' = True to the filter criteria.
+        
+        Args:
+            filter_criteria: Dictionary of field names and values
+            
+        Returns:
+            List[Dict]: List of active records matching criteria
+        """
+        logger.start(object={"filter_criteria": filter_criteria})
+        
+        # Add active condition to filter criteria
+        active_filter = filter_criteria.copy()
+        active_filter["active"] = True
+        
+        result = self.where(active_filter)
+        
+        logger.end(object={"result_count": len(result)})
+        return result
+    
+    def active(self) -> List[Dict[str, Any]]:
+        """
+        Get all active records.
+        
+        Returns:
+            List[Dict]: List of all active records
+        """
+        logger.start()
+        result = self.active_by_filter({})
+        logger.end(object={"result_count": len(result)})
+        return result
+
+
+class MockGenericCrud(GenericCrud):
+    """
+    Mock implementation of GenericCrud for testing purposes.
+    
+    Uses in-memory storage instead of a real database.
+    """
+    
+    def __init__(self, table_name: str, connection=None):
+        super().__init__(table_name, connection)
+        self._data: Dict[int, Dict[str, Any]] = {}
+        self._next_id = 1
+    
+    def create(self, data: Dict[str, Any]) -> Optional[int]:
+        """Create a new record in memory."""
+        logger.start(object={"data": data})
+        
+        record_id = self._next_id
+        self._next_id += 1
+        
+        # Add ID and created timestamp
+        record_data = data.copy()
+        record_data["id"] = record_id
+        
+        self._data[record_id] = record_data
+        
+        logger.end(object={"record_id": record_id})
+        return record_id
+    
+    def read(self, record_id: Union[int, str]) -> Optional[Dict[str, Any]]:
+        """Read a single record by ID."""
+        logger.start(object={"record_id": record_id})
+        
+        record_id = int(record_id)
+        result = self._data.get(record_id)
+        
+        logger.end(object={"found": result is not None})
+        return result
+    
+    def update(self, record_id: Union[int, str], data: Dict[str, Any]) -> bool:
+        """Update an existing record."""
+        logger.start(object={"record_id": record_id, "data": data})
+        
+        record_id = int(record_id)
+        if record_id in self._data:
+            self._data[record_id].update(data)
+            logger.end(object={"success": True})
+            return True
+        
+        logger.end(object={"success": False, "reason": "record_not_found"})
+        return False
+    
+    def delete(self, record_id: Union[int, str]) -> bool:
+        """Delete a record by ID."""
+        logger.start(object={"record_id": record_id})
+        
+        record_id = int(record_id)
+        if record_id in self._data:
+            del self._data[record_id]
+            logger.end(object={"success": True})
+            return True
+        
+        logger.end(object={"success": False, "reason": "record_not_found"})
+        return False
+    
+    def list_all(self, limit: Optional[int] = None, offset: int = 0) -> List[Dict[str, Any]]:
+        """List all records."""
+        logger.start(object={"limit": limit, "offset": offset})
+        
+        all_records = list(self._data.values())
+        
+        # Apply offset and limit
+        if offset > 0:
+            all_records = all_records[offset:]
+        
+        if limit is not None:
+            all_records = all_records[:limit]
+        
+        logger.end(object={"result_count": len(all_records)})
+        return all_records
+    
+    def where(self, conditions: Dict[str, Any], 
+              limit: Optional[int] = None, 
+              offset: int = 0,
+              order_by: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Query records with WHERE conditions."""
+        logger.start(object={"conditions": conditions, "limit": limit, "offset": offset, "order_by": order_by})
+        
+        matching_records = []
+        
+        for record in self._data.values():
+            matches = True
+            for field, value in conditions.items():
+                if field not in record or record[field] != value:
+                    matches = False
+                    break
+            
+            if matches:
+                matching_records.append(record)
+        
+        # Apply ordering
+        if order_by and matching_records:
+            try:
+                matching_records.sort(key=lambda x: x.get(order_by, ''))
+            except Exception as e:
+                logger.warning(f"Failed to sort by order_by={order_by}: e={e}")
+        
+        # Apply offset and limit
+        if offset > 0:
+            matching_records = matching_records[offset:]
+        
+        if limit is not None:
+            matching_records = matching_records[:limit]
+        
+        logger.end(object={"result_count": len(matching_records)})
+        return matching_records
+    
+    def count(self, conditions: Optional[Dict[str, Any]] = None) -> int:
+        """Count records matching conditions."""
+        logger.start(object={"conditions": conditions})
+        
+        if conditions is None:
+            result = len(self._data)
+        else:
+            matching_count = 0
+            for record in self._data.values():
+                matches = True
+                for field, value in conditions.items():
+                    if field not in record or record[field] != value:
+                        matches = False
+                        break
+                
+                if matches:
+                    matching_count += 1
+            
+            result = matching_count
+        
+        logger.end(object={"count": result})
+        return result