adss 1.31__tar.gz → 1.33__tar.gz

{adss-1.31 → adss-1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adss
-Version: 1.31
+Version: 1.33
 Summary: Astronomical Data Smart System
 Author-email: Gustavo Schwarz <gustavo.b.schwarz@gmail.com>
 Project-URL: Homepage, https://github.com/schwarzam/adss
@@ -9,6 +9,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyarrow
+Requires-Dist: httpx
 Requires-Dist: requests
 Requires-Dist: astropy
 Dynamic: license-file
@@ -178,3 +179,147 @@ cl.get_image_collections()
 ]
 ```
 
+And then to list the files in a collection:
+
+```python
+cl.list_files(1) ## pass the collection ID
+```
+
+```
+[
+{
+    'filename': 'SPLUS-s17s23_F515_swpweight.fz',
+    'full_path': '/dados/splus/SPLUS-s17s23 SPLUS-s17s23_F515_swpweight.fz',
+    'file_type': 'fz',
+    'ra_center': 316.45153076969416,
+    'dec_center': -21.580560694390957,
+    'width': 11000,
+    'height': 11000,
+    'pixel_scale': 0.55000000000008,
+    'hdus': 2,
+    'data_hdu': 1,
+    'object_name': 'SPLUS-s17s23',
+    'filter': 'F515',
+    'instrument': 'T80Cam',
+    'telescope': 'T80',
+    'date_obs': None,
+    'file_size': 51353280,
+    'id': 28,
+    'collection_id': 1,
+    'created_at': '2025-04-22T15:35:05.487208',
+    'updated_at': '2025-05-08T19:53:09.541437'},
+},...]
+```
+
+You can then download a file by its filename:
+
+```python
+file_bytes = cl.download_file(
+    file_id=28,
+    output_path=None
+)
+```
+
+Then handle the bytes. Example:
+
+```python
+# if a fits you may open like 
+import io
+from astropy.io import fits
+
+hdul = fits.open(io.BytesIO(file_bytes))
+
+# or a image 
+from PIL import Image
+import matplotlib.pyplot as plt
+
+image = Image.open(io.BytesIO(file_bytes))
+plt.imshow(image)
+```
+
+### Image Tools
+
+Now notice that (**if**) the image collection has some wcs parameters as `ra_center`, `dec_center`, `pixel_scale`. This allows us to do some image cutouts and colored images in real time. Example:
+
+```python
+cutout_bytes = cl.create_stamp_by_coordinates(
+    collection_id = 1, 
+    ra = 0.1, 
+    dec = 0.1, 
+    size = 300, 
+    filter = "R", 
+    size_unit="pixels", 
+    format = "fits", 
+    pattern="swp."
+)
+
+hdul = fits.open(BytesIO(cutout_bytes))
+```
+
+or if the image collection has object_name info you may filter by it, forcing the cutout from that object:
+
+```python
+cutout_bytes = cl.stamp_images.create_stamp_by_object(
+    collection_id=1, 
+    object_name="STRIPE82-0002", 
+    size=300, 
+    ra=0.1,
+    dec=0.1,
+    filter_name="R", 
+    size_unit="pixels", 
+    format="fits"
+)
+cutout = fits.open(BytesIO(cutout_bytes))
+```
+
+or just by file_id, this will force the cutout from that specific file:
+
+```python
+cl.stamp_images.create_stamp(
+    file_id=28,
+    size=300,
+    ra=0.1,
+    dec=0.1,
+    size_unit="pixels", 
+    format="fits"
+)
+```
+
+### Colored images 
+
+Colored images API is very similar to the cutouts. You just need to provide a list of filters and the output format (png or jpg). Example with lupton et al. (2004) algorithm:
+
+```python
+im_bytes = cl.create_rgb_image_by_coordinates(
+    collection_id=1,
+    ra=0.1,
+    dec=0.1,
+    size=300,
+    size_unit="pixels",
+    r_filter="I",
+    g_filter="R",
+    b_filter="G",
+)
+
+im = Image.open(BytesIO(im_bytes))
+im.show()
+```
+
+Or trilogy algorithm:
+
+```python
+im_bytes = cl.trilogy_images.create_trilogy_rgb_by_coordinates(
+    collection_id=1,
+    ra=0.1,
+    dec=0.1,
+    size=300,
+    size_unit="pixels",
+    r_filters=["I", "R", "Z", "F861", "G"],
+    g_filters=["F660"],
+    b_filters=["U", "F378", "F395", "F410", "F430", "F515"],
+    satpercent=0.15,
+)
+
+im = Image.open(BytesIO(im_bytes))
+im.show()
+```

{adss-1.31 → adss-1.33}/README.md

@@ -163,3 +163,147 @@ cl.get_image_collections()
 ]
 ```
 
+And then to list the files in a collection:
+
+```python
+cl.list_files(1) ## pass the collection ID
+```
+
+```
+[
+{
+    'filename': 'SPLUS-s17s23_F515_swpweight.fz',
+    'full_path': '/dados/splus/SPLUS-s17s23 SPLUS-s17s23_F515_swpweight.fz',
+    'file_type': 'fz',
+    'ra_center': 316.45153076969416,
+    'dec_center': -21.580560694390957,
+    'width': 11000,
+    'height': 11000,
+    'pixel_scale': 0.55000000000008,
+    'hdus': 2,
+    'data_hdu': 1,
+    'object_name': 'SPLUS-s17s23',
+    'filter': 'F515',
+    'instrument': 'T80Cam',
+    'telescope': 'T80',
+    'date_obs': None,
+    'file_size': 51353280,
+    'id': 28,
+    'collection_id': 1,
+    'created_at': '2025-04-22T15:35:05.487208',
+    'updated_at': '2025-05-08T19:53:09.541437'},
+},...]
+```
+
+You can then download a file by its filename:
+
+```python
+file_bytes = cl.download_file(
+    file_id=28,
+    output_path=None
+)
+```
+
+Then handle the bytes. Example:
+
+```python
+# if a fits you may open like 
+import io
+from astropy.io import fits
+
+hdul = fits.open(io.BytesIO(file_bytes))
+
+# or a image 
+from PIL import Image
+import matplotlib.pyplot as plt
+
+image = Image.open(io.BytesIO(file_bytes))
+plt.imshow(image)
+```
+
+### Image Tools
+
+Now notice that (**if**) the image collection has some wcs parameters as `ra_center`, `dec_center`, `pixel_scale`. This allows us to do some image cutouts and colored images in real time. Example:
+
+```python
+cutout_bytes = cl.create_stamp_by_coordinates(
+    collection_id = 1, 
+    ra = 0.1, 
+    dec = 0.1, 
+    size = 300, 
+    filter = "R", 
+    size_unit="pixels", 
+    format = "fits", 
+    pattern="swp."
+)
+
+hdul = fits.open(BytesIO(cutout_bytes))
+```
+
+or if the image collection has object_name info you may filter by it, forcing the cutout from that object:
+
+```python
+cutout_bytes = cl.stamp_images.create_stamp_by_object(
+    collection_id=1, 
+    object_name="STRIPE82-0002", 
+    size=300, 
+    ra=0.1,
+    dec=0.1,
+    filter_name="R", 
+    size_unit="pixels", 
+    format="fits"
+)
+cutout = fits.open(BytesIO(cutout_bytes))
+```
+
+or just by file_id, this will force the cutout from that specific file:
+
+```python
+cl.stamp_images.create_stamp(
+    file_id=28,
+    size=300,
+    ra=0.1,
+    dec=0.1,
+    size_unit="pixels", 
+    format="fits"
+)
+```
+
+### Colored images 
+
+Colored images API is very similar to the cutouts. You just need to provide a list of filters and the output format (png or jpg). Example with lupton et al. (2004) algorithm:
+
+```python
+im_bytes = cl.create_rgb_image_by_coordinates(
+    collection_id=1,
+    ra=0.1,
+    dec=0.1,
+    size=300,
+    size_unit="pixels",
+    r_filter="I",
+    g_filter="R",
+    b_filter="G",
+)
+
+im = Image.open(BytesIO(im_bytes))
+im.show()
+```
+
+Or trilogy algorithm:
+
+```python
+im_bytes = cl.trilogy_images.create_trilogy_rgb_by_coordinates(
+    collection_id=1,
+    ra=0.1,
+    dec=0.1,
+    size=300,
+    size_unit="pixels",
+    r_filters=["I", "R", "Z", "F861", "G"],
+    g_filters=["F660"],
+    b_filters=["U", "F378", "F395", "F410", "F430", "F515"],
+    satpercent=0.15,
+)
+
+im = Image.open(BytesIO(im_bytes))
+im.show()
+```

adss-1.33/adss/auth.py

@@ -0,0 +1,346 @@
+import os
+import time
+from typing import Dict, Optional, Tuple
+
+import requests  # kept for compatibility (exceptions/type expectations)
+import httpx
+
+from adss.exceptions import AuthenticationError
+from adss.utils import handle_response_errors
+from adss.models.user import User
+
+
+# --- internal defaults (safe timeouts; env-overridable) ---
+_CONNECT_TIMEOUT = float(os.getenv("ADSS_CONNECT_TIMEOUT", "5"))
+_READ_TIMEOUT    = float(os.getenv("ADSS_READ_TIMEOUT", "600"))
+_DEFAULT_TIMEOUT = (_CONNECT_TIMEOUT, _READ_TIMEOUT)
+
+_TOTAL_RETRIES   = int(os.getenv("ADSS_RETRY_TOTAL", "3"))
+_BACKOFF_FACTOR  = float(os.getenv("ADSS_RETRY_BACKOFF", "0.5"))
+_TRUST_ENV       = os.getenv("ADSS_TRUST_ENV", "1").lower() not in ("0", "false", "no")
+_FORCE_CLOSE_STREAMS = os.getenv("ADSS_FORCE_CLOSE_STREAMS", "0").lower() in ("1", "true", "yes")
+
+
+def _to_httpx_timeout(t):
+    """Map (connect, read) tuple or scalar into httpx.Timeout."""
+    if isinstance(t, tuple) and len(t) == 2:
+        connect, read = t
+        return httpx.Timeout(connect=connect, read=read, write=read, pool=connect)
+    if isinstance(t, (int, float)):
+        return httpx.Timeout(t)
+    return httpx.Timeout(connect=_CONNECT_TIMEOUT, read=_READ_TIMEOUT, write=_READ_TIMEOUT, pool=_CONNECT_TIMEOUT)
+
+
+def _attach_requests_compat(resp: httpx.Response) -> httpx.Response:
+    """
+    Attach requests-like helpers so existing code doesn't break:
+    - iter_content(chunk_size) -> yields bytes
+    - raw.read([n]) -> bytes (returns remaining body)
+    """
+    if not hasattr(resp, "iter_content"):
+        def iter_content(chunk_size: int = 1024 * 1024):
+            return resp.iter_bytes(chunk_size=chunk_size)
+        setattr(resp, "iter_content", iter_content)
+
+    if not hasattr(resp, "raw"):
+        class _RawAdapter:
+            def __init__(self, r: httpx.Response):
+                self._r = r
+            def read(self, amt: Optional[int] = None) -> bytes:
+                # httpx sync API doesn't expose partial read; return remaining.
+                return self._r.read()
+        setattr(resp, "raw", _RawAdapter(resp))
+
+    return resp
+
+
+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
+
+        # Single keep-alive client; set verify at construction.
+        self._client = httpx.Client(trust_env=_TRUST_ENV, verify=self.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:
+            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")
+
+            self.current_user = self._get_current_user(**kwargs)
+            return self.token, self.current_user
+
+        except httpx.RequestError as e:
+            # preserve existing caller except-blocks that catch requests.RequestException
+            raise requests.RequestException(str(e))  # noqa: B904
+
+    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:
+            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 httpx.RequestError as e:
+            raise requests.RequestException(str(e))  # noqa: B904
+
+    def _get_auth_headers(self) -> Dict[str, str]:
+        headers = {"Accept": "application/json"}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    # ---------------- core helpers ---------------- #
+
+    def _full_url(self, url: str) -> str:
+        return url if url.startswith(('http://', 'https://')) else f"{self.base_url}/{url.lstrip('/')}"
+
+    def _request_with_retries_nonstream(
+        self,
+        *,
+        method: str,
+        url: str,
+        headers: Dict[str, str],
+        params=None,
+        data=None,
+        json=None,
+        files=None,
+        timeout: httpx.Timeout,
+        follow_redirects: bool,
+    ) -> httpx.Response:
+        last_exc = None
+        for attempt in range(_TOTAL_RETRIES + 1):
+            try:
+                return self._client.request(
+                    method=method.upper(),
+                    url=url,
+                    headers=headers,
+                    params=params,
+                    data=data,
+                    json=json,
+                    files=files,
+                    follow_redirects=follow_redirects,
+                    timeout=timeout,
+                )
+            except httpx.RequestError as e:
+                last_exc = e
+                if attempt >= _TOTAL_RETRIES:
+                    break
+                time.sleep(_BACKOFF_FACTOR * (2 ** attempt))
+        raise requests.RequestException(str(last_exc))  # noqa: B904
+
+    def _request_with_retries_stream(
+        self,
+        *,
+        method: str,
+        url: str,
+        headers: Dict[str, str],
+        params=None,
+        data=None,
+        json=None,
+        files=None,
+        timeout: httpx.Timeout,
+        follow_redirects: bool,
+    ) -> httpx.Response:
+        """
+        Use client.stream(...) but keep the stream open for the caller.
+        We manually __enter__ the context manager and override resp.close()
+        to ensure resources are cleaned when caller closes the response.
+        """
+        last_exc = None
+        for attempt in range(_TOTAL_RETRIES + 1):
+            try:
+                cm = self._client.stream(
+                    method=method.upper(),
+                    url=url,
+                    headers=headers,
+                    params=params,
+                    data=data,
+                    json=json,
+                    files=files,
+                    follow_redirects=follow_redirects,
+                    timeout=timeout,
+                )
+                resp = cm.__enter__()  # don't exit: let caller iterate/close
+                # Make close() also exit the context manager safely
+                _orig_close = resp.close
+                def _close():
+                    try:
+                        _orig_close()
+                    finally:
+                        try:
+                            cm.__exit__(None, None, None)
+                        except Exception:
+                            pass
+                resp.close = _close  # type: ignore[attr-defined]
+                return resp
+            except httpx.RequestError as e:
+                last_exc = e
+                if attempt >= _TOTAL_RETRIES:
+                    break
+                time.sleep(_BACKOFF_FACTOR * (2 ** attempt))
+        raise requests.RequestException(str(last_exc))  # noqa: B904
+
+    # ---------------- public API (unchanged signatures) ------------------- #
+
+    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")
+
+        url = self._full_url(url)
+
+        # Merge headers
+        final_headers = self._get_auth_headers()
+        if headers:
+            final_headers.update(headers)
+
+        # Map requests-style kwargs to httpx
+        timeout   = _to_httpx_timeout(kwargs.pop('timeout', _DEFAULT_TIMEOUT))
+        follow_redirects = kwargs.pop('allow_redirects', True)
+        stream_flag = bool(kwargs.pop('stream', False))
+
+        # (verify is fixed per-client at __init__; ignore/strip any incoming 'verify' kw)
+        kwargs.pop('verify', None)
+
+        # Build payload pieces compatibly
+        params = kwargs.pop('params', None)
+        data   = kwargs.pop('data', None)
+        json_  = kwargs.pop('json', None)
+        files  = kwargs.pop('files', None)
+
+        if stream_flag:
+            resp = self._request_with_retries_stream(
+                method=method,
+                url=url,
+                headers=final_headers,
+                params=params,
+                data=data,
+                json=json_,
+                files=files,
+                timeout=timeout,
+                follow_redirects=follow_redirects,
+            )
+        else:
+            resp = self._request_with_retries_nonstream(
+                method=method,
+                url=url,
+                headers=final_headers,
+                params=params,
+                data=data,
+                json=json_,
+                files=files,
+                timeout=timeout,
+                follow_redirects=follow_redirects,
+            )
+        return _attach_requests_compat(resp)
+
+    def refresh_user_info(self, **kwargs) -> User:
+        self.current_user = self._get_current_user(**kwargs)
+        return self.current_user
+
+    def download(
+        self,
+        method: str,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        auth_required: bool = False,
+        **kwargs
+    ) -> requests.Response:
+        """
+        Like request(), but always streams the body.
+        Caller can iterate over response.iter_content() or
+        call response.raw.read() for large files.
+
+        Signature is identical to request(), so you can just
+        swap `request` -> `download` in call sites.
+        """
+        if auth_required and not self.is_authenticated():
+            raise AuthenticationError("Authentication required for this request")
+
+        url = self._full_url(url)
+
+        # Merge headers
+        final_headers = self._get_auth_headers()
+        if headers:
+            final_headers.update(headers)
+        if _FORCE_CLOSE_STREAMS:
+            final_headers.setdefault("Connection", "close")
+
+        timeout   = _to_httpx_timeout(kwargs.pop('timeout', _DEFAULT_TIMEOUT))
+        follow_redirects = kwargs.pop('allow_redirects', True)
+        kwargs.pop('verify', None)  # verify is fixed on client
+
+        params = kwargs.pop('params', None)
+        data   = kwargs.pop('data', None)
+        json_  = kwargs.pop('json', None)
+        files  = kwargs.pop('files', None)
+
+        resp = self._request_with_retries_stream(
+            method=method,
+            url=url,
+            headers=final_headers,
+            params=params,
+            data=data,
+            json=json_,
+            files=files,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+        )
+        handle_response_errors(resp)  # fail fast on HTTP errors
+        return _attach_requests_compat(resp)

{adss-1.31 → adss-1.33}/adss/client.py

@@ -516,7 +516,7 @@ class ADSSClient:
         """
         return self.images.cone_search(collection_id, ra, dec, radius, filter_name, limit, **kwargs)
     
-    def download_image(self, file_id: int, output_path: Optional[str] = None, **kwargs) -> Union[bytes, str]:
+    def download_file(self, file_id: int, output_path: Optional[str] = None, **kwargs) -> Union[bytes, str]:
         """
         Download an image file.
         

{adss-1.31 → adss-1.33}/adss/endpoints/images.py

@@ -160,7 +160,7 @@ class ImagesEndpoint:
                     for chunk in resp.iter_content(8192):
                         f.write(chunk)
                 return output_path
-            return resp.content
+            return resp.read()
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to download image file {file_id}: {e}")
 
@@ -220,9 +220,9 @@ class LuptonImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create RGB image: {e}")
@@ -293,9 +293,9 @@ class LuptonImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create RGB image by filenames: {e}")
@@ -340,9 +340,9 @@ class LuptonImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create RGB image by coordinates: {e}")
@@ -395,9 +395,9 @@ class LuptonImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create RGB image by object: {e}")
@@ -451,9 +451,9 @@ class StampImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create stamp from file {file_id}: {e}")
@@ -516,9 +516,9 @@ class StampImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create stamp from file {filename}: {e}")
@@ -566,9 +566,9 @@ class StampImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create stamp by coordinates: {e}")
@@ -618,9 +618,9 @@ class StampImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create stamp by object: {e}")
@@ -682,9 +682,9 @@ class TrilogyImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create Trilogy RGB image: {e}")
@@ -731,9 +731,9 @@ class TrilogyImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
+                    f.write(resp.read())
                 return output_path
-            return resp.content
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create Trilogy RGB image by coordinates: {e}")
@@ -787,9 +787,9 @@ class TrilogyImagesEndpoint:
                 output_path = os.path.join(output_path, filename)
             if output_path:
                 with open(output_path, 'wb') as f:
-                    f.write(resp.content)
-                return resp.content
-            return resp.content
+                    f.write(resp.read())
+                return resp.read()
+            return resp.read()
 
         except Exception as e:
             raise ResourceNotFoundError(f"Failed to create Trilogy RGB image by object: {e}")

{adss-1.31 → adss-1.33}/adss/endpoints/queries.py

@@ -116,7 +116,7 @@ class QueriesEndpoint:
             )
             
             # Parse Parquet data
-            df = parquet_to_dataframe(response.content)
+            df = parquet_to_dataframe(response.read())
             
             return QueryResult(
                 query=query_obj,
@@ -280,7 +280,7 @@ class QueriesEndpoint:
             handle_response_errors(response)
             
             # Parse Parquet data
-            df = parquet_to_dataframe(response.content)
+            df = parquet_to_dataframe(response.read())
             
             # Extract metadata
             expires_at = response.headers.get('X-Expires-At')

{adss-1.31 → adss-1.33}/adss/utils.py

@@ -19,7 +19,7 @@ def handle_response_errors(response):
         return response
     
     try:
-        error_data = response.json()
+        error_data = response.read()
         error_message = error_data.get('detail', str(error_data))
     except Exception:
         error_message = response.text or f"HTTP Error {response.status_code}"

{adss-1.31 → adss-1.33}/adss.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adss
-Version: 1.31
+Version: 1.33
 Summary: Astronomical Data Smart System
 Author-email: Gustavo Schwarz <gustavo.b.schwarz@gmail.com>
 Project-URL: Homepage, https://github.com/schwarzam/adss
@@ -9,6 +9,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyarrow
+Requires-Dist: httpx
 Requires-Dist: requests
 Requires-Dist: astropy
 Dynamic: license-file
@@ -178,3 +179,147 @@ cl.get_image_collections()
 ]
 ```
 
+And then to list the files in a collection:
+
+```python
+cl.list_files(1) ## pass the collection ID
+```
+
+```
+[
+{
+    'filename': 'SPLUS-s17s23_F515_swpweight.fz',
+    'full_path': '/dados/splus/SPLUS-s17s23 SPLUS-s17s23_F515_swpweight.fz',
+    'file_type': 'fz',
+    'ra_center': 316.45153076969416,
+    'dec_center': -21.580560694390957,
+    'width': 11000,
+    'height': 11000,
+    'pixel_scale': 0.55000000000008,
+    'hdus': 2,
+    'data_hdu': 1,
+    'object_name': 'SPLUS-s17s23',
+    'filter': 'F515',
+    'instrument': 'T80Cam',
+    'telescope': 'T80',
+    'date_obs': None,
+    'file_size': 51353280,
+    'id': 28,
+    'collection_id': 1,
+    'created_at': '2025-04-22T15:35:05.487208',
+    'updated_at': '2025-05-08T19:53:09.541437'},
+},...]
+```
+
+You can then download a file by its filename:
+
+```python
+file_bytes = cl.download_file(
+    file_id=28,
+    output_path=None
+)
+```
+
+Then handle the bytes. Example:
+
+```python
+# if a fits you may open like 
+import io
+from astropy.io import fits
+
+hdul = fits.open(io.BytesIO(file_bytes))
+
+# or a image 
+from PIL import Image
+import matplotlib.pyplot as plt
+
+image = Image.open(io.BytesIO(file_bytes))
+plt.imshow(image)
+```
+
+### Image Tools
+
+Now notice that (**if**) the image collection has some wcs parameters as `ra_center`, `dec_center`, `pixel_scale`. This allows us to do some image cutouts and colored images in real time. Example:
+
+```python
+cutout_bytes = cl.create_stamp_by_coordinates(
+    collection_id = 1, 
+    ra = 0.1, 
+    dec = 0.1, 
+    size = 300, 
+    filter = "R", 
+    size_unit="pixels", 
+    format = "fits", 
+    pattern="swp."
+)
+
+hdul = fits.open(BytesIO(cutout_bytes))
+```
+
+or if the image collection has object_name info you may filter by it, forcing the cutout from that object:
+
+```python
+cutout_bytes = cl.stamp_images.create_stamp_by_object(
+    collection_id=1, 
+    object_name="STRIPE82-0002", 
+    size=300, 
+    ra=0.1,
+    dec=0.1,
+    filter_name="R", 
+    size_unit="pixels", 
+    format="fits"
+)
+cutout = fits.open(BytesIO(cutout_bytes))
+```
+
+or just by file_id, this will force the cutout from that specific file:
+
+```python
+cl.stamp_images.create_stamp(
+    file_id=28,
+    size=300,
+    ra=0.1,
+    dec=0.1,
+    size_unit="pixels", 
+    format="fits"
+)
+```
+
+### Colored images 
+
+Colored images API is very similar to the cutouts. You just need to provide a list of filters and the output format (png or jpg). Example with lupton et al. (2004) algorithm:
+
+```python
+im_bytes = cl.create_rgb_image_by_coordinates(
+    collection_id=1,
+    ra=0.1,
+    dec=0.1,
+    size=300,
+    size_unit="pixels",
+    r_filter="I",
+    g_filter="R",
+    b_filter="G",
+)
+
+im = Image.open(BytesIO(im_bytes))
+im.show()
+```
+
+Or trilogy algorithm:
+
+```python
+im_bytes = cl.trilogy_images.create_trilogy_rgb_by_coordinates(
+    collection_id=1,
+    ra=0.1,
+    dec=0.1,
+    size=300,
+    size_unit="pixels",
+    r_filters=["I", "R", "Z", "F861", "G"],
+    g_filters=["F660"],
+    b_filters=["U", "F378", "F395", "F410", "F430", "F515"],
+    satpercent=0.15,
+)
+
+im = Image.open(BytesIO(im_bytes))
+im.show()
+```

{adss-1.31 → adss-1.33}/adss.egg-info/requires.txt

@@ -1,3 +1,4 @@
 pyarrow
+httpx
 requests
 astropy

{adss-1.31 → adss-1.33}/pyproject.toml

@@ -4,13 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "adss"
-version = "1.31"
+version = "1.33"
 description = "Astronomical Data Smart System"
 readme = "README.md"
 authors = [{ name = "Gustavo Schwarz", email = "gustavo.b.schwarz@gmail.com" }]
 requires-python = ">=3.8"
 dependencies = [
   "pyarrow",
+  "httpx",
   "requests",
   "astropy"
 ]

adss-1.31/adss/auth.py

@@ -1,162 +0,0 @@
-import requests
-from typing import Dict, Optional, Tuple
-
-from adss.exceptions import AuthenticationError
-from adss.utils import handle_response_errors
-from adss.models.user import User
-
-import os
-
-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
-    
-    def download(
-        self,
-        method: str,
-        url: str,
-        headers: Optional[Dict[str, str]] = None,
-        auth_required: bool = False,
-        **kwargs
-    ) -> requests.Response:
-        """
-        Like request(), but always streams the body.
-        Caller can iterate over response.iter_content() or
-        call response.raw.read() for large files.
-
-        Signature is identical to request(), so you can just
-        swap `request` -> `download` in call sites.
-        """
-        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
-
-        # Force streaming
-        kwargs['stream'] = True
-
-        resp = requests.request(method, url, headers=final_headers, **kwargs)
-        handle_response_errors(resp)  # fail fast on HTTP errors
-
-        return resp