adss 0.1__py3-none-any.whl → 1.1__py3-none-any.whl

adss/__init__.py

@@ -0,0 +1,24 @@
+"""
+Astronomy TAP Client - A Python client for interacting with the Astronomy TAP Service API.
+
+This package provides a comprehensive client for working with the Astronomy TAP Service,
+including authentication, query execution, user management, and administrative functions.
+"""
+
+__version__ = "0.1.0"
+
+from .client import ADSSClient
+from .exceptions import (
+    ADSSClientError, AuthenticationError, PermissionDeniedError, 
+    ResourceNotFoundError, QueryExecutionError
+)
+from .models.user import User, Role
+from .models.query import Query, QueryResult
+from .models.metadata import Schema, Table, Column
+
+__all__ = [
+    'ADSSClient',
+    'ADSSClientError', 'AuthenticationError', 'PermissionDeniedError',
+    'ResourceNotFoundError', 'QueryExecutionError',
+    'User', 'Role', 'Query', 'QueryResult', 'Schema', 'Table', 'Column'
+]

adss/adss_manager.py

@@ -0,0 +1,53 @@
+import requests
+import pprint
+import os
+
+import xml.etree.ElementTree as ET
+
+from adss.table import Table
+from adss.variables import BASEURL
+
+class ADSSManager:
+    def __init__(self):
+        self.tables = {}
+        
+    def load_tables(self):
+        res = requests.get(os.path.join(BASEURL, 'tables'))
+        
+        # Parse the XML
+        root = ET.fromstring(res.content)
+
+        # In this XML, the root element is in the "vosi" namespace but the child elements (schema, table, etc.)
+        # are unqualified (i.e. have no prefix). Thus, we can search for them without a namespace.
+        tables = []
+        for schema_elem in root.findall('schema'):
+            schema_name = schema_elem.find('name').text if schema_elem.find('name') is not None else None
+            
+            for table_elem in schema_elem.findall('table'):
+                table_name = table_elem.find('name').text if table_elem.find('name') is not None else None
+                columns = []
+                for col_elem in table_elem.findall('column'):
+                    col_name = col_elem.find('name').text if col_elem.find('name') is not None else None
+                    #dataType_elem = col_elem.find('dataType')
+                    #data_type = dataType_elem.text if dataType_elem is not None else None
+                    # The xsi:type attribute is in the XML namespace for xsi
+                    #xsi_type = dataType_elem.get('{http://www.w3.org/2001/XMLSchema-instance}type') if dataType_elem is not None else None
+                    columns.append(col_name)
+                
+                if schema_name == "public":
+                    name = table_name
+                else:
+                    name = f"{schema_name}.{table_name}"
+                    
+                tables.append(Table(name, columns))
+
+        self.tables = tables
+        
+    def print_tables(self):
+        pprint.pprint(self.tables)
+    
+    def get_table(self, name):
+        for table in self.tables:
+            if name in table.name:
+                return table
+        return None

adss/auth.py

@@ -0,0 +1,121 @@
+import requests
+from typing import Dict, Optional, Tuple
+
+from .exceptions import AuthenticationError
+from .utils import handle_response_errors
+from .models.user import User
+
+
+class Auth:
+    """
+    Handles authentication, token management, and HTTP requests for the TAP client.
+    """
+
+    def __init__(self, base_url: str, verify_ssl: bool = True):
+        self.base_url = base_url.rstrip('/')
+        self.token: Optional[str] = None
+        self.current_user: Optional[User] = None
+        self.verify_ssl = verify_ssl
+
+    def login(self, username: str, password: str, **kwargs) -> Tuple[str, User]:
+        """
+        Log in with username and password, obtaining an authentication token.
+        """
+        login_url = f"{self.base_url}/adss/v1/auth/login"
+        data = {"username": username, "password": password}
+
+        try:
+            # Use our own request() method here
+            response = self.request(
+                method="POST",
+                url=login_url,
+                auth_required=False,
+                data=data,
+                **kwargs
+            )
+            handle_response_errors(response)
+
+            token_data = response.json()
+            self.token = token_data.get("access_token")
+            if not self.token:
+                raise AuthenticationError("Login succeeded but no token returned")
+
+            # Now fetch user info (this will use auth_required=True internally)
+            self.current_user = self._get_current_user(**kwargs)
+            return self.token, self.current_user
+
+        except requests.RequestException as e:
+            raise AuthenticationError(f"Login failed: {e}")
+
+    def logout(self) -> None:
+        self.token = None
+        self.current_user = None
+
+    def is_authenticated(self) -> bool:
+        return self.token is not None
+
+    def _get_current_user(self, **kwargs) -> User:
+        """
+        Fetch the current user's information using the stored token.
+        """
+        if not self.token:
+            raise AuthenticationError("Not authenticated")
+
+        me_url = f"{self.base_url}/adss/v1/users/me"
+        auth_headers = self._get_auth_headers()
+
+        try:
+            # Again, use request() so SSL and auth headers are applied consistently
+            response = self.request(
+                method="GET",
+                url=me_url,
+                headers=auth_headers,
+                auth_required=True,
+                **kwargs
+            )
+            handle_response_errors(response)
+
+            user_data = response.json()
+            return User.from_dict(user_data)
+
+        except requests.RequestException as e:
+            raise AuthenticationError(f"Failed to get user info: {e}")
+
+    def _get_auth_headers(self) -> Dict[str, str]:
+        headers = {"Accept": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        auth_required: bool = False,
+        **kwargs
+    ) -> requests.Response:
+        """
+        Make an HTTP request with automatic base_url prefix, SSL config, and auth headers.
+        """
+        if auth_required and not self.is_authenticated():
+            raise AuthenticationError("Authentication required for this request")
+
+        # Prepend base_url if needed
+        if not url.startswith(('http://', 'https://')):
+            url = f"{self.base_url}/{url.lstrip('/')}"
+
+        # Merge headers
+        final_headers = self._get_auth_headers()
+        if headers:
+            final_headers.update(headers)
+
+        # Apply verify_ssl unless overridden
+        if 'verify' not in kwargs:
+            kwargs['verify'] = self.verify_ssl
+
+        return requests.request(method, url, headers=final_headers, **kwargs)
+
+    def refresh_user_info(self, **kwargs) -> User:
+        self.current_user = self._get_current_user(**kwargs)
+        return self.current_user