python - Pythonでsudsオブジェクトをシリアル化する

Question

さて、私はPythonでより良くなるように取り組んでいるので、これが私が最初にやっていることを実行する正しい方法であるかどうかはわかりませんが、これが私の現在の問題です...

SOAPメソッドを介していくつかの情報を取得する必要があり、現在は情報の一部のみを使用しますが、将来の使用のために結果全体を保存します（サービスの使用はできるだけ少なくする必要があります）。私が考えたサービスにアクセスするための最良の方法を探すことは、行く方法であり、それは単純で、データを取得するための魅力のように機能しました。しかし今、私は結果をどうにかして保存したいと思います。後でそれを引き出して同じように使用できるように、できればシリアル化/データベースに保存します。

これを行うための最良の方法は何ですか、pickle / jsonはオプションではないように見えますか？ありがとう！

更新「泡の結果をピクルスにするにはどうすればよいですか？」 のトップアンサーを読んでください。なぜこれがオプションではないのかについてのより良いアイデアを私に与えてくれます、私は私が必要な情報で基本的なオブジェクトを再作成するのに行き詰まっていると思いますか？

Answer 1

私は次のアプローチを使用してSudsオブジェクトをJSONに変換しています。

from suds.sudsobject import asdict

def recursive_asdict(d):
    """Convert Suds object into serializable format."""
    out = {}
    for k, v in asdict(d).items():
        if hasattr(v, '__keylist__'):
            out[k] = recursive_asdict(v)
        elif isinstance(v, list):
            out[k] = []
            for item in v:
                if hasattr(item, '__keylist__'):
                    out[k].append(recursive_asdict(item))
                else:
                    out[k].append(item)
        else:
            out[k] = v
    return out

def suds_to_json(data):
    return json.dumps(recursive_asdict(data))

Answer 2

はい、私はあなたが参照する答えで私が与えた説明を確認します-動的に生成されたクラスは簡単に選択できません（または他の方法で簡単にシリアル化できません）、すべての状態情報を抽出し、その状態を選択し、取得時にトリッキーなsudsobjectを再構築する必要がありますあなたが本当にそれを使うことを主張するならば;-)。

Answer 3

これが私がこの答えを調べて見つける前に思いついたものです。__builtins__これは、複雑なsud応答や、ソリューションがsudに依存しないためなど、他のオブジェクトでも実際にうまく機能します。

import datetime

def object_to_dict(obj):
    if isinstance(obj, (str, unicode, bool, int, long, float, datetime.datetime, datetime.date, datetime.time)):
        return obj
    data_dict = {}
    try:
        all_keys = obj.__dict__.keys()  # vars(obj).keys()
    except AttributeError:
        return obj
    fields = [k for k in all_keys if not k.startswith('_')]
    for field in fields:
        val = getattr(obj, field)
        if isinstance(val, (list, tuple)):
            data_dict[field] = []
            for item in val:
                data_dict[field].append(object_to_dict(item))
        else:
            data_dict[field] = object_to_dict(val)
    return data_dict

このソリューションは機能し、実際には高速です。また、属性を持たないオブジェクトでも機能し__keylist__ます。

複雑なsuds出力オブジェクトでベンチマークを100回実行しました。このソリューションの実行時間は、0.04〜.052秒（平均0.045724287）でした。上記recursive_asdictのソリューションは.082〜0.102秒で実行されたため、ほぼ2倍になりました（平均0.0829765582）。

次に、製図板に戻り、関数を再実行してパフォーマンスを向上させましたdatetime。インポートは必要ありません。__keylist__属性の使用を利用したので、これは次のような他のオブジェクトでは機能しません__builtins__が、sudsオブジェクトの出力ではうまく機能します。

def fastest_object_to_dict(obj):
    if not hasattr(obj, '__keylist__'):
        return obj
    data = {}
    fields = obj.__keylist__
    for field in fields:
        val = getattr(obj, field)
        if isinstance(val, list):  # tuple not used
            data[field] = []
            for item in val:
                data[field].append(fastest_object_to_dict(item))
        else:
            data[field] = fastest_object_to_dict(val)
    return data

実行時間は0.18〜0.033秒（平均0.0260889721）であり、recursive_asdictソリューションのほぼ4倍の速さでした。

Answer 4

泡のオブジェクトインスタンス用のダミークラスを実装し、シリアル化できるようにしました。FakeSudsInstanceは、元のSudsObjectインスタンスのように動作します。以下を参照してください。

from suds.sudsobject import Object as SudsObject

class FakeSudsNode(SudsObject):

    def __init__(self, data):
        SudsObject.__init__(self)
        self.__keylist__ = data.keys()
        for key, value in data.items():
            if isinstance(value, dict):
                setattr(self, key, FakeSudsNode(value))
            elif isinstance(value, list):
                l = []
                for v in value:
                    if isinstance(v, list) or isinstance(v, dict):
                        l.append(FakeSudsNode(v))
                    else:
                        l.append(v)
                setattr(self, key, l)
            else:
                setattr(self, key, value)


class FakeSudsInstance(SudsObject):

    def __init__(self, data):
        SudsObject.__init__(self)
        self.__keylist__ = data.keys()
        for key, value in data.items():
            if isinstance(value, dict):
                setattr(self, key, FakeSudsNode(value))
            else:
                setattr(self, key, value)

    @classmethod
    def build_instance(cls, instance):
        suds_data = {}
        def node_to_dict(node, node_data):
            if hasattr(node, '__keylist__'):
                keys = node.__keylist__
                for key in keys:
                    if isinstance(node[key], list):
                        lkey = key.replace('[]', '')
                        node_data[lkey] = node_to_dict(node[key], [])
                    elif hasattr(node[key], '__keylist__'):
                        node_data[key] = node_to_dict(node[key], {})
                    else:
                        if isinstance(node_data, list):
                            node_data.append(node[key])
                        else:
                            node_data[key] = node[key]
                return node_data
            else:
                if isinstance(node, list):
                    for lnode in node:
                        node_data.append(node_to_dict(lnode, {}))
                    return node_data
                else:
                    return node
        node_to_dict(instance, suds_data)
        return cls(suds_data)

さて、suds呼び出しの後、たとえば以下のようになります。

# Now, after a suds call, for example below
>>> import cPickle as pickle
>>> suds_intance = client.service.SomeCall(account, param)
>>> fake_suds = FakeSudsInstance.build_instance(suds_intance)
>>> dumped = pickle.dumps(fake_suds)
>>> loaded = pickle.loads(dumped)

お役に立てば幸いです。

Answer 5

上記で提案されたソリューションは、クラス名に関する貴重な情報を失います-エンティティタイプが動的に生成されたクラス名にエンコードされる可能性があるDFPクライアントhttps://github.com/googleads/googleads-python-libなどの一部のライブラリで価値がある可能性があります（つまり、 TemplateCreative / ImageCreative）

これが私が使用したソリューションで、クラス名を保持し、データを失うことなくdictシリアル化されたオブジェクトを復元します（通常のUnicodeオブジェクトやおそらく私が遭遇していない他のタイプに変換されるsuds.sax.text.Textを除く）

from suds.sudsobject import asdict, Factory as SudsFactory

def suds2dict(d):                                                               
    """                                                                         
    Suds object serializer 
    Borrowed from https://stackoverflow.com/questions/2412486/serializing-a-suds-object-in-python/15678861#15678861                                                     
    """                                                                         
    out = {'__class__': d.__class__.__name__}                                   
    for k, v in asdict(d).iteritems():                                          
        if hasattr(v, '__keylist__'):                                           
            out[k] = suds2dict(v)                                               
        elif isinstance(v, list):                                               
            out[k] = []                                                         
            for item in v:                                                      
                if hasattr(item, '__keylist__'):                                
                    out[k].append(suds2dict(item))                              
                else:                                                           
                    out[k].append(item)                                         
        else:                                                                   
            out[k] = v                                                          
    return out                                                                  


def dict2suds(d):                                                               
    """                                                                         
    Suds object deserializer                                                    
    """                                                                         
    out = {}                                                                    
    for k, v in d.iteritems():                                                  
        if isinstance(v, dict):                                                 
            out[k] = dict2suds(v)                                               
        elif isinstance(v, list):                                               
            out[k] = []                                                         
            for item in v:                                                      
                if isinstance(item, dict):                                      
                    out[k].append(dict2suds(item))                              
                else:                                                           
                    out[k].append(item)                                         
        else:                                                                   
            out[k] = v                                                          
    return SudsFactory.object(out.pop('__class__'), out)  

Answer 6

上記recursive_asdictの例を（の代わりに） python3と互換性があるように更新しました。itemsiteritems

from suds.sudsobject import asdict
from suds.sax.text import Text

def recursive_asdict(d):
    """
    Recursively convert Suds object into dict.
    We convert the keys to lowercase, and convert sax.Text
    instances to Unicode.

    Taken from:
    https://stackoverflow.com/a/15678861/202168

    Let's create a suds object from scratch with some lists and stuff
    >>> from suds.sudsobject import Object as SudsObject
    >>> sudsobject = SudsObject()
    >>> sudsobject.Title = "My title"
    >>> sudsobject.JustAList = [1, 2, 3]
    >>> sudsobject.Child = SudsObject()
    >>> sudsobject.Child.Title = "Child title"
    >>> sudsobject.Child.AnotherList = ["4", "5", "6"]
    >>> childobject = SudsObject()
    >>> childobject.Title = "Another child title"
    >>> sudsobject.Child.SudObjectList = [childobject]

    Now see if this works:
    >>> result = recursive_asdict(sudsobject)
    >>> result['title']
    'My title'
    >>> result['child']['anotherlist']
    ['4', '5', '6']
   """
    out = {}
    for k, v in asdict(d).items():
        k = k.lower()
        if hasattr(v, '__keylist__'):
            out[k] = recursive_asdict(v)
        elif isinstance(v, list):
            out[k] = []
            for item in v:
                if hasattr(item, '__keylist__'):
                    out[k].append(recursive_asdict(item))
                else:
                    out[k].append(
                        item.title() if isinstance(item, Text) else item)
        else:
            out[k] = v.title() if isinstance(v, Text) else v
    return out

Answer 7

私はこのように好きです。自分で反復を行うのではなく、文字列に変換するときに反復するのはPythonです。

class Ob:
    def __init__(self, J) -> None:
        self.J = J
    
    def __str__(self):           

        if hasattr(self.J, "__keylist__"):
            self.J = {key: Ob(value) for key, value in dict(self.J).items()}
        if hasattr(self.J, "append"):
            self.J = [Ob(data) for data in sefl.J]
        return str(self.J)

result = Ob(result_soap)