adss 1.30__tar.gz → 1.32__tar.gz

adss-1.32/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: adss
+Version: 1.32
+Summary: Astronomical Data Smart System
+Author-email: Gustavo Schwarz <gustavo.b.schwarz@gmail.com>
+Project-URL: Homepage, https://github.com/schwarzam/adss
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyarrow
+Requires-Dist: requests
+Requires-Dist: astropy
+Dynamic: license-file
+
+# ADSS
+Astronomical Data Smart System
+
+ADSS is a database/server project that provides access to ADSS compatible astronomical services.
+
+This repository provides a set of tools for querying astronomical ADSS services using ADQL. You can perform cone searches, cross-match queries between tables, and even cross-match against user-supplied data. The library supports both synchronous and asynchronous query execution. Download of images, cutouts, colored images and spectra is also supported.
+
+Github repository: [https://github.com/schwarzam/adss](https://github.com/schwarzam/adss)
+
+## Installation
+
+```bash
+pip install adss
+```
+
+or
+
+```bash
+git clone https://github.com/schwarzam/adss.git
+cd adss
+pip install .
+```
+
+
+### About ADSS compatible services
+
+ADSS is a project that is still under development. Currently, some of the ADSS services are available at [https://ai-scope.cbpf.br/](https://ai-scope.cbpf.br/) and [https://splus.cloud/](https://splus.cloud/). 
+
+### New Features
+
+ADSS supports different queries, including cone searches, cross-matches between tables, and cross-matches against user-supplied data. The library supports both synchronous and asynchronous query execution.
+
+Also some improvements in the ADQL parsing were made, allowing queries with wildcards in the SELECT statement, such as:
+
+```sql
+SELECT psf_* FROM my_table WHERE CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', 150.0, 2.0, 0.1))=1
+```
+
+This will select all columns that start with "psf_".
+
+
+### Starting a client
+
+To start using ADSS, you need to initialize a client with the base URL of the ADSS service and your credentials. Here's an example:
+
+```python
+import adss
+
+cl = adss.ADSSClient(
+    base_url="https://ai-scope.cbpf.br/", 
+    username="your_username",
+    password="your_password"
+)
+```
+
+The client will handle authentication and session management for you. 
+
+### Performing Queries
+
+You can perform various types of queries using the client. ADSS inherited a lot of the concept of the Table Access Protocol (TAP). Specially the sync and async modes of queries. 
+
+- **Synchronous Queries** (Short Lived Queries): These queries are executed immediately, and the results are returned in the body of the first request if found! With a timeout of ~10 seconds usually. Good for small tables or queries that return a small number of rows <1000. Example:
+
+```python
+cl.query(
+"""
+select * 
+from my_table 
+where CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', 150.0, 2.0, 0.1))=1
+"""
+)
+```
+
+- **Asynchronous Queries**: These queries are executed in the background, and you can check the status of the query and retrieve the results once they are ready. Good for large tables or queries that return a large number of rows or long queries.
+
+We have two ways of doing async queries. This first send the query to the server and wait until it's done. Example:
+
+```python
+tab = cl.query_and_wait(
+    query_text="""
+    select top 100 * 
+    from splus.splus_idr6 where field = 'HYDRA-0091'
+    """,
+    mode="adql", # or sql
+    file=None, # dataframe
+    table_name=None,
+)
+# Print the dataframe
+print(tab.data)
+```
+
+The second way is a more controlled way, where you create the query, check the status and fetch the when you want results:
+
+```python
+
+# Create a asynchronous query
+query = cl.async_query(
+    query_text="""
+    select top 100 id, ra, dec, mag_psf* 
+    from splus.splus_idr6 where field = 'HYDRA-0091'
+    """, 
+    mode="adql", # or sql
+    file=None, # dataframe
+    table_name=None, 
+)
+
+# Check the status of the query and fetch results if complete
+query = cl.queries.get_status(query.id)
+if query.is_complete:
+    print("Query is complete. Fetching results...")
+    results = cl.queries.get_results(query.id)
+else:
+    print("Query is not complete yet.")
+
+```
+
+### Uploading user tables
+
+In the last example we left the `file` and `table_name` parameters as `None`. This means that we are not uploading any user table to the server. If you want to upload a user table, you can do it by passing a pandas DataFrame to the `file` parameter and a name for the table to the `table_name` parameter. **The uploaded table should be referenced as upload.`table_name` in the query.**.
+
+```python
+import pandas as pd
+# Create a sample dataframe
+data = {
+    "id": [1, 2, 3],
+    "ra": [150.1, 150.2, 150.3],
+    "dec": [2.1, 2.2, 2.3]
+}
+df = pd.DataFrame(data)
+
+# Create a asynchronous query with user table
+query = cl.query_and_wait(
+    query_text="""
+        select a.*, b.mag_psf_r 
+        from upload.my_table as a
+        join splus.splus_idr6 as b on a.id = b.id
+    """,
+    mode="adql", # or sql
+    file=df, # dataframe
+    table_name="my_table",
+)
+
+### Images - File Collections
+
+ADSS also supports downloading images, cutouts, colored images. These are handled as Collections. You can list the available file collections in the database metadata:
+
+```python
+cl.get_image_collections()
+```
+
+```
+[
+{
+    'name': 'splus dr4',
+    'path': '/dados/splus',
+    'description': 'splus dr4 collection',
+    'id': 1,
+    'created_at': '2025-04-22T15:27:36.698058',
+    'updated_at': '2025-07-31T23:27:51.497554',
+    'last_scanned': '2025-05-08T20:28:54.420350',
+    'patterns': {'': 'swp.', 'weight': 'weight'}
+}
+]
+```
+
+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
+cl.images.download_file("SPLUS-s17s23_F515_swpweight.fz", download_path=".")
+```

adss-1.32/README.md

@@ -0,0 +1,202 @@
+# ADSS
+Astronomical Data Smart System
+
+ADSS is a database/server project that provides access to ADSS compatible astronomical services.
+
+This repository provides a set of tools for querying astronomical ADSS services using ADQL. You can perform cone searches, cross-match queries between tables, and even cross-match against user-supplied data. The library supports both synchronous and asynchronous query execution. Download of images, cutouts, colored images and spectra is also supported.
+
+Github repository: [https://github.com/schwarzam/adss](https://github.com/schwarzam/adss)
+
+## Installation
+
+```bash
+pip install adss
+```
+
+or
+
+```bash
+git clone https://github.com/schwarzam/adss.git
+cd adss
+pip install .
+```
+
+
+### About ADSS compatible services
+
+ADSS is a project that is still under development. Currently, some of the ADSS services are available at [https://ai-scope.cbpf.br/](https://ai-scope.cbpf.br/) and [https://splus.cloud/](https://splus.cloud/). 
+
+### New Features
+
+ADSS supports different queries, including cone searches, cross-matches between tables, and cross-matches against user-supplied data. The library supports both synchronous and asynchronous query execution.
+
+Also some improvements in the ADQL parsing were made, allowing queries with wildcards in the SELECT statement, such as:
+
+```sql
+SELECT psf_* FROM my_table WHERE CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', 150.0, 2.0, 0.1))=1
+```
+
+This will select all columns that start with "psf_".
+
+
+### Starting a client
+
+To start using ADSS, you need to initialize a client with the base URL of the ADSS service and your credentials. Here's an example:
+
+```python
+import adss
+
+cl = adss.ADSSClient(
+    base_url="https://ai-scope.cbpf.br/", 
+    username="your_username",
+    password="your_password"
+)
+```
+
+The client will handle authentication and session management for you. 
+
+### Performing Queries
+
+You can perform various types of queries using the client. ADSS inherited a lot of the concept of the Table Access Protocol (TAP). Specially the sync and async modes of queries. 
+
+- **Synchronous Queries** (Short Lived Queries): These queries are executed immediately, and the results are returned in the body of the first request if found! With a timeout of ~10 seconds usually. Good for small tables or queries that return a small number of rows <1000. Example:
+
+```python
+cl.query(
+"""
+select * 
+from my_table 
+where CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', 150.0, 2.0, 0.1))=1
+"""
+)
+```
+
+- **Asynchronous Queries**: These queries are executed in the background, and you can check the status of the query and retrieve the results once they are ready. Good for large tables or queries that return a large number of rows or long queries.
+
+We have two ways of doing async queries. This first send the query to the server and wait until it's done. Example:
+
+```python
+tab = cl.query_and_wait(
+    query_text="""
+    select top 100 * 
+    from splus.splus_idr6 where field = 'HYDRA-0091'
+    """,
+    mode="adql", # or sql
+    file=None, # dataframe
+    table_name=None,
+)
+# Print the dataframe
+print(tab.data)
+```
+
+The second way is a more controlled way, where you create the query, check the status and fetch the when you want results:
+
+```python
+
+# Create a asynchronous query
+query = cl.async_query(
+    query_text="""
+    select top 100 id, ra, dec, mag_psf* 
+    from splus.splus_idr6 where field = 'HYDRA-0091'
+    """, 
+    mode="adql", # or sql
+    file=None, # dataframe
+    table_name=None, 
+)
+
+# Check the status of the query and fetch results if complete
+query = cl.queries.get_status(query.id)
+if query.is_complete:
+    print("Query is complete. Fetching results...")
+    results = cl.queries.get_results(query.id)
+else:
+    print("Query is not complete yet.")
+
+```
+
+### Uploading user tables
+
+In the last example we left the `file` and `table_name` parameters as `None`. This means that we are not uploading any user table to the server. If you want to upload a user table, you can do it by passing a pandas DataFrame to the `file` parameter and a name for the table to the `table_name` parameter. **The uploaded table should be referenced as upload.`table_name` in the query.**.
+
+```python
+import pandas as pd
+# Create a sample dataframe
+data = {
+    "id": [1, 2, 3],
+    "ra": [150.1, 150.2, 150.3],
+    "dec": [2.1, 2.2, 2.3]
+}
+df = pd.DataFrame(data)
+
+# Create a asynchronous query with user table
+query = cl.query_and_wait(
+    query_text="""
+        select a.*, b.mag_psf_r 
+        from upload.my_table as a
+        join splus.splus_idr6 as b on a.id = b.id
+    """,
+    mode="adql", # or sql
+    file=df, # dataframe
+    table_name="my_table",
+)
+
+### Images - File Collections
+
+ADSS also supports downloading images, cutouts, colored images. These are handled as Collections. You can list the available file collections in the database metadata:
+
+```python
+cl.get_image_collections()
+```
+
+```
+[
+{
+    'name': 'splus dr4',
+    'path': '/dados/splus',
+    'description': 'splus dr4 collection',
+    'id': 1,
+    'created_at': '2025-04-22T15:27:36.698058',
+    'updated_at': '2025-07-31T23:27:51.497554',
+    'last_scanned': '2025-05-08T20:28:54.420350',
+    'patterns': {'': 'swp.', 'weight': 'weight'}
+}
+]
+```
+
+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
+cl.images.download_file("SPLUS-s17s23_F515_swpweight.fz", download_path=".")
+```

{adss-1.30 → adss-1.32}/adss/client.py

@@ -450,7 +450,7 @@ class ADSSClient:
     
     # === Image methods ===
     
-    def get_image_collections(self, skip: int = 0, limit: int = 100, **kwargs) -> List[Dict[str, Any]]:
+    def get_collections(self, skip: int = 0, limit: int = 100, **kwargs) -> List[Dict[str, Any]]:
         """
         Get a list of accessible image collections.
         
@@ -464,7 +464,7 @@ class ADSSClient:
         """
         return self.images.get_collections(skip, limit, **kwargs)
     
-    def get_image_collection(self, collection_id: int, **kwargs) -> Dict[str, Any]:
+    def get_collection(self, collection_id: int, **kwargs) -> Dict[str, Any]:
         """
         Get a specific image collection by ID.
         
@@ -477,7 +477,7 @@ class ADSSClient:
         """
         return self.images.get_collection(collection_id, **kwargs)
     
-    def list_image_files(self, collection_id: int, skip: int = 0, limit: int = 100, 
+    def list_files(self, collection_id: int, skip: int = 0, limit: int = 100, 
                         filter_name: Optional[str] = None, filter_str: Optional[str] = None,
                         object_name: Optional[str] = None, **kwargs) -> List[Dict[str, Any]]:
         """
@@ -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.30 → adss-1.32}/adss/endpoints/images.py

@@ -25,7 +25,7 @@ class ImagesEndpoint:
         params = {"skip": skip, "limit": limit}
 
         try:
-            resp = self.auth_manager.download(
+            resp = self.auth_manager.request(
                 method="GET",
                 url=url,
                 headers=headers,
@@ -46,7 +46,7 @@ class ImagesEndpoint:
             headers = {"Accept": "application/json"}
 
         try:
-            resp = self.auth_manager.download(
+            resp = self.auth_manager.request(
                 method="GET",
                 url=url,
                 headers=headers,

{adss-1.30 → adss-1.32}/adss/models/query.py

@@ -90,6 +90,19 @@ class Query:
     def is_failed(self) -> bool:
         """Check if the query failed."""
         return self.status == 'failed'
+    
+    def report(self) -> None:
+        """Print a summary of the query."""
+        print(f"Query ID: {self.id}")
+        print(f"Status: {self.status}")
+        if self.completed_at:
+            print(f"Completed At: {self.completed_at}")
+        if self.execution_time_ms is not None:
+            print(f"Execution Time (ms): {self.execution_time_ms}")
+        if self.row_count is not None:
+            print(f"Row Count: {self.row_count}")
+        if self.error:
+            print(f"Error: {self.error}")
 
 
 @dataclass

adss-1.32/adss.egg-info/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: adss
+Version: 1.32
+Summary: Astronomical Data Smart System
+Author-email: Gustavo Schwarz <gustavo.b.schwarz@gmail.com>
+Project-URL: Homepage, https://github.com/schwarzam/adss
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyarrow
+Requires-Dist: requests
+Requires-Dist: astropy
+Dynamic: license-file
+
+# ADSS
+Astronomical Data Smart System
+
+ADSS is a database/server project that provides access to ADSS compatible astronomical services.
+
+This repository provides a set of tools for querying astronomical ADSS services using ADQL. You can perform cone searches, cross-match queries between tables, and even cross-match against user-supplied data. The library supports both synchronous and asynchronous query execution. Download of images, cutouts, colored images and spectra is also supported.
+
+Github repository: [https://github.com/schwarzam/adss](https://github.com/schwarzam/adss)
+
+## Installation
+
+```bash
+pip install adss
+```
+
+or
+
+```bash
+git clone https://github.com/schwarzam/adss.git
+cd adss
+pip install .
+```
+
+
+### About ADSS compatible services
+
+ADSS is a project that is still under development. Currently, some of the ADSS services are available at [https://ai-scope.cbpf.br/](https://ai-scope.cbpf.br/) and [https://splus.cloud/](https://splus.cloud/). 
+
+### New Features
+
+ADSS supports different queries, including cone searches, cross-matches between tables, and cross-matches against user-supplied data. The library supports both synchronous and asynchronous query execution.
+
+Also some improvements in the ADQL parsing were made, allowing queries with wildcards in the SELECT statement, such as:
+
+```sql
+SELECT psf_* FROM my_table WHERE CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', 150.0, 2.0, 0.1))=1
+```
+
+This will select all columns that start with "psf_".
+
+
+### Starting a client
+
+To start using ADSS, you need to initialize a client with the base URL of the ADSS service and your credentials. Here's an example:
+
+```python
+import adss
+
+cl = adss.ADSSClient(
+    base_url="https://ai-scope.cbpf.br/", 
+    username="your_username",
+    password="your_password"
+)
+```
+
+The client will handle authentication and session management for you. 
+
+### Performing Queries
+
+You can perform various types of queries using the client. ADSS inherited a lot of the concept of the Table Access Protocol (TAP). Specially the sync and async modes of queries. 
+
+- **Synchronous Queries** (Short Lived Queries): These queries are executed immediately, and the results are returned in the body of the first request if found! With a timeout of ~10 seconds usually. Good for small tables or queries that return a small number of rows <1000. Example:
+
+```python
+cl.query(
+"""
+select * 
+from my_table 
+where CONTAINS(POINT('ICRS', ra, dec), CIRCLE('ICRS', 150.0, 2.0, 0.1))=1
+"""
+)
+```
+
+- **Asynchronous Queries**: These queries are executed in the background, and you can check the status of the query and retrieve the results once they are ready. Good for large tables or queries that return a large number of rows or long queries.
+
+We have two ways of doing async queries. This first send the query to the server and wait until it's done. Example:
+
+```python
+tab = cl.query_and_wait(
+    query_text="""
+    select top 100 * 
+    from splus.splus_idr6 where field = 'HYDRA-0091'
+    """,
+    mode="adql", # or sql
+    file=None, # dataframe
+    table_name=None,
+)
+# Print the dataframe
+print(tab.data)
+```
+
+The second way is a more controlled way, where you create the query, check the status and fetch the when you want results:
+
+```python
+
+# Create a asynchronous query
+query = cl.async_query(
+    query_text="""
+    select top 100 id, ra, dec, mag_psf* 
+    from splus.splus_idr6 where field = 'HYDRA-0091'
+    """, 
+    mode="adql", # or sql
+    file=None, # dataframe
+    table_name=None, 
+)
+
+# Check the status of the query and fetch results if complete
+query = cl.queries.get_status(query.id)
+if query.is_complete:
+    print("Query is complete. Fetching results...")
+    results = cl.queries.get_results(query.id)
+else:
+    print("Query is not complete yet.")
+
+```
+
+### Uploading user tables
+
+In the last example we left the `file` and `table_name` parameters as `None`. This means that we are not uploading any user table to the server. If you want to upload a user table, you can do it by passing a pandas DataFrame to the `file` parameter and a name for the table to the `table_name` parameter. **The uploaded table should be referenced as upload.`table_name` in the query.**.
+
+```python
+import pandas as pd
+# Create a sample dataframe
+data = {
+    "id": [1, 2, 3],
+    "ra": [150.1, 150.2, 150.3],
+    "dec": [2.1, 2.2, 2.3]
+}
+df = pd.DataFrame(data)
+
+# Create a asynchronous query with user table
+query = cl.query_and_wait(
+    query_text="""
+        select a.*, b.mag_psf_r 
+        from upload.my_table as a
+        join splus.splus_idr6 as b on a.id = b.id
+    """,
+    mode="adql", # or sql
+    file=df, # dataframe
+    table_name="my_table",
+)
+
+### Images - File Collections
+
+ADSS also supports downloading images, cutouts, colored images. These are handled as Collections. You can list the available file collections in the database metadata:
+
+```python
+cl.get_image_collections()
+```
+
+```
+[
+{
+    'name': 'splus dr4',
+    'path': '/dados/splus',
+    'description': 'splus dr4 collection',
+    'id': 1,
+    'created_at': '2025-04-22T15:27:36.698058',
+    'updated_at': '2025-07-31T23:27:51.497554',
+    'last_scanned': '2025-05-08T20:28:54.420350',
+    'patterns': {'': 'swp.', 'weight': 'weight'}
+}
+]
+```
+
+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
+cl.images.download_file("SPLUS-s17s23_F515_swpweight.fz", download_path=".")
+```

{adss-1.30 → adss-1.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "adss"
-version = "1.30"
+version = "1.32"
 description = "Astronomical Data Smart System"
 readme = "README.md"
 authors = [{ name = "Gustavo Schwarz", email = "gustavo.b.schwarz@gmail.com" }]

adss-1.30/PKG-INFO

@@ -1,36 +0,0 @@
-Metadata-Version: 2.4
-Name: adss
-Version: 1.30
-Summary: Astronomical Data Smart System
-Author-email: Gustavo Schwarz <gustavo.b.schwarz@gmail.com>
-Project-URL: Homepage, https://github.com/schwarzam/adss
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pyarrow
-Requires-Dist: requests
-Requires-Dist: astropy
-Dynamic: license-file
-
-# ADSS
-Astronomical Data Smart System
-
-ADSS is a database/server project hosted at CBPF (Brazilian Center for Research in Physics) that provides access to astronomical data from different surveys. 
-
-This repository provides a set of tools for querying astronomical ADSS services using ADQL. You can perform cone searches, cross-match queries between tables, and even cross-match against user-supplied data. The library supports both synchronous and asynchronous query execution.
-
-## Instalation
-
-```bash
-pip install adss
-```
-
-or
-
-```bash
-git clone https://github.com/schwarzam/adss.git
-cd adss
-pip install .
-```
-

adss-1.30/README.md

@@ -1,21 +0,0 @@
-# ADSS
-Astronomical Data Smart System
-
-ADSS is a database/server project hosted at CBPF (Brazilian Center for Research in Physics) that provides access to astronomical data from different surveys. 
-
-This repository provides a set of tools for querying astronomical ADSS services using ADQL. You can perform cone searches, cross-match queries between tables, and even cross-match against user-supplied data. The library supports both synchronous and asynchronous query execution.
-
-## Instalation
-
-```bash
-pip install adss
-```
-
-or
-
-```bash
-git clone https://github.com/schwarzam/adss.git
-cd adss
-pip install .
-```
-

adss-1.30/adss.egg-info/PKG-INFO

@@ -1,36 +0,0 @@
-Metadata-Version: 2.4
-Name: adss
-Version: 1.30
-Summary: Astronomical Data Smart System
-Author-email: Gustavo Schwarz <gustavo.b.schwarz@gmail.com>
-Project-URL: Homepage, https://github.com/schwarzam/adss
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pyarrow
-Requires-Dist: requests
-Requires-Dist: astropy
-Dynamic: license-file
-
-# ADSS
-Astronomical Data Smart System
-
-ADSS is a database/server project hosted at CBPF (Brazilian Center for Research in Physics) that provides access to astronomical data from different surveys. 
-
-This repository provides a set of tools for querying astronomical ADSS services using ADQL. You can perform cone searches, cross-match queries between tables, and even cross-match against user-supplied data. The library supports both synchronous and asynchronous query execution.
-
-## Instalation
-
-```bash
-pip install adss
-```
-
-or
-
-```bash
-git clone https://github.com/schwarzam/adss.git
-cd adss
-pip install .
-```
-