restructure imports + code base

Author: mythz

servicestack/__init__.py

@@ -1,5 +1,4 @@
 __all__ = [
-    'JsonServiceClient',
     'IReturn',
     'IReturnVoid',
     'IGet',
@@ -55,11 +54,29 @@
     'StringResponse',
     'StringsResponse',
     'AuditBase',
+    'JsonServiceClient',
+    'WebServiceException',
+    'to_json',
+    'from_json',
     'qsvalue',
     'resolve_httpmethod',
-    'Bytes'
+    'index_of',
+    'last_index_of',
+    'left_part',
+    'right_part',
+    'last_left_part',
+    'last_right_part',
+    'split_on_first',
+    'split_on_last',
+    'to_timespan',
+    'from_timespan',
+    'from_datetime',
+    'to_bytearray',
+    'from_bytearray',
+    'Bytes',
 ]
 
-from .servicestack import JsonServiceClient, json_encode, qsvalue, resolve_httpmethod, Bytes
+from .dtos import *
+from .clients import JsonServiceClient, WebServiceException, to_json, from_json, qsvalue, resolve_httpmethod
 from .utils import *
-from .client_dtos import *
+from .fields import *

servicestack/servicestack.py renamed to servicestack/clients.py

@@ -2,13 +2,13 @@
 import json
 from re import L
 
-from servicestack.utils import to_timespan
+from requests.models import Response
+from requests.exceptions import HTTPError
 
-from requests.models import HTTPError, Response
-
-from servicestack.client_dtos import IDelete, IGet, IPatch, IPost, IPut, IReturn, IReturnVoid, ResponseStatus, KeyValuePair
+from servicestack.dtos import *
 from servicestack.log import Log
 from servicestack.utils import *
+from servicestack.fields import *
 
 from typing import Callable, TypeVar, Generic, Optional, Dict, List, Tuple, get_args, Any, Type
 from dataclasses import dataclass, field, fields, asdict, is_dataclass, Field
@@ -19,21 +19,10 @@
 import requests
 import base64
 import decimal
+import inspect
 
 JSON_MIME_TYPE = "application/json"
 
-class Bytes(mf.Field):
-    def _serialize(self, value, attr, obj, **kwargs):
-        return to_bytearray(value)
-
-    def _deserialize(self, value, attr, data, **kwargs):
-        return from_bytearray(value)
-
-mm.TYPES[timedelta] = mf.DateTime
-mm.TYPES[KeyValuePair] = KeyValuePair[str,str]
-mm.TYPES[bytes] = Bytes
-mm.TYPES[Bytes] = Bytes
-
 @dataclass
 class A:
     l: list
@@ -129,33 +118,20 @@ def _json_encoder(obj:Any):
         return base64.b64encode(obj).decode('ascii')
     raise TypeError(f"Unsupported Type in JSON encoding: {type(obj)}")
 
-def json_encode(obj:Any):
+def to_json(obj:Any):
     if is_dataclass(obj):
-        # return obj.to_json()
         return json.dumps(clean_any(obj.to_dict()), default=_json_encoder)
     return json.dumps(obj, default=_json_encoder)
 
-def _json_decoder(obj:Any):
-    # print('ZZZZZZZZZZZZZZZZZ')
-    # print(type(obj))
-    return obj
-
 class TypeConverters:
     converters: dict[Type, Callable[[Any],Any]]
 
     def register(type:Type, converter:Callable[[Any],Any]):
         TypeConverters.converters[type] = converter
 
 TypeConverters.converters = {
-    mf.Integer: int,
-    mf.Float: float,
-    mf.Decimal: decimal.Decimal,
-    mf.String: str,
-    mf.Boolean: bool,
     mf.DateTime: from_datetime,
     mf.TimeDelta: from_timespan,
-    Bytes: from_bytearray,
-    bytes: from_bytearray,
 }
 
 def is_optional(cls:Type): return f"{cls}".startswith("typing.Optional")
@@ -212,16 +188,25 @@ def convert(into:Type, obj:Any):
             try:
                 return converter(obj)
             except Exception as e:
-                Log.error(f"ERROR converter(obj) {into}({obj})", e)
+                Log.error(f"converter(obj) {into}({obj})", e)
+                raise e
+        elif inspect.isclass(into) and issubclass(into, mf.Field):
+            try:
+                return into().deserialize(obj)
+            except Exception as e:
+                Log.error(f"into().deserialize(obj) {into}({obj})", e)
                 raise e
         else:
-            # print(f"TRY {obj} into {into}")
             try:
                 return into(obj)
             except Exception as e:
-                Log.error(f"ERROR into(obj) {into}({obj})", e)
+                Log.error(f"into(obj) {into}({obj})", e)
                 raise e
 
+def from_json(into:Type, json_str:str):
+    json_obj = json.loads(json_str)
+    return convert(into, json_obj)
+
 def ex_message(e:Exception):
     if hasattr(e,'message'):
         return e.message
@@ -378,17 +363,14 @@ def _create_response(self, response:Response, info:SendContext):
         json_str = response.text
         if Log.debug_enabled: Log.debug(f"json_str: {json_str}")
 
-        if not into:
+        if into is None:
             return json.loads(json_str)
 
         if into is str:
             return json_str
 
         try:
-            # res_dto = into.schema().loads(json_str, object_hook=_json_decoder)
-
-            json_obj = json.loads(json_str)
-            res_dto = convert(into, json_obj)
+            res_dto = from_json(into, json_str)
         except Exception as e:
             Log.error(f"Failed to deserialize into {into}: {e}", e)
             raise e
@@ -399,20 +381,32 @@ def _raise_error(self, e:Exception):
         return e
 
     def _handle_error(self, hold_res:Response, e:Exception):
-        if e is WebServiceException:
+        if type(e) == WebServiceException:
             raise self._raise_error(e)
 
         web_ex = WebServiceException()
         web_ex.inner_exception = e
         web_ex.status_code = 500
         web_ex.status_description = ex_message(e)
 
-        if e is HTTPError:
-            web_ex.status_code = e.response.status_code
-            if Log.debug_enabled: Log.debug(f"{e}")
+        res = hold_res
+        if type(e) == HTTPError and not e.response is None:
+            res = e.response
 
-        if hold_res:
-            pass
+        if not res is None:
+            if Log.debug_enabled(): Log.debug(f"error.text: {res.text}")
+            web_ex.status_code = res.status_code
+            web_ex.status_description = res.reason
+
+            web_ex.response_status = ResponseStatus(
+                error_code=f"{res.status_code}",
+                message=res.reason)
+
+            try:
+                error_response = from_json(EmptyResponse, res.text)
+                web_ex.response_status = error_response.response_status
+            except Exception as ex:
+                Log.error(f"Could not deserialize error response {res.text}", ex)
 
         raise web_ex
 
@@ -449,7 +443,7 @@ def send_request(self, info:SendContext):
             if type(body) is str:
                 info.body_string = body
             else:
-                info.body_string = json_encode(body)
+                info.body_string = to_json(body)
 
         Log.debug(f"info method: {info.method}, url: {info.url}, body_string: {info.body_string}")
         response:Response = None

servicestack/client_dtos.py renamed to servicestack/dtos.py

@@ -0,0 +1,9 @@
+from servicestack.utils import *
+import marshmallow.fields as mf
+
+class Bytes(mf.Field):
+    def _serialize(self, value, attr, obj, **kwargs):
+        return to_bytearray(value)
+
+    def _deserialize(self, value, attr, data, **kwargs):
+        return from_bytearray(value)

servicestack/fields.py

@@ -47,3 +47,5 @@ def warn(msg:str, e:Exception=None):
     def error(msg:str, e:Exception=None):
         if Log.error_enabled():
             Log.logger.log(LogLevel.ERROR, msg, e)
+
+# Log.levels.append(LogLevel.DEBUG)

servicestack/log.py

@@ -1,13 +1,12 @@
 """ Basic Serialization Tests
 """
 
-from requests.api import put
-from servicestack.servicestack import json_encode
+from requests.api import put, request
 import unittest
 from .dtos import *
 from datetime import datetime, timedelta, timezone
 
-from servicestack import JsonServiceClient
+from servicestack import JsonServiceClient, WebServiceException, to_json
 
 # TEST_URL = "https://localhost:5001"
 TEST_URL = "http://localhost:5000"
@@ -169,7 +168,7 @@ def test_can_post_Hello_with_CustomPath(self):
         self.assertEqual(response.result, "Hello, World!")
 
     def test_can_post_hello_with_CustomPath_json_object(self):
-        json_obj = client.post_url("/hello", json_encode(Hello(name="World")))
+        json_obj = client.post_url("/hello", to_json(Hello(name="World")))
         self.assertIsInstance(json_obj, dict)
         response = HelloResponse(**json_obj)
         self.assertEqual(response.result, "Hello, World!")
@@ -179,3 +178,18 @@ def test_can_post_HelloAllTypes(self):
         response:HelloAllTypesResponse=client.post(request)
         self.assert_HelloAllTypesResponse(response)
 
+    def test_can_put_HelloAllTypes(self):
+        request=create_HelloAllTypes()
+        response:HelloAllTypesResponse=client.put(request)
+        self.assert_HelloAllTypesResponse(response)
+
+    def test_does_handle_404_error(self):
+        request = ThrowType(type="NotFound", message="not here")
+        try:
+            client.put(request)
+            self.fail("should throw")
+        except WebServiceException as ex:
+            status = ex.response_status
+            self.assertEqual(status.error_code, "NotFound")
+            self.assertEqual(status.message, "not here")
+

tests/test_client.py

@@ -3,18 +3,18 @@
 
 import unittest
 from .dtos import *
-from servicestack import json_encode, qsvalue, resolve_httpmethod
+from servicestack import to_json, qsvalue, resolve_httpmethod
 
 class ClientUtils(unittest.TestCase):
 
     def test_json_encode(self):
         h = Hello(name='A')
-        self.assertEqual(json_encode(None), 'null')
-        self.assertEqual(json_encode("A"), '"A"')
-        self.assertEqual(json_encode(1), '1')
-        self.assertEqual(json_encode(h), '{"name": "A"}')
-        self.assertEqual(json_encode([h,h]), '[{"name": "A"}, {"name": "A"}]')
-        self.assertEqual(json_encode({'a':h,'b':h}), '{"a": {"name": "A"}, "b": {"name": "A"}}')
+        self.assertEqual(to_json(None), 'null')
+        self.assertEqual(to_json("A"), '"A"')
+        self.assertEqual(to_json(1), '1')
+        self.assertEqual(to_json(h), '{"name": "A"}')
+        self.assertEqual(to_json([h,h]), '[{"name": "A"}, {"name": "A"}]')
+        self.assertEqual(to_json({'a':h,'b':h}), '{"a": {"name": "A"}, "b": {"name": "A"}}')
 
     def test_qsvalue(self):
         self.assertEqual(qsvalue(None), "")