prodict 0.8.22__py3-none-any.whl

prodict/__init__.py

@@ -0,0 +1,278 @@
+# Global comments:
+# self is avoided to fix #15
+from typing import Any, List
+import copy
+
+DICT_RESERVED_KEYS = vars(dict).keys()
+
+
+class GenericMeta(type):
+    pass
+
+
+def _dict_value(v, is_recursive, exclude_none, exclude_none_in_lists, convert_list_items):
+    if is_recursive and isinstance(v, Prodict):
+        return v.to_dict(is_recursive=is_recursive, exclude_none=exclude_none,
+                        exclude_none_in_lists=exclude_none_in_lists,
+                        convert_list_items=convert_list_items)
+
+    # Handle lists: convert items to dict if requested
+    if isinstance(v, List) and (convert_list_items or exclude_none_in_lists):
+        # Determine whether to exclude None from list items
+        # If exclude_none_in_lists=True, always exclude None (legacy behavior)
+        # Otherwise, respect the parent's exclude_none setting
+        list_item_exclude_none = True if exclude_none_in_lists else exclude_none
+
+        return [
+            item.to_dict(exclude_none=list_item_exclude_none,
+                        is_recursive=is_recursive,
+                        exclude_none_in_lists=exclude_none_in_lists,
+                        convert_list_items=convert_list_items)
+            if isinstance(item, Prodict)
+            else item
+            for item in v
+        ]
+
+    return v
+
+
+def _none_condition(v, is_recursive, exclude_none):
+    return v is not None if exclude_none else True
+
+
+# noinspection PyMethodParameters
+class Prodict(dict):
+    """
+    Prodict = Dictionary with IDE friendly(auto code completion),
+    dot-accessible attributes and more.
+    """
+
+    def __init__(self_d921dfa9_4e93_4123_893d_a7e7eb783a32, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # #3: Set all properties to None
+        for (
+            k,
+            v,
+        ) in self_d921dfa9_4e93_4123_893d_a7e7eb783a32.attr_types().items():
+            self_d921dfa9_4e93_4123_893d_a7e7eb783a32.set_attribute(k, None)
+
+        # Set default values of annotated attributes
+        self_d921dfa9_4e93_4123_893d_a7e7eb783a32.init()
+        self_d921dfa9_4e93_4123_893d_a7e7eb783a32.set_attributes(**kwargs)
+
+    def init(self):
+        ...
+
+    def __new__(cls, *args, **kwargs):
+        return super(Prodict, cls).__new__(cls, *args, **kwargs)
+
+    def __getstate__(self):
+        return self.to_dict()
+
+    def __setstate__(self, state):
+        return Prodict.from_dict(state)
+
+    def __deepcopy__(self, memo=None):
+        new = self.from_dict({})
+        for key in self.keys():
+            new.set_attribute(key, copy.deepcopy(self[key], memo=memo))
+        return new
+
+    @classmethod
+    def from_dict(cls, d: dict):
+        return cls(**d)
+
+    @classmethod
+    def attr_has_default_value(cls, attr_name: str) -> bool:
+        return bool(hasattr(cls, attr_name))
+
+    @classmethod
+    def get_attr_default_value(cls, attr_name: str):
+        if cls.attr_has_default_value(attr_name):
+            return getattr(cls, attr_name)
+        else:
+            return None
+
+    @classmethod
+    def attr_type(cls, attr_name: str):
+        return cls.attr_types()[attr_name]
+
+    @classmethod
+    def attr_types(cls):
+        return cls.__annotations__ if hasattr(cls, '__annotations__') else {}
+
+    @classmethod
+    def attr_names(cls) -> List[str]:
+        """
+        Returns annotated attribute names
+        :return: List[str]
+        """
+        return [k for k, v in cls.attr_types().items()]
+
+    @classmethod
+    def has_attr(cls, attr_name: str):
+        """
+        Returns True if class have an annotated attribute
+        :param attr_name: Attribute name
+        :return: bool
+        """
+        return bool(cls.attr_types().get(attr_name))
+
+    def set_default(self, attr_name):
+        if self.attr_has_default_value(attr_name):
+            attr_default_type = self.attr_type(attr_name)
+            attr_default_value = self.get_attr_default_value(attr_name)
+            delattr(self, attr_name)
+            self.__annotations__[attr_name] = attr_default_type
+            self.set_attribute(attr_name, None)
+            self.update({attr_name: attr_default_value})
+
+    def get_constructor(self, attr_name, value):
+        """
+        This method is used for type conversion.
+        Prodict uses this method to get the type of a value, then based on the
+        value, it return a constructor. If the type of a value is 'float' then
+        it returns 'float' since 'float' is also a constructor to build a float
+        value.
+        """
+        attr_type1 = self.attr_type(attr_name)
+        constructor = None
+        element_type = None
+        if attr_type1 == float:
+            constructor = float
+        elif attr_type1 == str:
+            constructor = str
+        elif attr_type1 == int:
+            constructor = int
+        elif attr_type1 == list:
+            constructor = list
+        elif isinstance(value, Prodict):
+            constructor = attr_type1.from_dict
+        elif attr_type1 is Any:
+            constructor = None
+        elif isinstance(value, dict):
+            if attr_type1 == dict:
+                constructor = Prodict.from_dict
+            elif issubclass(attr_type1, Prodict):
+                constructor = self.attr_type(attr_name).from_dict
+        elif attr_type1 is List:
+            constructor = list
+        elif hasattr(attr_type1, '__origin__'):
+            if attr_type1.__dict__['__origin__'] is list:
+                # if the type is 'List[something]'
+                if len(attr_type1.__args__) == 0:
+                    constructor = list
+                elif len(attr_type1.__args__) == 1:
+                    constructor = List
+                    element_type = attr_type1.__args__[0]
+                elif len(attr_type1.__args__) > 1:
+                    raise TypeError('Only one dimensional List is supported')
+            elif attr_type1.__dict__['__origin__'] is tuple:
+                # if the type is 'Tuple[something]'
+                constructor = tuple
+
+        # print('constru={} element_type={}'.format(constructor, element_type))
+        return constructor, element_type
+
+    def set_attribute(self, attr_name, value):
+        if attr_name in DICT_RESERVED_KEYS:
+            raise TypeError("You cannot set a reserved name as attribute")
+        if self.has_attr(attr_name):
+            if value is None:
+                self.update({attr_name: None})
+            elif self.attr_type(attr_name) == Any:
+                self[attr_name] = value
+            else:
+                constructor, element_type = self.get_constructor(
+                    attr_name, value
+                )
+                if constructor is None:
+                    self.update({attr_name: value})
+                elif constructor == List:
+                    value_list: List[element_type] = value
+                    new_list: List[element_type] = []
+
+                    if issubclass(element_type, Prodict):
+                        element_constructor = element_type.from_dict
+                    else:
+                        element_constructor = element_type
+
+                    for v in value_list:
+                        new_list.append(element_constructor(v))
+                    self.update({attr_name: new_list})
+                elif constructor == list:
+                    self.update({attr_name: list(value)})
+                else:
+                    self.update({attr_name: constructor(value)})
+        else:
+            if isinstance(value, dict):
+                if isinstance(value, Prodict):
+                    constructor = value.from_dict
+                else:
+                    constructor = Prodict.from_dict
+                self.update({attr_name: constructor(value)})
+            else:
+                self.update({attr_name: value})
+
+    def set_attributes(self_d921dfa9_4e93_4123_893d_a7e7eb783a32, **d):
+        for k, v in d.items():
+            self_d921dfa9_4e93_4123_893d_a7e7eb783a32.set_attribute(k, v)
+
+    def __getattr__(self, item):
+        try:
+            return self[item]
+        except KeyError as exc:
+            raise AttributeError(f"{type(self).__name__!r} object has no attribute {exc!s}") from None
+
+    def __setattr__(self, name: str, value) -> None:
+        self.set_attribute(name, value)
+
+    def to_dict(
+        self,
+        *args,
+        is_recursive=False,
+        exclude_none=False,
+        exclude_none_in_lists=False,
+        convert_list_items=False,
+        **kwargs
+    ):
+        """
+        Converts Prodict to dict.
+
+        :param is_recursive: If True, nested Prodict attributes are converted to dicts
+        :param exclude_none: If True, attributes with None values are excluded from the result
+        :param exclude_none_in_lists: If True, Prodict items in lists are converted to dicts
+                                      with None values excluded (legacy behavior, implies convert_list_items=True)
+        :param convert_list_items: If True, Prodict items in lists are converted to dicts
+                                   (respects exclude_none setting for those items)
+        :return: dict
+
+        Examples:
+            # Keep list items as Prodict
+            obj.to_dict()  # or to_dict(is_recursive=False, convert_list_items=False)
+
+            # Convert list items to dict, keeping None values
+            obj.to_dict(convert_list_items=True)
+
+            # Convert list items to dict, excluding None values
+            obj.to_dict(convert_list_items=True, exclude_none=True)
+            # or obj.to_dict(exclude_none_in_lists=True)  # legacy, always excludes None
+
+            # Convert everything recursively
+            obj.to_dict(is_recursive=True, convert_list_items=True)
+        """
+        ret = {
+            k: _dict_value(
+                v,
+                is_recursive=is_recursive,
+                exclude_none=exclude_none,
+                exclude_none_in_lists=exclude_none_in_lists,
+                convert_list_items=convert_list_items,
+            )
+            for k, v in self.items()
+            if _none_condition(
+                v, is_recursive=is_recursive, exclude_none=exclude_none
+            )
+        }
+        return ret

prodict-0.8.22.dist-info/METADATA

@@ -0,0 +1,401 @@
+Metadata-Version: 2.4
+Name: prodict
+Version: 0.8.22
+Summary: Prodict = Pro Dictionary with IDE friendly(auto code completion), dot-accessible attributes and more.
+Project-URL: Homepage, https://github.com/ramazanpolat/prodict
+Project-URL: Download, https://pypi.python.org/pypi/prodict/0.8.22
+Project-URL: Repository, https://github.com/ramazanpolat/prodict
+Project-URL: Issues, https://github.com/ramazanpolat/prodict/issues
+Author-email: Ramazan Polat <ramazanpolat@gmail.com>
+License: MIT
+License-File: LICENSE.txt
+Keywords: auto-code-complete,auto-complete,dict,dictionary,dynamic-props,prodict,python3,typehinting
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Prodict
+Prodict = Dictionary with IDE friendly(auto code completion) and dot-accessible attributes **and more**.
+
+# What it does
+Ever wanted to use a `dict` like a class and access keys as attributes? **Prodict** does exactly this. 
+
+Although there are number of modules doing this, **Prodict** does a little bit **more**.
+
+You can provide type hints and get auto code completion!
+
+With type hints, you also get nested object instantiations, which will blow your mind.
+
+You will never want to use `dict` again.
+
+# Why?
+* Because accessing `dict` keys like `d['key']` is error prone and ugly.
+
+* Because it becomes uglier if it is nested, like `d['key1]['key2']['key3']`. Compare `d['key1]['key2']['key3']` to `d.key1.key2.key3`, which one looks better?
+
+* Because since web technologies mostly talk with JSON, it should be much more easy to use JSON data(see sample use case below).
+
+* Because auto code completion makes developers' life easier.
+
+* Because serializing a Python class to `dict` and deserializing from `dict` in one line is awesome!
+ 
+
+# Features
+
+  1) A class with dynamic properties, without defining it beforehand.
+
+```python
+j = Prodict()
+j.hi = 'there'
+```
+
+  2) Pass named arguments and all arguments will become properties.
+
+```python
+p = Prodict(lang='Python', pros='Rocks!')
+print(p.lang)  # Python
+print(p.pros)  # Rocks!
+print(p)  # {'lang': 'Python', 'pros': 'Rocks!'}
+```
+
+  3) Instantiate from a `dict`, get `dict` keys as properties
+```python
+p = Prodict.from_dict({'lang': 'Python', 'pros': 'Rocks!'})
+print(p.lang)   # Python
+p.another_property = 'this is dynamically added'
+```
+
+  4) Pass a `dict` as argument, get a nested `Prodict`!
+```python
+p = Prodict(package='Prodict', makes='Python', rock={'even': 'more!'})
+print(p)  #  {'package': 'Prodict', 'makes': 'Python', 'rock': {'even': 'more!'}}
+print(p.rock.even)  #  'more!'
+print(type(p.rock))  # <class 'prodict.Prodict'>
+```
+
+  5) Extend `Prodict` and use type annotations for auto type conversion and auto code completion
+```python
+class User(Prodict):
+    user_id: int
+    name: str
+
+user = User(user_id="1", name="Ramazan")
+type(user.user_id) # <class 'int'>
+# IDE will be able to auto complete 'user_id' and 'name' properties(see example 1 below)
+```
+Why type conversion? Because it will be useful if the incoming data doesn't have the desired type.
+
+```python
+class User(Prodict):
+    user_id: int
+    name: str
+    literal: Any
+    
+response = requests.get("https://some.restservice.com/user/1").json()
+user: User = User.from_dict(response)
+type(user.user_id) # <class 'int'>
+```
+
+**Notes on automatic type conversion**:
+* In the above example code, `user.user_id` will be an `int`, even if rest service responded with `str`.
+* Same goes for all built-in types(int, str, float, bool, list, tuple), except `dict`. Because by default, all `dict` types will be converted to `Prodict`.
+* If you don't want any type conversion but still want to have auto code completion, use `Any` as type annotation, like the `literal` attribute defined in `User` class.
+* If the annotated type of an attribute is sub-class of a `Prodict`, the provided `dict` will be instantiated as the instance of sub-class. Even if it is `List` of the sub-class(see sample usa case below).
+
+
+
+# Sample use case
+
+Suppose that you are getting this JSON response from `https://some.restservice.com/user/1`:
+
+```javascript
+{
+  user_id: 1,
+  user_name: "rambo",
+  posts: [
+    {
+      title:"Hello World",
+      text:"This is my first blog post...",
+      date:"2018-01-02 03:04:05",
+      comments: [
+          {
+            user_id:2,
+            comment:"Good to see you blogging",
+            date:"2018-01-02 03:04:06"
+          },
+          {
+            user_id:3,
+            comment:"Good for you",
+            date:"2018-01-02 03:04:07"
+          }
+        ]
+    },
+    {
+      title:"Leave the old behind",
+      text:"Stop using Python 2.x...",
+      date:"2018-02-03 04:05:06",
+      comments: [
+          {
+            user_id:4,
+            comment:"Python 2 is dead, long live Python",
+            date:"2018-02-03 04:05:07"
+          },
+          {
+            user_id:5,
+            comment:"You are god damn right :wears Heissenberg glasses:",
+            date:"2018-02-03 04:05:08"
+          }
+        ]
+    }
+  ]
+}
+```
+Despite the fact that JSON being schemaless, most REST services will respond with a certain structure.
+In the above example, the structure is something like this:
+```
+User
+ |--> user_id
+ |--> user_name
+ |--> posts [post]
+       |--> title
+       |--> text
+       |--> date
+       |--> comments [comment]
+             |--> user_id
+             |--> comment
+             |--> date
+```
+
+And you want to convert this to appropriate Python classes.
+
+Without `Prodict`:
+
+```python
+class Comment:
+	def __init__(self, user_id, comment, date):
+    	self.user_id = user_id
+    	self.comment = comment
+        self.date = date
+        
+class Post:
+    def __init__(self, title, text, date):
+    	self.title = title
+        self.text = text
+        self.date = date
+        self.comments = []
+        
+class User:
+    def __init__(self, user_id, user_name):
+        self.user_id = user_id
+        self.user_name = user_name
+        self.posts = []
+
+user_json = requests.get("https://some.restservice.com/user/1").json()
+posts = [Post(post['title'], post['text'], post['date']) for post in user_json['posts']]
+for post in posts:
+    post.comments = [[comment for comment in post['comments']] for post in user_json['posts']]
+
+user = User(user_json['user_id'], user_json['user_name'])
+user.posts = posts
+
+for post in user.posts:
+    print(post.title)
+
+```
+
+With **Prodict** you just need to define the classes and let the prodict do the rest like this:
+
+```python
+class Comment(Prodict):
+    user_id: int
+    comment: str
+    date: str
+
+class Post(Prodict):
+    title: str
+    text: str
+    date: str
+    comments: List[Comment]
+        
+class User(Prodict):
+    user_id: int
+    user_name: str
+    posts: List[Post]
+
+user_json = requests.get("https://some.restservice.com/user/1").json()
+user:User = User.from_dict(user_json)
+# Don't forget to annotate the `user` with `User` type in order to get auto code completion.
+```
+
+See the difference?
+Plus you can add new attributes to `User`, `Post` and `Comment` objects dynamically and access them as dot-accessible attributes.
+
+
+# Examples
+
+**Example 0**: Use it like regular `dict`, because **it is** a dict.
+```python
+
+from prodict import Prodict
+
+d = dict(lang='Python', pros='Rocks!')
+p = Prodict(lang='Python', pros='Rocks!')
+
+print(d)  # {'lang': 'Python', 'pros': 'Rocks!'}
+print(p)  # {'lang': 'Python', 'pros': 'Rocks!'}
+print(d == p)  # True
+
+p2 = Prodict.from_dict({'Hello': 'world'})
+
+print(p2)  # {'Hello': 'world'}
+print(issubclass(Prodict, dict))  # True
+print(isinstance(p, dict))  # True
+print(set(dir(dict)).issubset(dir(Prodict)))  # True
+```
+
+**Example 1**: Accessing keys as attributes and auto completion.
+```python
+from prodict import Prodict
+class Country(Prodict):
+    name: str
+    population: int
+
+turkey = Country()
+turkey.name = 'Turkey'
+turkey.population = 79814871
+```
+
+![auto code complete](/auto-complete1.png?raw=true "Auto complete in action!")
+
+**Example 2**: Auto type conversion
+```python
+germany = Country(name='Germany', population='82175700', flag_colors=['black', 'red', 'yellow'])
+
+print(germany.population)  # 82175700
+print(type(germany.population))  # <class 'int'> <-- The type is `int` !
+# If you don't want type conversion and still want to have auto code completion, use `Any` as type.
+print(germany.flag_colors)  # ['black', 'red', 'yellow']
+print(type(germany.population))  # <class 'int'>
+```
+
+**Example 3**: Nested class instantiation
+```python
+class Ram(Prodict):
+    capacity: int
+    unit: str
+    type: str
+    clock: int
+
+class Computer(Prodict):
+    name: str
+    cpu_cores: int
+    rams: List[Ram]
+
+    def total_ram(self):
+        return sum([ram.capacity for ram in self.rams])
+
+comp1 = Computer.from_dict(
+    {
+        'name': 'My Computer',
+        'cpu_cores': 4,
+        'rams': [
+            {'capacity': 4,
+             'unit': 'GB',
+             'type': 'DDR3',
+             'clock': 2400}
+        ]
+    })
+print(comp1.rams)  #  [{'capacity': 4, 'unit': 'GB', 'type': 'DDR3', 'clock': 2400}]
+
+comp1.rams.append(Ram(capacity=8, type='DDR3'))
+comp1.rams.append(Ram.from_dict({'capacity': 12, 'type': 'DDR3', 'clock': 2400}))
+
+print(comp1.rams)
+# [
+#   {'capacity': 4, 'unit': 'GB', 'type': 'DDR3', 'clock': 2400}, 
+#   {'capacity': 8, 'type': 'DDR3'}, 
+#   {'capacity': 12, 'type': 'DDR3', 'clock': 2400}
+# ]
+print(type(comp1.rams))  # <class 'list'>
+print(type(comp1.rams[0]))  # <class 'Ram'> <-- Mind the type !
+```
+
+**Example 4**: Provide default values
+
+You can use `init` method to provide default values. Keep in mind that `init` is NOT `__init__` but `init` method will be called in `__init__` method.
+
+Additionally, you can use `init` method instead of `__init__` without referring to `super`.
+
+```python
+class MyDataWithDefaults(Prodict):
+    an_int: int
+    a_str: str
+    
+    def init(self):
+        self.an_int = 42
+        self.a_str = 'string'
+        
+
+data = MyDataWithDefaults(dynamic=43)
+print(data)
+# {'an_int':42, 'a_str':'string', 'dynamic':43}
+
+``` 
+
+# Class attributes vs Instance attributes
+
+Prodict only works for instance attributes.
+Even if you try to set an inherited class attribute, a new instance attribute is created and set.
+
+Consider this example:
+```python
+from prodict import Prodict
+
+class MyClass(Prodict):
+    class_attr: int = 42  # class_attr is a class attribute, not instance attribute
+
+my_class = MyClass()
+print(f"my_class.class_attr: {my_class.class_attr}")  # 42
+# There is no 'class_attr' defined as instance attribute, so class attribute will be returned (42).
+print(f"MyClass.class_attr: {MyClass.class_attr}") # 42
+# This is a class attribute, it will be returned as is.
+
+# Now an instance attribute 'class_attr' is created and set to 77
+my_class.class_attr = 77
+print(f"my_class.class_attr: {my_class.class_attr}")  # 42
+# For this matter, avoid setting class_attribute with dot notation, use class name instead
+
+MyClass.class_attr = 88
+print(f"MyClass.class_attr: {my_class.class_attr}")  # 88
+
+# So where did 77 go? It is in instance attribute of the class and since it's name is colliding with
+# the class attribute, you can't get it by dot notation. You can use .get tho.
+print(f"my_class.get('class_attr'): {my_class.get('class_attr')}")  # 77
+```
+
+
+# Installation
+If your default Python is 3.7:
+
+`pip install prodict`
+
+If you have more than one Python versions installed:
+
+`python3.7 -m pip install prodict`
+
+
+# Limitations
+- You cannot use `dict` method names as attribute names because of ambiguity.
+- You cannot use `Prodict` method names as attribute names(I will change `Prodict` method names with dunder names to reduce the limitation).
+- You must use valid variable names as `Prodict` attribute names(obviously). For example, while '1' cannot be an attribute for `Prodict`, it is perfectly valid for a `dict` to have '1' as a key. You can still use prodict.set_attribute('1',123) tho.
+- Requires Python 3.7+
+
+# Thanks
+I would like to thank to [JetBrains](https://www.jetbrains.com/) for creating [PyCharm](https://www.jetbrains.com/pycharm/), the IDE that made my life better.
+

prodict-0.8.22.dist-info/RECORD

@@ -0,0 +1,5 @@
+prodict/__init__.py,sha256=2nwvI0LPfcGTeImCfXYn1AHBTXOGSWZHXN1MFXh4V4Q,10150
+prodict-0.8.22.dist-info/METADATA,sha256=XJkAQGZbuL3YX5m59IGtT_Begq1ULMWpaWsXzVgHyMk,12357
+prodict-0.8.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+prodict-0.8.22.dist-info/licenses/LICENSE.txt,sha256=TEAKv1BbARNOlwFP1msyt1RtXuDBjXIwNcjjqkJBaJk,1095
+prodict-0.8.22.dist-info/RECORD,,

prodict-0.8.22.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

prodict-0.8.22.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Ramazan Polat (ramazanpolat@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.