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

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/executors/async_query.py

@@ -2,7 +2,9 @@ from astropy.io.votable import from_table, writeto
 from xml.dom import minidom
 from astropy.table import Table
 
+
 from adss.variables import BASEURL
+from adss.utils.format_table import format_result_table
 import requests
 import os
 
@@ -32,7 +34,7 @@ def execute_async(query, table_upload=None, refresh_rate=5):
         "query": query,
         "format": 'csv'
     }
-    
+
     if str(type(table_upload)) != "<class 'NoneType'>":
         if 'astropy.table' in str(type(table_upload)):
             if len(table_upload) > 6000:
@@ -76,7 +78,6 @@ def execute_async(query, table_upload=None, refresh_rate=5):
                 writeto(table_upload, IObytes)
                 IObytes.seek(0)
                 
-
         else:
             return 'Table type not supported'
 
@@ -109,7 +110,7 @@ def execute_async(query, table_upload=None, refresh_rate=5):
 
             res = requests.get(link)
 
-            return Table.read(io.BytesIO(res.content), format="csv")
+            return format_result_table(Table.read(io.BytesIO(res.content), format="csv"))
 
         if process == 'ERROR':
             item = xmldoc.getElementsByTagName('message')[0]

adss/executors/sync_query.py

@@ -1,4 +1,5 @@
 from adss.variables import BASEURL
+from adss.utils.format_table import format_result_table
 
 from astropy.table import Table
 from xml.dom import minidom
@@ -6,9 +7,11 @@ import requests
 import os
 import io
 
+from requests.exceptions import Timeout
+
 sync_url = os.path.join(BASEURL, "sync")
 
-def execute_sync(query):
+def execute_sync(query, timeout=20):
     data = {
         "request": "doQuery",
         "version": "1.0",
@@ -19,7 +22,10 @@ def execute_sync(query):
     }
 
     # Make request to TAP server
-    res = requests.post(sync_url, data=data)
+    try:
+        res = requests.post(sync_url, data=data, timeout=20)
+    except Timeout:
+        raise Exception("Request to TAP server timed out, for large queries use async query")
 
     # Handle errors from TAP response
     if res.status_code != 200:
@@ -31,6 +37,6 @@ def execute_sync(query):
                 raise Exception(f"ADQL Query Error: {error_message}")
 
     # Convert CSV response to Astropy Table
-    return Table.read(io.BytesIO(res.content), format="csv")
+    return format_result_table(Table.read(io.BytesIO(res.content), format="csv"))
 
 

adss/table.py

@@ -0,0 +1,295 @@
+from adss.executors.sync_query import execute_sync
+from adss.executors.async_query import execute_async
+from adss.utils import format_table
+
+import re
+
+class Table:
+    def __init__(self, name, columns):
+        self.name = name
+        self.columns = columns
+        self.selected_columns = []
+        self.constrains = []
+        
+    def __repr__(self):
+        return f"Table(name={self.name}, columns={len(self.columns)})"
+    
+    def __str__(self):
+        return f"Table: {self.name} ({len(self.columns)} columns)"
+    
+    def check_column(self, column):
+        return column in self.columns
+    
+    def format_columns(self, columns):
+        # Use provided columns list rather than an undefined variable
+        return ','.join(columns)
+    
+    def set_columns(self, columns):
+        if not isinstance(columns, list):
+            columns = [columns]
+        for column in columns:
+            if not self.check_column(column):
+                raise ValueError(f"Column {column} not in table {self.name}, options are {self.columns}")
+        self.selected_columns = columns
+    
+    def set_constrains(self, constrains):
+        self.constrains = constrains
+    
+    def cone_search(self, ra, dec, radius_arcsec, columns=None, method = 'sync'):
+        if radius_arcsec < 0:
+            raise ValueError("Radius must be positive")
+        if radius_arcsec > 60:
+            raise ValueError("Radius must be less than 60 arcsecs")
+        
+        if columns:
+            columns_str = self.format_columns(columns)
+        elif self.selected_columns:
+            columns_str = self.format_columns(self.selected_columns)
+        else:
+            columns_str = "*"  # Select all columns
+
+        constraints_str = ""
+        if self.constrains:
+            constraints_str = " AND (" + self.constrains + ")"
+            
+        query = f"""SELECT {columns_str} FROM {self.name}
+WHERE 1 = CONTAINS( 
+    POINT('ICRS', ra, dec), 
+    CIRCLE('ICRS', {ra}, {dec}, {radius_arcsec}/3600.0) 
+){constraints_str}
+"""
+                
+        print(query)
+        if method == 'sync':
+            return execute_sync(query)
+        else:
+            return execute_async(query)
+    
+    def cone_cross_match(
+            self, 
+            other_table, 
+            match_arcsec,
+            ra, 
+            dec,
+            radius_arcsec,
+            columns=None, 
+            other_columns=None,
+            other_suffix=None,
+            method='sync'
+        ):
+        """
+        Perform a cone search on the current table (t1) and then cross-match with another table (t2)
+        using a matching radius (match_arcsec).
+        
+        The query first restricts table t1 to a cone centered at (ra, dec) with a radius of radius_arcsec.
+        Then, for each object in t1, it finds matching objects in table t2 that lie within match_arcsec 
+        of the t1 object's coordinates.
+        
+        Additionally:
+          - If a non-empty `other_suffix` is provided, each selected column from t2 will be aliased with that suffix.
+          - The constraints for each table are processed so that the columns in the conditions are properly qualified with t1 or t2.
+        
+        Parameters:
+            other_table (Table): The table to match against (t2).
+            match_arcsec (float): The cross-match tolerance radius (in arcseconds) between t1 and t2.
+            ra (float): Right Ascension for the cone center (t1).
+            dec (float): Declination for the cone center (t1).
+            radius_arcsec (float): The cone search radius (in arcseconds) for filtering t1.
+            columns (list or None): Columns to select from the current table (t1).
+            other_columns (list or None): Columns to select from the other table (t2).
+            other_suffix (str or None): Optional suffix to append to each t2 column alias.
+            method (str): Use 'sync' for synchronous execution or 'async' for asynchronous.
+        
+        Returns:
+            The result of the query execution via execute_sync or execute_async.
+        """
+        
+        # Helper function to qualify constraint column names with the proper alias.
+        # It looks for each column name as a whole word (not already preceded by an alias) and prefixes it.
+        def apply_alias_to_constraint(constraint, alias, columns_list):
+            for col in columns_list:
+                # (?<![\w\.]) ensures that we do not match if the column is already prefixed (like t1.ra)
+                pattern = r'(?<![\w\.])\b' + re.escape(col) + r'\b'
+                constraint = re.sub(pattern, f"{alias}.{col}", constraint)
+            return constraint
+        
+        # Validate match_arcsec
+        if match_arcsec <= 0:
+            raise ValueError("Match radius must be positive")
+        if match_arcsec > 3:
+            print("Match radius may be too large; consider a value less than 3 arcsecs")
+        
+        # Determine columns for t1
+        if columns:
+            t1_columns_list = columns if isinstance(columns, list) else [columns]
+            t1_columns = ', '.join(f"t1.{col}" for col in t1_columns_list)
+        elif self.selected_columns:
+            t1_columns = ', '.join(f"t1.{col}" for col in self.selected_columns)
+        else:
+            t1_columns = "t1.*"
+        
+        # Determine columns for t2, adding suffix if provided
+        if other_columns:
+            t2_columns_list = other_columns if isinstance(other_columns, list) else [other_columns]
+            if other_suffix:
+                t2_columns = ', '.join(f"t2.{col} AS {col}{other_suffix}" for col in t2_columns_list)
+            else:
+                t2_columns = ', '.join(f"t2.{col}" for col in t2_columns_list)
+        elif other_table.selected_columns:
+            if other_suffix:
+                t2_columns = ', '.join(f"t2.{col} AS {col}{other_suffix}" for col in other_table.selected_columns)
+            else:
+                t2_columns = ', '.join(f"t2.{col}" for col in other_table.selected_columns)
+        else:
+            t2_columns = "t2.*"
+        
+        # Process constraints for t1: apply alias "t1" to each column mentioned in the constraint.
+        constraints_t1 = ""
+        if self.constrains:
+            if isinstance(self.constrains, str):
+                processed_constraint = apply_alias_to_constraint(self.constrains, "t1", self.columns)
+                constraints_t1 = " AND (" + processed_constraint + ")"
+            elif isinstance(self.constrains, list):
+                processed_constraints = []
+                for c in self.constrains:
+                    processed_constraints.append(apply_alias_to_constraint(c, "t1", self.columns))
+                constraints_t1 = " AND (" + " AND ".join(processed_constraints) + ")"
+
+        # Process constraints for t2: apply alias "t2" to each column mentioned in the constraint.
+        constraints_t2 = ""
+        if other_table.constrains:
+            if isinstance(other_table.constrains, str):
+                processed_constraint = apply_alias_to_constraint(other_table.constrains, "t2", other_table.columns)
+                constraints_t2 = " AND (" + processed_constraint + ")"
+            elif isinstance(other_table.constrains, list):
+                processed_constraints = []
+                for c in other_table.constrains:
+                    processed_constraints.append(apply_alias_to_constraint(c, "t2", other_table.columns))
+                constraints_t2 = " AND (" + " AND ".join(processed_constraints) + ")"
+        # Build the query:
+        # 1. The first CONTAINS clause performs the cross-match between t1 and t2 with match_arcsec tolerance.
+        # 2. The second CONTAINS clause restricts t1 objects to the cone centered at (ra, dec) with radius radius_arcsec.
+        query = f"""SELECT {t1_columns}, {t2_columns}
+FROM {self.name} AS t1, {other_table.name} AS t2
+WHERE 1 = CONTAINS(
+        POINT('ICRS', t2.ra, t2.dec),
+        CIRCLE('ICRS', t1.ra, t1.dec, {match_arcsec}/3600.0)
+    )
+AND 1 = CONTAINS(
+        POINT('ICRS', t1.ra, t1.dec),
+        CIRCLE('ICRS', {ra}, {dec}, {radius_arcsec}/3600.0)
+    )
+{constraints_t1}
+{constraints_t2}
+"""
+                
+        print(query)
+        if method == 'async':
+            return execute_async(query)
+        else:
+            return execute_sync(query)
+        
+    def table_cross_match(
+            self, 
+            other_table, 
+            match_arcsec,
+            columns=None, 
+            other_columns=None,
+            other_suffix=None,
+            method='async'
+        ):
+        """
+        Perform a cone search on the current table (t1) and then cross-match with another 
+        table (Dataframe or astropy Table) (t2)
+        using a matching radius (match_arcsec).
+        
+        For each object in t1, it finds matching objects in table t2 that lie within match_arcsec 
+        of the t1 object's coordinates.
+        
+        Additionally:
+          - If a non-empty `other_suffix` is provided, each selected column from t2 will be aliased with that suffix.
+          - The constraints for each table are processed so that the columns in the conditions are properly qualified with t1 or t2.
+        
+        Parameters:
+            other_table (astropy.table.Table): The table to match against (t2).
+            match_arcsec (float): The cross-match tolerance radius (in arcseconds) between t1 and t2.
+            columns (list or None): Columns to select from the current table (t1).
+            other_columns (list or None): Columns to select from the other table (t2).
+            other_suffix (str or None): Optional suffix to append to each t2 column alias.
+            method (str): Use 'sync' for synchronous execution or 'async' for asynchronous.
+        
+        Returns:
+            The result of the query execution via execute_sync or execute_async.
+        """
+        
+        # Helper function to qualify constraint column names with the proper alias.
+        # It looks for each column name as a whole word (not already preceded by an alias) and prefixes it.
+        def apply_alias_to_constraint(constraint, alias, columns_list):
+            for col in columns_list:
+                # (?<![\w\.]) ensures that we do not match if the column is already prefixed (like t1.ra)
+                pattern = r'(?<![\w\.])\b' + re.escape(col) + r'\b'
+                constraint = re.sub(pattern, f"{alias}.{col}", constraint)
+            return constraint
+        
+        # Validate match_arcsec
+        if match_arcsec <= 0:
+            raise ValueError("Match radius must be positive")
+        if match_arcsec > 3:
+            print("Match radius may be too large; consider a value less than 3 arcsecs")
+        
+        # Determine columns for t1
+        if columns:
+            t1_columns_list = columns if isinstance(columns, list) else [columns]
+            t1_columns = ', '.join(f"t1.{col}" for col in t1_columns_list)
+        elif self.selected_columns:
+            t1_columns = ', '.join(f"t1.{col}" for col in self.selected_columns)
+        else:
+            t1_columns = "t1.*"
+        
+        # Determine columns for t2, adding suffix if provided
+        if not other_columns:
+            raise ValueError("Must provide columns for the input table (other_columns param)")
+        
+        if not "ra" in other_columns or not "dec" in other_columns:
+            raise ValueError("Input table must have 'ra' and 'dec' columns")
+        
+        other_table = other_table[other_columns]
+        
+        t2_columns_list = other_columns if isinstance(other_columns, list) else [other_columns]
+        if other_suffix:
+            t2_columns = ', '.join(f"t2.{col} AS {col}{other_suffix}" for col in t2_columns_list)
+        else:
+            t2_columns = ', '.join(f"t2.{col}" for col in t2_columns_list)
+
+        # Process constraints for t1: apply alias "t1" to each column mentioned in the constraint.
+        constraints_t1 = ""
+        if self.constrains:
+            if isinstance(self.constrains, str):
+                processed_constraint = apply_alias_to_constraint(self.constrains, "t1", self.columns)
+                constraints_t1 = " (" + processed_constraint + ")"
+            elif isinstance(self.constrains, list):
+                processed_constraints = []
+                for c in self.constrains:
+                    processed_constraints.append(apply_alias_to_constraint(c, "t1", self.columns))
+                constraints_t1 = " (" + " AND ".join(processed_constraints) + ")"
+
+        if constraints_t1:
+            constraints_t1 = "WHERE " + constraints_t1
+        # Build the query:
+        # 1. The first CONTAINS clause performs the cross-match between t1 and t2 with match_arcsec tolerance.
+        # 2. The second CONTAINS clause restricts t1 objects to the cone centered at (ra, dec) with radius radius_arcsec.
+        query = f"""SELECT {t1_columns}, {t2_columns}
+FROM {self.name} AS t1 JOIN tap_upload.upload AS t2 ON
+1 = CONTAINS(
+        POINT('ICRS', t1.ra, t1.dec),
+        CIRCLE('ICRS', t2.ra, t2.dec, {match_arcsec}/3600.0)
+    )
+{constraints_t1}
+"""
+                
+        print(query)
+        if method == 'async':
+            return execute_async(query, table_upload=other_table)
+        else:
+            raise ValueError("Synchronous execution not supported yet for table cross-match")
+            #return execute_sync(query)

adss/utils/format_table.py

@@ -0,0 +1,115 @@
+import numpy as np
+from astropy.table import Table
+
+def vectorized_string_to_masked_array(column_data):
+    """
+    Fully vectorized conversion of formatted string arrays to NumPy masked arrays.
+    The strings are assumed to be wrapped in curly braces (e.g. "{1,2,3}").
+    Any occurrence of the literal "NULL" in a cell will be masked.
+    
+    Parameters
+    ----------
+    column_data : numpy.ndarray
+        A 1D NumPy array of strings. Each element is a formatted array like "{1,2,3}".
+        
+    Returns
+    -------
+    numpy.ma.MaskedArray
+        A masked array where "NULL" entries are masked.
+    """
+    # Remove curly braces (but do not remove "NULL")
+    clean_data = np.char.replace(column_data.astype(str), "{", "")
+    clean_data = np.char.replace(clean_data, "}", "")
+    
+    # Split each string by comma into a list of items (with possible surrounding whitespace)
+    split_arrays = np.char.split(clean_data, ",")
+    
+    # --- Determine type by scanning for a first non-"NULL" value ---
+    first_value = None
+    for row in split_arrays:
+        for item in row:
+            item_str = item.strip()
+            if item_str != "NULL":
+                first_value = item_str
+                break
+        if first_value is not None:
+            break
+            
+    # If no non-NULL value is found, default to a masked object array.
+    if first_value is None:
+        data = [np.array(row) for row in split_arrays]
+        mask = [np.full(len(row), True, dtype=bool) for row in split_arrays]
+        return np.ma.masked_array(data, mask=mask)
+    
+    # Try to determine numeric type.
+    # (If first_value consists solely of digits, we'll assume integer.
+    #  Otherwise, if it can be converted to float, we'll use float.
+    #  Else, we default to string.)
+    is_integer = first_value.isdigit()
+    is_float = False
+    if not is_integer:
+        try:
+            float(first_value)
+            is_float = True
+        except Exception:
+            pass
+
+    # Prepare lists to store converted rows and corresponding masks.
+    data_list = []
+    mask_list = []
+    
+    # Conversion helper functions
+    def convert_item(item, conv):
+        item = item.strip()
+        if item == "NULL":
+            return None, True
+        else:
+            return conv(item), False
+    
+    if is_integer:
+        conv_func = int
+        dtype = np.int64
+    elif is_float:
+        conv_func = float
+        dtype = np.float64
+    else:
+        conv_func = lambda x: x
+        dtype = object
+
+    # Process each row
+    for row in split_arrays:
+        row_vals = []
+        row_mask = []
+        for item in row:
+            val, is_mask = convert_item(item, conv_func)
+            # For masked numeric values, we insert a dummy (0 or 0.0) value.
+            if is_mask:
+                if dtype in (np.int64, np.float64):
+                    row_vals.append(0)
+                else:
+                    row_vals.append("")
+            else:
+                row_vals.append(val)
+            row_mask.append(is_mask)
+        # Convert row to an array of the target dtype.
+        row_arr = np.array(row_vals, dtype=dtype)
+        data_list.append(row_arr)
+        mask_list.append(np.array(row_mask, dtype=bool))
+    
+    # Create and return a masked array.
+    return np.ma.masked_array(data_list, mask=mask_list)
+
+def format_result_table(tab):
+    if tab is None or len(tab) == 0:
+        return None
+    
+    for col in tab.colnames:
+        if len(tab[col]) == 0:
+            continue
+        if not "<U" in str(tab[col].dtype):
+            continue
+        
+        if "{" in tab[col][0]:
+            tab[col] = vectorized_string_to_masked_array(tab[col])
+
+    return tab

adss-1.0.dist-info/LICENSE

@@ -0,0 +1,11 @@
+Copyright <YEAR> <COPYRIGHT HOLDER>
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

{adss-0.1.dist-info → adss-1.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: adss
-Version: 0.1
+Version: 1.0
 Summary: Astronomical Data Smart System
 Home-page: https://github.com/schwarzam/adss
 Author: Gustavo Schwarz
 Author-email: gustavo.b.schwarz@gmail.com
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
+License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: astropy
-Requires-Dist: pyvo
 

adss-1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+adss/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adss/adss_manager.py,sha256=vaS6y1IycVW8AjpAQeG58VwjCDLyMBUylJzYSeg6D9o,2068
+adss/table.py,sha256=Ua663njPk2sg8BtQPo1wZ-V09YvnjrEyIb_SmBhdOYY,13383
+adss/variables.py,sha256=kmbwxJBDC97yKakrnBvONRh1FVvSXU4YKqnjExAU2ZA,51
+adss/executors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adss/executors/async_query.py,sha256=qmSm-Ex8ZJSjn8lmm_F5BufVpDV-w6vOqXie7krCp7k,3977
+adss/executors/sync_query.py,sha256=3e-ALG3GnA906o_oefci5XHNcdnoPWuc67ml-YATMKE,1243
+adss/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adss/operations/cone_search.py,sha256=qfdFA2TGqnzuggz4nep21_y4LgmHP4ZMpVupxn87dB0,706
+adss/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adss/utils/format_table.py,sha256=UYCQ6Xum3dPHrh0cAh_KCj6vHShAvdHlV0rtIv7J09Q,3695
+adss-1.0.dist-info/LICENSE,sha256=1aYqcyqjrdNXY9hqgZkCWprcoA112oKvdrfPyvMYPTc,1468
+adss-1.0.dist-info/METADATA,sha256=mXmdv0NUDgCapF58GJOkJj5_bCU5rjHgCjYI1cCDY7Q,378
+adss-1.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+adss-1.0.dist-info/top_level.txt,sha256=ebD44L3R0PEvEFoRCJ-RjTIsQ9Yjpo2aAYC1BMtueLg,5
+adss-1.0.dist-info/RECORD,,

adss-0.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-adss/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-adss/variables.py,sha256=kmbwxJBDC97yKakrnBvONRh1FVvSXU4YKqnjExAU2ZA,51
-adss/executors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-adss/executors/async_query.py,sha256=2xVnnVp-0-dFR8GbDzG2be3dT2s8DpPN1ja59o4d_bM,3904
-adss/executors/sync_query.py,sha256=s-t95UtFCdkyBTpnrDgCrVS9wSFXdgIvtDLfNJ21BUA,974
-adss/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-adss/operations/cone_search.py,sha256=qfdFA2TGqnzuggz4nep21_y4LgmHP4ZMpVupxn87dB0,706
-adss-0.1.dist-info/METADATA,sha256=ilpdvMwhIRDpROZuVhtJTKueu5KvQEfMEQVUKpwQvv8,376
-adss-0.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-adss-0.1.dist-info/top_level.txt,sha256=ebD44L3R0PEvEFoRCJ-RjTIsQ9Yjpo2aAYC1BMtueLg,5
-adss-0.1.dist-info/RECORD,,