Merge pull request #17 from star-inc/rolling

v6.5.2-stable from Rolling

Author: supersonictw

COPYING.md

@@ -0,0 +1,20 @@
+# Star Yuuki BOT - Yuuki
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+1)You can edit/copy these files, but you need to keep the original "[COPYING.md](COPYING.md)", "[LICENSE.md](LICENSE.md)" and  in the program which you did it.
+
+2)The copyright of [Line Services](https://line.starinc.xyz/) contents belongs to [Star Inc.](https://starinc.xyz)
+
+3)Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+4)If your using cause any legal problem, we DO NOT assume any responsibility.
+
+5)Enjoy using ;)
+
+    This Source Code Form is "Incompatible With Secondary Licenses", as
+    defined by the Mozilla Public License, v. 2.0.
+
+Copyright 2019 [Star Inc.](https://starinc.xyz) All Rights Reserved.

COPYRIGHT.md

@@ -1,6 +1,6 @@
 Star Yuuki(pYthon) BOT - Yuuki
 ==================
-![Version](https://img.shields.io/badge/v6.5.1-OpenSource-33FF33.svg) ![License](https://img.shields.io/badge/license-MPL--2.0-FF8800.svg) ![Python](https://img.shields.io/badge/python-3.x-0066FF.svg)
+![Version](https://img.shields.io/badge/v6.5.2-OpenSource-FF0033.svg) ![Series](https://img.shields.io/badge/syb-Series-7700FF.svg) ![License](https://img.shields.io/badge/license-MPL--2.0-FF6600.svg) ![Python](https://img.shields.io/badge/python-3.x-0066FF.svg) ![Platform](https://img.shields.io/badge/base_on-LINE-00DD00.svg)
 
 A Python BOT for LINE Group Protection with LINE Unofficial API.
 ![ICON](logo.png)
@@ -10,7 +10,7 @@ Yeah! This is the BOT which was the first Chinese LINE Group Security BOT.
 Now, it is OpenSource.
 
 ## License
-The software licensed under Mozilla Public LICENSE 2.0.
+The software licensed under [Mozilla Public License 2.0](LICENSE.md) with [COPYING.md](COPYING.md).
 
 ## Warning
 Some function of old version maybe will make your LINE account be banned.
@@ -21,6 +21,7 @@ Recommand Environment:
     Ubuntu >= 18.04
     python >= 3.7
     pip >= 19.2
+    git >= 2.17
 
 You need the "LINE Unofficial API Core for Python". (Ex:[olsb](https://github.com/star-inc/olsb_cores),  [akad](https://pypi.org/project/akad), [curve](https://pypi.org/project/curve) ...)
 

README.md

@@ -1,23 +1,27 @@
 #!/usr/bin/python3
 # coding=UTF-8
 
-import os, time, json
+import \
+    os, \
+    time,\
+    json, \
+    random,\
+    requests
 from .core.ttypes import OpType
 
+from .data_mds import listen as msd_listen
+
 from .thread_control import Yuuki_Thread
 from .thread_control import Yuuki_Multiprocess
 
 class Yuuki_Data:
     def __init__(self, threading):
         self.threading = threading
         self.ThreadControl = Yuuki_Thread()
-        self.MpDataControl = Yuuki_Multiprocess()
+        MdsThreadControl = Yuuki_Multiprocess()
 
         # Data
-        if self.threading:
-            self.Data = self.MpDataControl.dataManager.dict()
-        else:
-            self.Data = {}
+        self.Data = {}
 
         self.DataType = {
             "Global":{
@@ -79,6 +83,25 @@ def __init__(self, threading):
                     self.Data[Type] = self.DataType[Type]
                     f.write(json.dumps(self.Data[Type]))
 
+        # Python MDS
+
+        if self.threading:
+            self.mdsHost = "http://localhost:2019/"
+            self.mdsCode = "{}.{}".format(random.random(), time.time())
+            MdsThreadControl.add(msd_listen, (self.mdsCode,))
+
+            # MDS Sync
+
+            time.sleep(1)
+            requests.post(
+                url=self.mdsHost,
+                json={
+                    "code": self.mdsCode,
+                    "do": "SYC",
+                    "path": self.Data
+                }
+            )
+
         # Log
 
         self.LogType = {
@@ -111,31 +134,92 @@ def ThreadExec(self, Function, args):
         else:
             Function(*args)
 
+    def _mdsShake(self, do, path, data=None):
+        if self.threading:
+            mds = requests.post(
+                url=self.mdsHost,
+                json={
+                    "code": self.mdsCode,
+                    "do": do,
+                    "path": path,
+                    "data": data
+                }
+            )
+            over = mds.json()
+            assert_result = "mds - ERROR\n{} on {}".format(do, path)
+            assert over["status"] == 200, assert_result
+            return over
+        else:
+            status = {"status" : 0}
+            return json.dumps(status)
+
+    def _local_query(self, query_data):
+        if type(query_data) is list:
+            result = self.Data
+            query_len = len(query_data)
+            source_data = self.Data
+            for count, key in enumerate(query_data):
+                if key in source_data:
+                    if count < (query_len - 1):
+                        if type(source_data.get(key)) is dict:
+                            source_data = source_data.get(key)
+                        else:
+                            result = 1
+                            break
+                    else:
+                        result = source_data.get(key)
+                else:
+                    result = 2
+                    break
+
+            return result
+        return 0
+
+    def _local_update(self, path, data):
+        over = self._local_query(path)
+        if not str(over).isnumeric():
+            over.update(data)
+        return False
+
     def file(self, Type, Mode, Format):
         if Format == "Data":
             return open(self.DataPath + self.DataName.format(Type), Mode)
         elif Format == "Log":
             return open(self.LogPath + self.LogName.format(Type), Mode)
 
     def syncData(self):
+        if self.threading:
+            self.Data = self.getData([])
         for Type in self.DataType:
             with self.file(Type, "w", "Data") as f:
                 f.write(json.dumps(self.Data[Type]))
+        return self.getData(["Global","Power"])
 
-    def updateData(self, Object, Input, Data):
+    def updateData(self, path, data):
         if self.threading:
-            self.ThreadExec(self._updateData, (Object, Input, Data))
+            self.ThreadExec(self._updateData, (path, data))
         else:
-            self._updateData(Object, Input, Data)
+            self._updateData(path, data)
 
-    def _updateData(self, Object, Input, Data):
-        if type(Object) == list:
-            if Input:
-                Object.append(Data)
-            else:
-                Object.remove(Data)
-        elif type(Object) == dict:
-            Object[Input] = Data
+    def _updateData(self, path, data):
+        assert path and type(path) is list, "Empty path - updateData"
+        if len(path) == 1:
+            origin_data = self.getData([])
+            assert type(origin_data) is dict, "Error origin data type (1) - updateData"
+            origin = origin_data.copy()
+            origin[path[0]] = data
+            path = []
+        else:
+            origin_data = self.getData(path[:-1])
+            assert type(origin_data) is dict, "Error origin data type (2) - updateData"
+            origin = origin_data.copy()
+            origin[path[-1]] = data
+            path = path[:-1]
+        assert type(origin) is dict, "Error request data type - updateData"
+        if self.threading:
+            self._mdsShake("UPT", path, origin)
+        else:
+            self._local_update(path, origin)
 
     def updateLog(self, Type, Data):
         if self.threading:
@@ -147,42 +231,39 @@ def _updateLog(self, Type, Data):
         with self.file(Type, "a", "Log") as f:
             f.write(self.LogType[Type] % Data)
 
-    def getTime(self, format="%b %d %Y %H:%M:%S %Z"):
+    @staticmethod
+    def getTime(time_format="%b %d %Y %H:%M:%S %Z"):
         Time = time.localtime(time.time())
-        return time.strftime(format, Time)
-
-    def getData(self, Type):
-        return self.Data[Type]
-
-    def getLimit(self, Type):
-        LimitInfo = self.getData("LimitInfo")
-        if Type == "Kick":
-            Limit = {}
-            for Mode in LimitInfo["KickLimit"]:
-                Limit[Mode] = int(LimitInfo["KickLimit"][Mode])
-        elif Type == "Cancel":
-            Limit = {}
-            for Mode in LimitInfo["CancelLimit"]:
-                Limit[Mode] = int(LimitInfo["CancelLimit"][Mode])
+        return time.strftime(time_format, Time)
+
+    def getData(self, path):
+        if self.threading:
+            return self._mdsShake("GET", path).get("data")
         else:
-            Limit = None
-        return Limit
+            return self._local_query(path)
 
     def getGroup(self, GroupID):
-        Groups = self.getData("Group")
+        Groups = self.getData(["Group"])
         if len(Groups) > 0:
             GroupIDs = [Group for Group in Groups]
             if GroupID not in GroupIDs:
-                Groups[GroupID] = self.GroupType
+                self.updateData(["Group", GroupID], self.GroupType)
         else:
-            Groups[GroupID] = self.GroupType
-        return Groups[GroupID]
+            self.updateData(["Group", GroupID], self.GroupType)
+        return self.getData(["Group", GroupID])
 
     def getSEGroup(self, GroupID):
-        SEMode = self.getGroup(GroupID).get("SEGroup")
-        if SEMode == None:
+        GroupData = self.getGroup(GroupID)
+        SEMode = GroupData.get("SEGroup")
+        if SEMode is None:
             return None
         SEMode_ = {}
         for Mode in SEMode:
             SEMode_[int(Mode)] = SEMode[Mode]
         return SEMode_
+
+    def limitDecrease(self, limit_type, userId):
+        if self.threading:
+            self._mdsShake("YLD", limit_type, userId)
+        else:
+            self.Data["LimitInfo"][limit_type][userId] -= 1