update table fn's

mythz · mythz · commit 39f998b8750c · 2021-07-14T02:07:46.000+08:00
diff --git a/servicestack/clients.py b/servicestack/clients.py
@@ -16,7 +16,8 @@
 from servicestack.log import Log
 from servicestack.reflection import TypeConverters, to_dict, nameof, is_list, is_dict, _resolve_forwardref, \
     has_type_vars, _dict_with_string_keys, _get_type_vars_map, from_json, to_json
-from servicestack.utils import ex_message
+from servicestack.utils import ex_message, clean_camelcase
+
 
 JSON_MIME_TYPE = "application/json"
 AUTHORIZATION_HEADER = "Authorization"
@@ -142,7 +143,6 @@ def exec(self):
             Log.debug(
                 f"{using}.request({self.method}): url={self.url}, headers={self.headers}, data={self.body_string}")
 
-        response: Optional[Response] = None
         if has_request_body(self.method):
             if self.session is not None:
                 response = self.session.request(self.method, self.url, data=self.body_string, headers=self.headers)
@@ -241,7 +241,7 @@ def refresh_token_cookie(self):
     def create_url_from_dto(self, method: str, request: Any):
         url = urljoin(self.reply_base_url, nameof(request))
         if not has_request_body(method):
-            url = append_querystring(url, to_dict(request))
+            url = append_querystring(url, to_dict(request, key_case=clean_camelcase))
         return url
 
     def get(self, request: IReturn[T], args: Dict[str, Any] = None) -> T:
@@ -329,14 +329,15 @@ def send(self, request, method="POST", body: Any = None, args: Dict[str, Any] =
             args=args,
             response_as=response_as))
 
-    def assert_valid_batch_request(self, requests: list):
-        if not isinstance(requests, list):
-            raise TypeError(f"'{nameof(requests)}' is not a List")
+    @staticmethod
+    def assert_valid_batch_request(request_dtos: list):
+        if not isinstance(request_dtos, list):
+            raise TypeError(f"'{nameof(request_dtos)}' is not a List")
 
-        if len(requests) == 0:
+        if len(request_dtos) == 0:
             return []
 
-        request = requests[0]
+        request = request_dtos[0]
         if not isinstance(request, IReturn) and not isinstance(request, IReturnVoid):
             raise TypeError(f"'{nameof(request)}' does not implement IReturn or IReturnVoid")
 
@@ -345,31 +346,31 @@ def assert_valid_batch_request(self, requests: list):
             raise TypeError(f"Could not resolve Response Type for '{nameof(request)}'")
         return request, item_response_as
 
-    def send_all(self, requests: List[IReturn[T]]):
-        request, item_response_as = self.assert_valid_batch_request(requests)
+    def send_all(self, request_dtos: List[IReturn[T]]):
+        request, item_response_as = self.assert_valid_batch_request(request_dtos)
         url = urljoin(self.reply_base_url, nameof(request) + "[]")
 
         return self.send_request(SendContext(
             session=self._session,
             headers=self.headers.copy(),
             method="POST",
             url=url,
-            request=list(requests),
+            request=list(request_dtos),
             body=None,
             body_string=None,
             args=None,
             response_as=list.__class_getitem__(item_response_as)))
 
-    def send_all_oneway(self, requests: list):
-        request, item_response_as = self.assert_valid_batch_request(requests)
+    def send_all_oneway(self, request_dtos: list):
+        request, item_response_as = self.assert_valid_batch_request(request_dtos)
         url = urljoin(self.oneway_base_url, nameof(request) + "[]")
 
         self.send_request(SendContext(
             session=self._session,
             headers=self.headers.copy(),
             method="POST",
             url=url,
-            request=list(requests),
+            request=list(request_dtos),
             body=None,
             body_string=None,
             args=None,
@@ -474,7 +475,7 @@ def create_request(self, info: SendContext):
                 body_not_request_dto = info.request and info.body
                 if body_not_request_dto:
                     url = urljoin(self.reply_base_url, nameof(info.request))
-                    url = append_querystring(url, to_dict(info.request))
+                    url = append_querystring(url, to_dict(info.request, key_case=clean_camelcase))
                 else:
                     url = self.create_url_from_dto(info.method, body)
 
diff --git a/servicestack/reflection.py b/servicestack/reflection.py
@@ -1,18 +1,18 @@
 import base64
-import dataclasses
 import decimal
 import inspect
 import json
+import math
 import numbers
 import os
 import pathlib
 import platform
 import typing
-from dataclasses import asdict
 from dataclasses import fields, is_dataclass
 from datetime import datetime, timedelta
-from enum import Enum, IntEnum
+from enum import Enum, IntEnum, EnumMeta
 from functools import reduce
+from types import MappingProxyType
 from typing import Callable, Type, get_origin, ForwardRef, Union, TypeVar, get_args
 from typing import List, Dict, Any
 
@@ -29,7 +29,7 @@ def is_optional(cls: Type): return get_origin(cls) is Union and type(None) in ge
 def is_list(cls: Type): return cls == typing.List or cls == list or get_origin(cls) == list
 
 
-def is_dict(cls: Type): return cls == typing.Dict or cls == dict or get_origin(cls) == dict
+def is_dict(cls: Type): return cls == typing.Dict or cls == dict or get_origin(cls) == dict or cls == MappingProxyType
 
 
 def nameof(instance):
@@ -78,31 +78,51 @@ def _empty(x):
     return x is None or x == {} or x == []
 
 
-def to_dict(obj: Any):
-    if obj is None:
-        return {}
+def _str(x: Any):
+    if type(x) == str:
+        return x
+    return f"{x}"
+
+
+def identity(x: Any): return x
+
+
+_JSON_TYPES = {str, bool, int, float}
+_BUILT_IN_TYPES = {str, bool, int, float, decimal.Decimal, datetime, timedelta, bytes, bytearray, complex}
+
+
+def to_dict(obj: Any, key_case: Callable[[str], str] = identity, remove_empty: bool = True):
     t = type(obj)
+    if obj is None or t in _BUILT_IN_TYPES or issubclass(t, Enum):
+        return obj
     if is_list(t):
         to = []
         for o in obj:
-            to.append(to_dict(o))
-        return to
+            use_val = to_dict(o, key_case=key_case, remove_empty=remove_empty)
+            if not remove_empty or use_val is not None:
+                to.append(use_val)
     elif is_dict(t):
         to = {}
-        for k in obj:
-            to[k] = to_dict(obj[k])
-        return to
-    if is_dataclass(obj):
-        d = asdict(obj)
+        for k, v in obj.items():
+            use_key = key_case(_str(k))
+            use_val = to_dict(v, key_case=key_case, remove_empty=remove_empty)
+            if not remove_empty or use_val is not None:
+                to[use_key] = use_val
+    elif hasattr(obj, 'to_dict'):  # dataclass
+        d = obj.to_dict()
         to = {}
         for k, v in d.items():
-            use_key = camelcase(k)
-            if use_key[-1] == '_':
-                use_key = use_key[0:-1]
-            to[use_key] = v
+            use_key = key_case(_str(k))
+            use_val = to_dict(v, key_case=key_case, remove_empty=remove_empty)
+            if not remove_empty or use_val is not None:
+                to[use_key] = use_val
     elif hasattr(obj, '__dict__'):
-        return obj.__dict__
-    return clean_any(to)
+        to = to_dict(vars(obj), key_case=key_case, remove_empty=remove_empty)
+    else:
+        to = obj
+    if remove_empty:
+        return clean_any(to)
+    return to
 
 
 def _clean_list(d: list):
@@ -115,19 +135,18 @@ def _clean_dict(d: dict):
 
 def clean_any(d):
     """recursively remove empty lists, empty dicts, or None elements from a dictionary"""
-    if not isinstance(d, (dict, list)):
-        return d
-    elif isinstance(d, list):
+    if is_dict(d):
+        return _clean_dict(d)
+    elif is_list(d):
         return _clean_list(d)
     else:
-        return _clean_dict(d)
+        return d
 
 
 def _json_encoder(obj: Any):
-    if is_dataclass(obj):
+    t = type(obj)
+    if is_dataclass(t) or is_dict(t):
         return to_dict(obj)
-    if hasattr(obj, '__dict__'):
-        return vars(obj)
     if isinstance(obj, datetime):
         return obj.isoformat()
     if isinstance(obj, timedelta):
@@ -136,14 +155,15 @@ def _json_encoder(obj: Any):
         return base64.b64encode(obj).decode('ascii')
     if isinstance(obj, decimal.Decimal):
         return float(obj)
-    raise TypeError(f"Unsupported Type in JSON encoding: {type(obj)}")
+    if t in _JSON_TYPES:
+        return obj
+    if t in _BUILT_IN_TYPES or (type(obj) == type and issubclass(obj, Enum)):
+        return _str(obj)
+    raise TypeError(f"Unsupported Type in JSON encoding: {t}")
 
 
 def to_json(obj: Any, indent=None):
-    if is_dataclass(obj):
-        obj_dict = clean_any(obj.to_dict())
-        return json.dumps(obj_dict, indent=indent, default=_json_encoder)
-    return json.dumps(obj, indent=indent, default=_json_encoder)
+    return json.dumps(to_dict(obj), indent=indent, default=_json_encoder)
 
 
 class TypeConverters:
@@ -316,7 +336,7 @@ def convert(into: Type, obj: Any, substitute_types: Dict[Type, type] = None):
             except Exception as e:
                 Log.error(f"into().deserialize(obj) {into}({obj})", e)
                 raise e
-        elif is_type and issubclass(into, Enum):
+        elif is_type and (issubclass(into, Enum) or into == EnumMeta):
             try:
                 return enum_get(into, obj)
             except Exception as e:
@@ -345,7 +365,8 @@ def all_keys(obj):
     keys = []
     for o in obj:
         for key in o:
-            if not key in keys:
+            key = _str(key)
+            if key is not None and key not in keys:
                 keys.append(key)
     return keys
 
@@ -392,7 +413,7 @@ def _align_center(s: str, length: int, pad: str = ' '):
     if length < 0:
         return ""
     nlen = len(s)
-    half = (length // 2 - nlen // 2)
+    half = math.floor(length / 2 - nlen / 2)
     odds = abs((nlen % 2) - (length % 2))
     return (pad * (half + 1)) + s + (pad * (half + 1 + odds))
 
@@ -407,28 +428,28 @@ def _align_right(s: str, length: int, pad: str = ' '):
 
 
 def _align_auto(obj: Any, length: int, pad: str = ' '):
-    s = f"{obj}"
+    s = _str(obj)
     if len(s) <= length:
         if isinstance(obj, numbers.Number):
             return _align_right(s, length, pad)
         return _align_left(s, length, pad)
     return s
 
 
-def dumptable(objs, headers=None):
+def table(objs, headers=None):
     if not is_list(type(objs)):
         raise TypeError('objs must be a list')
     map_rows = to_dict(objs)
     if headers is None:
-        headers = _allkeys(map_rows)
+        headers = all_keys(map_rows)
     col_sizes: Dict[str, int] = {}
 
     for k in headers:
         max = len(k)
         for row in map_rows:
             if k in row:
                 col = row[k]
-                val_size = len(f"{col}")
+                val_size = len(_str(col))
                 if val_size > max:
                     max = val_size
             col_sizes[k] = max
@@ -454,5 +475,5 @@ def dumptable(objs, headers=None):
     return '\n'.join(sb)
 
 
-def printdumptable(obj, headers=None):
-    print(dumptable(obj, headers))
+def printtable(obj, headers=None):
+    print(table(obj, headers))
diff --git a/tests/test_inspect.py b/tests/test_inspect.py
@@ -33,7 +33,7 @@ def test_does_dump(self):
         printdump(org_repos[0:3])
 
         print(f'\nTop 10 {org_name} Repos:')
-        printdumptable(org_repos[0:10], headers=['name', 'lang', 'watchers', 'forks'])
+        printtable(org_repos[0:10], headers=['name', 'lang', 'watchers', 'forks'])
 
         inspect_vars({'org_repos': org_repos})
 
@@ -42,8 +42,11 @@ def test_does_support_FindTechnologies(self):
         response = client.send(FindTechnologies(
             ids=[1, 2, 3],
             vendor_name="Google",
-            take=5))
+            take=5,
+            fields='id,name,vendorName,createdBy,viewCount,favCount'))
 
-        printdump(response)
-        printdumptable(response.results, headers=['id', 'name', 'vendorName', 'createdBy', 'viewCount', 'favCount'])
+        # printdump(response)
+        printtable(response.results)
+        printtable(response.results, headers=['id', 'name', 'vendor_name', 'view_count', 'fav_count'])
+        printtable(to_dict(response.results, key_case=titlecase))
         inspect_vars({"response": response})
diff --git a/tests/test_jsonserviceclient.py b/tests/test_jsonserviceclient.py
@@ -32,5 +32,5 @@ def test_does_serialize_dates_correctly_via_get_request(self):
     def test_should_generate_default_value(self):
         client = create_test_client()
         request = HelloTypes(bool_=False, int_=0)
-        request_url = append_querystring(TEST_URL, to_dict(request))
+        request_url = append_querystring(TEST_URL, to_dict(request, key_case=clean_camelcase))
         self.assertEqual(request_url, TEST_URL + "?bool=false&int=0")
