the37lab-authlib 0.1.1758263039__py3-none-any.whl → 0.1.1758266466__py3-none-any.whl

the37lab_authlib/db.py

@@ -1,91 +1,91 @@
-import psycopg2
-from psycopg2.extras import RealDictCursor
-from psycopg2 import pool
-from contextlib import contextmanager
-from .models import UUIDGenerator, IntegerGenerator
-
-class Database:
-    def __init__(self, dsn, id_type='uuid', min_conn=1, max_conn=10):
-        self.dsn = dsn
-        self.id_generator = UUIDGenerator() if id_type == 'uuid' else IntegerGenerator()
-        self.id_type = id_type
-        self.min_conn = min_conn
-        self.max_conn = max_conn
-        self._pool = None
-        self._init_pool()
-        self._init_db()
-
-    def _init_pool(self):
-        self._pool = pool.ThreadedConnectionPool(
-            self.min_conn,
-            self.max_conn,
-            self.dsn,
-            cursor_factory=RealDictCursor
-        )
-
-    def _init_db(self):
-        with self.get_connection() as conn:
-            with conn.cursor() as cur:
-                # Create users table with configurable ID type
-                cur.execute(f"""
-                    CREATE TABLE IF NOT EXISTS users (
-                        id {self._get_id_type()} PRIMARY KEY,
-                        username VARCHAR(255) UNIQUE NOT NULL,
-                        email VARCHAR(255) UNIQUE NOT NULL,
-                        real_name VARCHAR(255) NOT NULL,
-                        password_hash VARCHAR(255),
-                        created_at TIMESTAMP NOT NULL,
-                        updated_at TIMESTAMP NOT NULL
-                    );
-
-                    CREATE TABLE IF NOT EXISTS roles (
-                        id {self._get_id_type()} PRIMARY KEY,
-                        name VARCHAR(255) UNIQUE NOT NULL,
-                        description TEXT,
-                        created_at TIMESTAMP NOT NULL
-                    );
-
-                    CREATE TABLE IF NOT EXISTS user_roles (
-                        user_id {self._get_id_type()} REFERENCES users(id),
-                        role_id {self._get_id_type()} REFERENCES roles(id),
-                        PRIMARY KEY (user_id, role_id)
-                    );
-
-                    CREATE TABLE IF NOT EXISTS api_tokens (
-                        id VARCHAR(8) PRIMARY KEY,
-                        user_id INTEGER REFERENCES users(id),
-                        name VARCHAR(255) NOT NULL,
-                        token VARCHAR(255) NOT NULL,
-                        created_at TIMESTAMP NOT NULL,
-                        expires_at TIMESTAMP,
-                        last_used_at TIMESTAMP
-                    );
-                """)
-
-    def _get_id_type(self):
-        return 'UUID' if self.id_type == 'uuid' else 'SERIAL'
-
-    @contextmanager
-    def get_connection(self):
-        conn = self._pool.getconn()
-        try:
-            yield conn
-            conn.commit()
-        except Exception:
-            conn.rollback()
-            raise
-        finally:
-            self._pool.putconn(conn)
-
-    @contextmanager
-    def get_cursor(self):
-        with self.get_connection() as conn:
-            with conn.cursor() as cur:
-                yield cur
-
-    def get_id_generator(self):
-        return self.id_generator
-
-    def close(self):
-        if self._pool:
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from psycopg2 import pool
+from contextlib import contextmanager
+from .models import UUIDGenerator, IntegerGenerator
+
+class Database:
+    def __init__(self, dsn, id_type='uuid', min_conn=1, max_conn=10):
+        self.dsn = dsn
+        self.id_generator = UUIDGenerator() if id_type == 'uuid' else IntegerGenerator()
+        self.id_type = id_type
+        self.min_conn = min_conn
+        self.max_conn = max_conn
+        self._pool = None
+        self._init_pool()
+        self._init_db()
+
+    def _init_pool(self):
+        self._pool = pool.ThreadedConnectionPool(
+            self.min_conn,
+            self.max_conn,
+            self.dsn,
+            cursor_factory=RealDictCursor
+        )
+
+    def _init_db(self):
+        with self.get_connection() as conn:
+            with conn.cursor() as cur:
+                # Create users table with configurable ID type
+                cur.execute(f"""
+                    CREATE TABLE IF NOT EXISTS users (
+                        id {self._get_id_type()} PRIMARY KEY,
+                        username VARCHAR(255) UNIQUE NOT NULL,
+                        email VARCHAR(255) UNIQUE NOT NULL,
+                        real_name VARCHAR(255) NOT NULL,
+                        password_hash VARCHAR(255),
+                        created_at TIMESTAMP NOT NULL,
+                        updated_at TIMESTAMP NOT NULL
+                    );
+
+                    CREATE TABLE IF NOT EXISTS roles (
+                        id {self._get_id_type()} PRIMARY KEY,
+                        name VARCHAR(255) UNIQUE NOT NULL,
+                        description TEXT,
+                        created_at TIMESTAMP NOT NULL
+                    );
+
+                    CREATE TABLE IF NOT EXISTS user_roles (
+                        user_id {self._get_id_type()} REFERENCES users(id),
+                        role_id {self._get_id_type()} REFERENCES roles(id),
+                        PRIMARY KEY (user_id, role_id)
+                    );
+
+                    CREATE TABLE IF NOT EXISTS api_tokens (
+                        id VARCHAR(8) PRIMARY KEY,
+                        user_id INTEGER REFERENCES users(id),
+                        name VARCHAR(255) NOT NULL,
+                        token VARCHAR(255) NOT NULL,
+                        created_at TIMESTAMP NOT NULL,
+                        expires_at TIMESTAMP,
+                        last_used_at TIMESTAMP
+                    );
+                """)
+
+    def _get_id_type(self):
+        return 'UUID' if self.id_type == 'uuid' else 'SERIAL'
+
+    @contextmanager
+    def get_connection(self):
+        conn = self._pool.getconn()
+        try:
+            yield conn
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+        finally:
+            self._pool.putconn(conn)
+
+    @contextmanager
+    def get_cursor(self):
+        with self.get_connection() as conn:
+            with conn.cursor() as cur:
+                yield cur
+
+    def get_id_generator(self):
+        return self.id_generator
+
+    def close(self):
+        if self._pool:
             self._pool.closeall() 

the37lab_authlib/decorators.py

@@ -1,33 +1,33 @@
-from functools import wraps
-from flask import request, current_app, jsonify
-from .exceptions import AuthError
-
-def require_auth(roles=None):
-    def decorator(f):
-        @wraps(f)
-        def decorated(*args, **kwargs):
-            if request.method == 'OPTIONS':
-                return f(*args, **kwargs)
-            try:
-                # Get the require_auth decorator from AuthManager
-                user = current_app.auth_manager.get_current_user()
-                if not user:
-                    raise AuthError('User not authenticated', 401)
-
-                auth_decorator = current_app.auth_manager.require_auth
-                
-                # Apply the AuthManager's decorator and get the result
-                decorated_func = auth_decorator(f)
-                
-                # Check roles if specified
-                if roles and not any(role in user['roles'] for role in roles):
-                    raise AuthError('Insufficient permissions', 403)
-                    
-                # Now execute the function
-                return decorated_func(*args, **kwargs)
-            except AuthError as e:
-                response = jsonify(e.to_dict())
-                response.status_code = e.status_code
-                return response
-        return decorated
+from functools import wraps
+from flask import request, current_app, jsonify
+from .exceptions import AuthError
+
+def require_auth(roles=None):
+    def decorator(f):
+        @wraps(f)
+        def decorated(*args, **kwargs):
+            if request.method == 'OPTIONS':
+                return f(*args, **kwargs)
+            try:
+                # Get the require_auth decorator from AuthManager
+                user = current_app.auth_manager.get_current_user()
+                if not user:
+                    raise AuthError('User not authenticated', 401)
+
+                auth_decorator = current_app.auth_manager.require_auth
+                
+                # Apply the AuthManager's decorator and get the result
+                decorated_func = auth_decorator(f)
+                
+                # Check roles if specified
+                if roles and not any(role in user['roles'] for role in roles):
+                    raise AuthError('Insufficient permissions', 403)
+                    
+                # Now execute the function
+                return decorated_func(*args, **kwargs)
+            except AuthError as e:
+                response = jsonify(e.to_dict())
+                response.status_code = e.status_code
+                return response
+        return decorated
     return decorator 

the37lab_authlib/exceptions.py

@@ -1,11 +1,11 @@
-class AuthError(Exception):
-    def __init__(self, message, status_code=401):
-        self.message = message
-        self.status_code = status_code
-        super().__init__(self.message)
-
-    def to_dict(self):
-        return {
-            'error': self.message,
-            'status_code': self.status_code
+class AuthError(Exception):
+    def __init__(self, message, status_code=401):
+        self.message = message
+        self.status_code = status_code
+        super().__init__(self.message)
+
+    def to_dict(self):
+        return {
+            'error': self.message,
+            'status_code': self.status_code
         } 

the37lab_authlib/models.py

@@ -1,95 +1,95 @@
-from datetime import datetime, timedelta
-import uuid
-import bcrypt
-import secrets
-import string
-from abc import ABC, abstractmethod
-
-def generate_random_string(length, alphabet=string.ascii_letters + string.digits):
-    """Generate a random string of specified length using the given alphabet."""
-    return ''.join(secrets.choice(alphabet) for _ in range(length))
-
-class IDGenerator(ABC):
-    @abstractmethod
-    def generate(self):
-        pass
-
-class UUIDGenerator(IDGenerator):
-    def generate(self):
-        return str(uuid.uuid4())
-
-class IntegerGenerator(IDGenerator):
-    def generate(self):
-        return None  # Let the database handle ID generation with SERIAL
-
-class User:
-    def __init__(self, username, email, real_name, roles=None, id_generator=None):
-        self.id = id_generator.generate() if id_generator else str(uuid.uuid4())
-        if self.id is None:  # Let database handle ID generation
-            self.id = None
-        self.username = username
-        self.email = email
-        self.real_name = real_name
-        self.roles = roles or []
-        self.created_at = datetime.utcnow()
-        self.updated_at = datetime.utcnow()
-
-class Role:
-    def __init__(self, name, description=None, id_generator=None):
-        self.id = id_generator.generate() if id_generator else str(uuid.uuid4())
-        self.name = name
-        self.description = description
-        self.created_at = datetime.utcnow()
-
-class ApiToken:
-    def __init__(self, user_id, name, expires_in_days=None):
-        self.id = generate_random_string(8)  # 8 character ID
-        self.user_id = user_id
-        self.name = name
-        self.nonce = generate_random_string(32)  # 32 character nonce
-        self.token = self._hash_nonce(self.nonce)  # Hash the nonce
-        self.created_at = datetime.utcnow()
-        self.expires_at = datetime.utcnow() + timedelta(days=expires_in_days) if expires_in_days else None
-        self.last_used_at = None
-
-    def _hash_nonce(self, nonce):
-        """Hash the nonce using bcrypt."""
-        salt = bcrypt.gensalt()
-        return bcrypt.hashpw(nonce.encode('utf-8'), salt).decode('utf-8')
-
-    def get_full_token(self):
-        """Get the full token string in the format api_IDNONCE."""
-        return f"api_{self.id}{self.nonce}"
-
-    @staticmethod
-    def parse_token(token_string):
-        """Parse a token string into its components."""
-        if not token_string.startswith('api_'):
-            raise ValueError('Invalid token format')
-        
-        token_string = token_string[4:]  # Remove 'api_' prefix
-        if len(token_string) != 40:  # 8 (id) + 32 (nonce)
-            raise ValueError('Invalid token length')
-        
-        return {
-            'id': token_string[:8],
-            'nonce': token_string[8:]
-        }
-
-    @staticmethod
-    def parse_token_id(token_string):
-        if len(token_string) == 8:
-            return token_string
-        if not token_string.startswith('api_'):
-            raise ValueError('Invalid token format')
-        return token_string[4:][:8]
-
-    def verify_token(self, token_string):
-        """Verify if a token string matches this token."""
-        try:
-            parsed = self.parse_token(token_string)
-            if parsed['id'] != self.id:
-                return False
-            return bcrypt.checkpw(parsed['nonce'].encode('utf-8'), self.token.encode('utf-8'))
-        except ValueError:
+from datetime import datetime, timedelta
+import uuid
+import bcrypt
+import secrets
+import string
+from abc import ABC, abstractmethod
+
+def generate_random_string(length, alphabet=string.ascii_letters + string.digits):
+    """Generate a random string of specified length using the given alphabet."""
+    return ''.join(secrets.choice(alphabet) for _ in range(length))
+
+class IDGenerator(ABC):
+    @abstractmethod
+    def generate(self):
+        pass
+
+class UUIDGenerator(IDGenerator):
+    def generate(self):
+        return str(uuid.uuid4())
+
+class IntegerGenerator(IDGenerator):
+    def generate(self):
+        return None  # Let the database handle ID generation with SERIAL
+
+class User:
+    def __init__(self, username, email, real_name, roles=None, id_generator=None):
+        self.id = id_generator.generate() if id_generator else str(uuid.uuid4())
+        if self.id is None:  # Let database handle ID generation
+            self.id = None
+        self.username = username
+        self.email = email
+        self.real_name = real_name
+        self.roles = roles or []
+        self.created_at = datetime.utcnow()
+        self.updated_at = datetime.utcnow()
+
+class Role:
+    def __init__(self, name, description=None, id_generator=None):
+        self.id = id_generator.generate() if id_generator else str(uuid.uuid4())
+        self.name = name
+        self.description = description
+        self.created_at = datetime.utcnow()
+
+class ApiToken:
+    def __init__(self, user_id, name, expires_in_days=None):
+        self.id = generate_random_string(8)  # 8 character ID
+        self.user_id = user_id
+        self.name = name
+        self.nonce = generate_random_string(32)  # 32 character nonce
+        self.token = self._hash_nonce(self.nonce)  # Hash the nonce
+        self.created_at = datetime.utcnow()
+        self.expires_at = datetime.utcnow() + timedelta(days=expires_in_days) if expires_in_days else None
+        self.last_used_at = None
+
+    def _hash_nonce(self, nonce):
+        """Hash the nonce using bcrypt."""
+        salt = bcrypt.gensalt()
+        return bcrypt.hashpw(nonce.encode('utf-8'), salt).decode('utf-8')
+
+    def get_full_token(self):
+        """Get the full token string in the format api_IDNONCE."""
+        return f"api_{self.id}{self.nonce}"
+
+    @staticmethod
+    def parse_token(token_string):
+        """Parse a token string into its components."""
+        if not token_string.startswith('api_'):
+            raise ValueError('Invalid token format')
+        
+        token_string = token_string[4:]  # Remove 'api_' prefix
+        if len(token_string) != 40:  # 8 (id) + 32 (nonce)
+            raise ValueError('Invalid token length')
+        
+        return {
+            'id': token_string[:8],
+            'nonce': token_string[8:]
+        }
+
+    @staticmethod
+    def parse_token_id(token_string):
+        if len(token_string) == 8:
+            return token_string
+        if not token_string.startswith('api_'):
+            raise ValueError('Invalid token format')
+        return token_string[4:][:8]
+
+    def verify_token(self, token_string):
+        """Verify if a token string matches this token."""
+        try:
+            parsed = self.parse_token(token_string)
+            if parsed['id'] != self.id:
+                return False
+            return bcrypt.checkpw(parsed['nonce'].encode('utf-8'), self.token.encode('utf-8'))
+        except ValueError:
             return False 

{the37lab_authlib-0.1.1758263039.dist-info → the37lab_authlib-0.1.1758266466.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: the37lab_authlib
-Version: 0.1.1758263039
+Version: 0.1.1758266466
 Summary: Python SDK for the Authlib
 Author-email: the37lab <info@the37lab.com>
 Classifier: Programming Language :: Python :: 3

the37lab_authlib-0.1.1758266466.dist-info/RECORD

@@ -0,0 +1,10 @@
+the37lab_authlib/__init__.py,sha256=cFVTWL-0YIMqwOMVy1P8mOt_bQODJp-L9bfp2QQ8CTo,132
+the37lab_authlib/auth.py,sha256=3igW3vyWXY6Ec4A6WuE0btYZcIcnv0TfweRHQdEDcwQ,49336
+the37lab_authlib/db.py,sha256=cmnmykKvq6V5e-D0HGiRN4DjFBOGB-SL1HpFjR5uyCw,3162
+the37lab_authlib/decorators.py,sha256=L-gJUUwDUT2JXTptQ6XEey1LkI5RprbqzEfArWI7F8Y,1305
+the37lab_authlib/exceptions.py,sha256=mdplK5sKNtagPAzSGq5NGsrQ4r-k03DKJBKx6myWwZc,317
+the37lab_authlib/models.py,sha256=-PlvQlHGIsSdrH0H9Cdh_vTPlltGV8G1Z1mmGQvAg9Y,3422
+the37lab_authlib-0.1.1758266466.dist-info/METADATA,sha256=Za_SVsmAMryV_x8vOOjByTjRpgWUVFZ0zveBORf3Dqw,8339
+the37lab_authlib-0.1.1758266466.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+the37lab_authlib-0.1.1758266466.dist-info/top_level.txt,sha256=6Jmxw4UeLrhfJXgRKbXWY4OhxRSaMs0dKKhNCGWWSwc,17
+the37lab_authlib-0.1.1758266466.dist-info/RECORD,,

the37lab_authlib-0.1.1758263039.dist-info/RECORD

@@ -1,10 +0,0 @@
-the37lab_authlib/__init__.py,sha256=QxIyIyb-b2C91a9vSE05cFov-MFwprBnPLUTCz1rAGo,136
-the37lab_authlib/auth.py,sha256=3coNtCHg6sMIsTuWXNe8Ni147jmypCB_x-28AYq0ZMw,50484
-the37lab_authlib/db.py,sha256=w8OcWvFWA-MbWals--l64qx_iDQYxv85wKGT52GtNVo,3252
-the37lab_authlib/decorators.py,sha256=hCd6XSEREgeQ8XGJzlmKD-K8sQYbK7WgZCQKdY3m7ng,1337
-the37lab_authlib/exceptions.py,sha256=ONA64ktHAuj4w0ur4xUeWZQQmfZw9hHo4che1Bi-M3s,327
-the37lab_authlib/models.py,sha256=9-9ndGq-o9VGjHF8VvgMHvjhYOEapfOkocfjpqEFHY4,3516
-the37lab_authlib-0.1.1758263039.dist-info/METADATA,sha256=r4jwSFSiHkOrGQ8HJxvhDxcs0UzfILy_NS50Qwy93eU,8339
-the37lab_authlib-0.1.1758263039.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-the37lab_authlib-0.1.1758263039.dist-info/top_level.txt,sha256=6Jmxw4UeLrhfJXgRKbXWY4OhxRSaMs0dKKhNCGWWSwc,17
-the37lab_authlib-0.1.1758263039.dist-info/RECORD,,