dapper-sqls 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

dapper_sqls/models/result.py

@@ -96,27 +96,32 @@ class Result(object):
             return self._error
     
     class Fetchone(BaseResult):
-        def __init__(self, query : str | tuple, cursor, result, exception: Exception = None):
+
+        def __init__(self, query: str | tuple, cursor, result, exception: Exception = None):
             super().__init__(query)
             self._error = Error(exception)
             self._list = []
-            self._dict : dict[str, Any] = {}
-            if cursor != None:
+            self._dict: dict[str, Any] = {}
+
+            if cursor is not None:
                 self._status_code = 200
                 self._success = True
                 if result:
                     sensitive_fields = SensitiveFields.get()
                     columns = [column[0] for column in cursor.description]
                     raw_dict = dict(zip(columns, result))
+
+                    # Exclui campos sensíveis 
                     self._dict = {
                         k: v for k, v in raw_dict.items()
-                        if k not in sensitive_fields
+                        if k not in sensitive_fields 
                     }
-                    self._list = result
+                    # Lista só com valores que não sejam None
+                    self._list = [v for v in result if v is not None]
             else:
                 self._status_code = SQL_ERROR_HTTP_CODES.get(self._error.type, 500)
                 self._success = False
-        
+
         def _organize_joined_tables(self, joins: list):
             alias_to_table_name = {
                 join.model.TABLE_ALIAS: join.model.__class__.__name__ for join in joins
@@ -126,9 +131,11 @@ class Result(object):
                 return
 
             alias_data = defaultdict(dict)
+            cleaned_alias_data : dict[str, dict] = {}
             keys_to_remove = []
 
-            for key, value in self._dict.items(): 
+            for key, value in self._dict.items():
+        
                 for alias_table, table_name in alias_to_table_name.items():
                     if alias_table in key:
                         column_name = key.replace(alias_table, '')
@@ -136,15 +143,27 @@ class Result(object):
                         keys_to_remove.append(key)
                         break
 
+            if alias_data:
+                for table_name, cols in alias_data.items():
+                    if all(v is None for v in cols.values()):
+                        cleaned_alias_data[table_name] = {}
+                    else:
+                        cleaned_alias_data[table_name] = {
+                            k: v for k, v in cols.items() if v is not None
+                        }
+
             for key in keys_to_remove:
-                self._dict.pop(key)
+                self._dict.pop(key, None)
 
-            if alias_data:
-                self._dict['joined_tables'] = dict(alias_data)
+            if cleaned_alias_data:
+                self._dict['joined_tables'] = {
+                    t: {k: v for k, v in cols.items() if v}
+                    for t, cols in cleaned_alias_data.items()
+                }
 
             if self._list:
                 columns = [col for col in self._dict.keys() if col]
-                self._list = [self._dict[col] for col in columns]
+                self._list = [self._dict[col] for col in columns if self._dict[col] is not None]
 
         def model_dump(self, *, include: set[str] = None):
             if not self.success:
@@ -153,11 +172,14 @@ class Result(object):
                     'message': self.error.message
                 }
 
-            result_dict = self._dict.copy()
+            result_dict = {k: v for k, v in self._dict.items() if v is not None}
 
             if include is not None:
                 include = set(include)
-                result_dict = {k: v for k, v in result_dict.items() if k in include  or k == 'joined_tables'}
+                result_dict = {
+                    k: v for k, v in result_dict.items()
+                    if k in include or k == 'joined_tables'
+                }
 
             return {
                 'status_code': self.status_code,
@@ -174,7 +196,7 @@ class Result(object):
 
         @property
         def dict(self):
-            return self._dict
+            return {k: v for k, v in self._dict.items() if v is not None}
 
         @property
         def success(self):
@@ -220,24 +242,25 @@ class Result(object):
         def model_dump(self, *, include: set[str] = None):
             return self._fetchone.model_dump(include=include)
 
-
     class Fetchall(BaseResult):
-
-        def __init__(self, query : str | tuple, cursor, result, exception: Exception = None):
+        def __init__(self, query: str | tuple, cursor, result, exception: Exception = None):
             super().__init__(query)
             self._error = Error(exception)
-            self._list_dict : list[dict[str, Any]] = []
-            if cursor != None:
+            self._list_dict: list[dict[str, Any]] = []
+
+            if cursor is not None:
                 self._status_code = 200
                 self._success = True
                 if result:
                     sensitive_fields = SensitiveFields.get()
                     columns = [column[0] for column in cursor.description]
+
                     for r in result:
                         raw_dict = dict(zip(columns, r))
+                        # remove campos sensíveis 
                         clean_dict = {
                             k: v for k, v in raw_dict.items()
-                            if k not in sensitive_fields
+                            if k not in sensitive_fields 
                         }
                         self._list_dict.append(clean_dict)
             else:
@@ -251,9 +274,10 @@ class Result(object):
 
             for item in self._list_dict:
                 alias_data = defaultdict(dict)
+                cleaned_alias_data : dict[str, dict] = {}
                 keys_to_remove = []
 
-                for key, value in item.items(): 
+                for key, value in item.items():
                     for alias_table, table_name in alias_to_table_name.items():
                         if alias_table in key:
                             column_name = key.replace(alias_table, '')
@@ -261,11 +285,24 @@ class Result(object):
                             keys_to_remove.append(key)
                             break
 
+                if alias_data:
+                    for table_name, cols in alias_data.items():
+                        if all(v is None for v in cols.values()):
+                            cleaned_alias_data[table_name] = {}
+                        else:
+                            cleaned_alias_data[table_name] = {
+                                k: v for k, v in cols.items() if v is not None
+                            }
+
                 for key in keys_to_remove:
-                    del item[key]
+                    item.pop(key, None)
 
-                if alias_data:
-                    item['joined_tables'] = dict(alias_data)
+                if cleaned_alias_data:
+                    # filtra None também dentro de joined_tables
+                    item['joined_tables'] = {
+                        t: {k: v for k, v in cols.items()}
+                        for t, cols in cleaned_alias_data.items()
+                    }
 
         def model_dump(self, *, include: set[str] = None):
             if not self.success:
@@ -274,11 +311,18 @@ class Result(object):
                     'message': self.error.message
                 }
 
-            data = self._list_dict
+            # remove valores None de todos os dicts
+            data = [
+                {k: v for k, v in d.items() if v is not None}
+                for d in self._list_dict
+            ]
 
             if include is not None:
                 include = set(include)
-                data = [{k: v for k, v in d.items() if k in include or k == 'joined_tables'} for d in data]
+                data = [
+                    {k: v for k, v in d.items() if k in include or k == 'joined_tables'}
+                    for d in data
+                ]
 
             return {
                 'status_code': self.status_code,
@@ -291,7 +335,10 @@ class Result(object):
 
         @property
         def list_dict(self):
-            return self._list_dict
+            return [
+                {k: v for k, v in d.items() if v is not None}
+                for d in self._list_dict
+            ]
 
         @property
         def success(self):

dapper_sqls/sqlite/installer.py

@@ -34,9 +34,12 @@ class DataBaseInstall(object):
                with self.engine.connect() as conn:
                     self.tables.meta_data.create_all(self.engine)
                     if hasattr(self.tables, 'system'):
-                         ins = insert(self.tables.system).values(App=app_name, Tema='light')
-                         conn.execute(ins)
-                    conn.commit()
+                         try:
+                              ins = insert(self.tables.system).values(App=app_name, Tema='light')
+                              conn.execute(ins)
+                              conn.commit()
+                         except:
+                              ...
           else:
                if not self.are_tables_existing(self.engine):
                     try:

{dapper_sqls-1.2.1.dist-info → dapper_sqls-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dapper-sqls
-Version: 1.2.1
+Version: 1.2.3
 Summary: UNKNOWN
 Home-page: UNKNOWN
 Author: Samuel Semedo

{dapper_sqls-1.2.1.dist-info → dapper_sqls-1.2.3.dist-info}/RECORD

@@ -26,15 +26,15 @@ dapper_sqls/models/base.py,sha256=KmlbLa9_k0ioGDWVjISes4kIP8OgElAoCqXbr3VbSCE,85
 dapper_sqls/models/connection.py,sha256=z5OkYeY5Qp-dXdy1bvZHAlov-Kq-lgMxC6RqNdTiiq4,1745
 dapper_sqls/models/http.py,sha256=rCmf4Mj1bA_oc0k0vDxi2v1Cqd4oXDDU83P_6kNwTuA,356
 dapper_sqls/models/query_field.py,sha256=QOQlB6hlVm7fGZqsAFgWGznLEDSR03uTI_--xDyUEao,7763
-dapper_sqls/models/result.py,sha256=K_EIZxQljqFiHinbLwlda87ZCktZ4buvvws1smGIh5Q,12707
+dapper_sqls/models/result.py,sha256=EsbgP7sY8QO5i-ddPwWH9mmRYGPLpQnwe89H1zWImqg,14728
 dapper_sqls/sqlite/__init__.py,sha256=EUREulLqSlZ43_3pEYlDJ3rF7i0cSwROnqrlZX9ircI,247
 dapper_sqls/sqlite/async_local_database.py,sha256=VqMdAD2wdzqFMIKEpnOgbajEwwSmxLqtSkqWSipbu6o,7754
 dapper_sqls/sqlite/decorators.py,sha256=hvehaUi6uV3BkLNOcbGhv3-fV0VJD0hLomXznSSMJEA,2420
-dapper_sqls/sqlite/installer.py,sha256=nCDGRNUEvAEHx8Pw3izXx9miJJ3o5cjjPWA07nlqAD4,4781
+dapper_sqls/sqlite/installer.py,sha256=pHRXFn8gFPUj_d42ErKcMUDFmzc8tK1DabuhgqUIuSw,4901
 dapper_sqls/sqlite/local_database.py,sha256=kuEVRJvzUUQg3X1Abq9ZYslO9n5IMovaCj7jnB51qSs,5902
 dapper_sqls/sqlite/models.py,sha256=m1I0-iYDdv-4fVYMsAboRYHbMEcwI4GScZSdbs7_nUY,2232
 dapper_sqls/sqlite/utils.py,sha256=22n2ry7_7b7XGDjwv3sY8swADpXDAynR0-E8WQrvHzc,230
-dapper_sqls-1.2.1.dist-info/METADATA,sha256=Lcvmw9RHD9l5YFo7Lag1BaqHIdKwduFjcHlUWefuqHk,964
-dapper_sqls-1.2.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-dapper_sqls-1.2.1.dist-info/top_level.txt,sha256=Pe1YqCPngnYbSVdhJyDrdFWHFCOqBvFW8WK7kTaIax4,12
-dapper_sqls-1.2.1.dist-info/RECORD,,
+dapper_sqls-1.2.3.dist-info/METADATA,sha256=8la5wW7ydUMVjseiK-XDcDaalnkz2tMYTFl0-g7HZms,964
+dapper_sqls-1.2.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+dapper_sqls-1.2.3.dist-info/top_level.txt,sha256=Pe1YqCPngnYbSVdhJyDrdFWHFCOqBvFW8WK7kTaIax4,12
+dapper_sqls-1.2.3.dist-info/RECORD,,