1st commit

.env

+SQLALCHEMY_DATABASE_URI=mssql+pyodbc://TestXERP:Test00@192.168.1.70/XSmartERP?driver=ODBC+Driver+13+for+SQL+Server
+SQLALCHEMY_TRACK_MODIFICATIONS=False
\ No newline at end of file

App.py

+import os, sys
+PROJECT_ROOT = os.path.dirname(os.path.realpath(__file__))
+
+# Load Settings
+from dotenv import load_dotenv
+from pathlib import Path
+env_path = Path('.') / '.env'
+load_dotenv(dotenv_path=str(env_path.absolute()))
+
+# Start Application
+from flask import Flask
+App = Flask(__name__)
+
+# Initialize DB Connection
+from flask_sqlalchemy import SQLAlchemy
+App.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('SQLALCHEMY_DATABASE_URI')
+App.config['SQLALCHEMY_TRACK_MODIFICATIONS'] =  os.getenv('SQLALCHEMY_TRACK_MODIFICATIONS')
+db = SQLAlchemy(App)
+App.app_context().push()
+
+#Models
+from Models import *
\ No newline at end of file

Models/LCategoryDictionaryUsage.py

+from App import db
+
+class LCategoryDictionaryUsage(db.Model):
+    __tablename__ = 'LCategoryDictionaryUsage'
+    LaymanCategoryKey = db.Column(db.Integer,db.ForeignKey("LaymanCategory.LaymanCategoryKey"),primary_key=True)
+    LanguageKey = db.Column(db.Integer, db.ForeignKey("Language.LanguageKey"),primary_key=True)
+    AccountKey = db.Column(db.Integer,primary_key=True)
+    LaymanDictionaryKey = db.Column(db.Integer,db.ForeignKey("LaymanDictionary.LaymanDictionaryKey"),primary_key=True)
+    Count = db.Column(db.Integer)
+    def __init__(**kwargs):
+        super(LaymanCategoryUsage, self).__init__(**kwargs)
+    def __repr__(self):
+        return "<LCategoryDictionaryUsage: (LaymanDictionaryKey: %ld, LaymanCategoryKey:%ld)>" % (self.LaymanDictionaryKey,self.LaymanCategoryKey)
+

Models/Language.py

+from App import db
+
+class Language(db.Model):
+    __tablename__ = 'Language'
+    LanguageKey = db.Column(db.Integer, primary_key=True)
+    Type = db.Column(db.String(3))
+    AccountKey = db.Column(db.Integer)
+    Count = db.Column(db.Integer)
+
+    def __repr__(self):
+        return "<Language: [%s]>" % self.Type
\ No newline at end of file

Models/Layman.py

+from App import db
+from datetime import datetime
+class Layman(db.Model):
+    __tablename__ = 'Layman'
+    LaymanKey = db.Column(db.Integer, primary_key=True)
+    Title = db.Column(db.String(500))
+    Abstract = db.Column(db.String(8000))
+    CDate = db.Column(db.DateTime, default=datetime.now())
+    MDate = db.Column(db.DateTime, default=datetime.now())
+    Description = db.Column(db.Text)
+    Summary = db.Column(db.String())
+    LanguageKey = db.Column(db.Integer, db.ForeignKey("Language.LanguageKey"))
+    AccountKey = db.Column(db.Integer)
+    PaperKey = db.Column(db.Integer, db.ForeignKey("Paper.PaperKey"))
+    Count = db.Column(db.Integer)
+    MetaKeywords = db.Column(db.String(255))
+    SequenceID = db.Column(db.Integer,nullable=True)
+    Type = db.Column(db.String(1))
+    FKScore = db.Column(db.Float,nullable=True)
+
+    def __repr__(self):
+        return "<Layman: (LaymanKey: %ld)>" % self.LaymanKey
\ No newline at end of file

Models/LaymanCategory.py

+from App import db
+from datetime import datetime
+
+class LaymanCategory(db.Model):
+    __tablename__ = 'LaymanCategory'
+    LaymanCategoryKey = db.Column(db.Integer,primary_key=True)
+    Name = db.Column(db.String(300))
+    ParentID = db.Column(db.Integer)
+    SequenceID = db.Column(db.Integer)
+    CDate = db.Column(db.DateTime, default=datetime.now())
+    Count = db.Column(db.Integer)
+    Type = db.Column(db.String(1))
+    LanguageKey = db.Column(db.Integer, db.ForeignKey("Language.LanguageKey"))
+    AccountKey = db.Column(db.Integer)
+    ClassificationCode = db.Column(db.String(10))
+    MetaKeywords = db.Column(db.String(1000))
+    CorpusName = db.Column(db.String(100))
+    Field = db.Column(db.String(20))
+    def __init__(**kwargs):
+        super(LaymanCategory, self).__init__(**kwargs)
+    def __repr__(self):
+        return "<LaymanCategory: (LaymanCategoryKey: %ld)>" % (self.LaymanCategoryKey)
+

Models/LaymanDictionary.py

+from App import db
+
+class LaymanDictionary(db.Model):
+	__tablename__ = 'LaymanDictionary'
+	LaymanDictionaryKey = db.Column(db.Integer, primary_key=True)
+	OriginalTerm = db.Column(db.String(50))
+	LanguageKey = db.Column(db.Integer, db.ForeignKey("Language.LanguageKey"))
+	AccountKey = db.Column(db.Integer)
+	XMLData = db.Column(db.Text)
+	Count = db.Column(db.Integer)
+	Synonym = db.Column(db.String(50))
+	Meaning = db.Column(db.String(255))
+	Changeability = db.Column(db.Boolean)
+	Type = db.Column(db.String(50))
+	CompoundWord = db.Column(db.Boolean)
+
+	def __repr__(self):
+		return "<LaymanDictionary: [%s]>" % self.LaymanDictionaryKey
\ No newline at end of file

Models/Paper.py

+from App import db
+
+class Paper(db.Model):
+    __tablename__ = 'Paper'
+    PaperKey = db.Column(db.Integer,primary_key=True)
+    Title = db.Column(db.String(500))
+    Abstract = db.Column(db.String(8000))
+    CDate = db.Column(db.DateTime)
+    MDate = db.Column(db.DateTime)
+    Description = db.Column(db.Text)
+    Summary = db.Column(db.String(500))
+    PublishedDate = db.Column(db.DateTime, nullable=True)
+    ReferenceID = db.Column(db.String(50))
+    AcceptedDate = db.Column(db.DateTime, nullable=True)
+    ReceivedDate = db.Column(db.DateTime, nullable=True)
+    Count = db.Column(db.Integer)
+    Citations = db.Column(db.Integer)
+    Ranking = db.Column(db.Integer)
+    Versions = db.Column(db.Integer)
+    MetaKeywords = db.Column(db.String(1024))
+    JurnalID = db.Column(db.String(50))
+    AbstractID = db.Column(db.String(50))
+    PaperID = db.Column(db.String(50))
+    FKScore = db.Column(db.Float, nullable=True)
+    def __init__(**kwargs):
+        super(Paper, self).__init__(**kwargs)
+    def __repr__(self):
+        return "<Paper: (PaperID: %s)>" % self.PaperID
\ No newline at end of file

Models/PaperCategoryUsage.py

+from App import db
+
+class PaperCategoryUsage(db.Model):
+    __tablename__ = 'PaperCategoryUsage'
+    PaperKey = db.Column(db.Integer, db.ForeignKey("Paper.PaperKey"),primary_key=True)
+    LaymanCategoryKey = db.Column(db.Integer, db.ForeignKey("LaymanCategory.LaymanCategoryKey"),primary_key=True)
+    LanguageKey = db.Column(db.Integer, db.ForeignKey("Language.LanguageKey"),primary_key=True)
+    AccountKey = db.Column(db.Integer, primary_key=True)
+    SequenceID = db.Column(db.Integer)
+    def __init__(**kwargs):
+        super(PaperCategoryUsage, self).__init__(**kwargs)
+    def __repr__(self):
+        return "<PaperCategoryUsage: (PaperKey: %ld, LaymanCategoryKey: %ld, LanguageKey: %ld, AccountKey:%ld)>" % (self.AccountKey,self.LanguageKey,self.PaperKey,self.LaymanCategoryKey)
+

Models/__init__.py

+
+from .Layman import Layman
+from .Paper import Paper
+from .LaymanDictionary import LaymanDictionary
+from .Language import Language
+from .PaperCategoryUsage import PaperCategoryUsage
+from .LaymanCategory import LaymanCategory
+
+__all__ = [
+    "Layman",
+    "Paper",
+    "LaymanDictionary",
+    "Language",
+    "PaperCategoryUsage",
+    "LaymanCategory"
+    ]
\ No newline at end of file

lib/networkDriveConnector.py

+from smb.SMBConnection import SMBConnection 
+from smb.smb_structs import OperationFailure
+
+from socket import gethostname
+import os,platform
+
+
+class NetworkDriveConnector():
+    __current_directory='/'
+    def __init__(self,username,password,dest_name,dest_ip,share_name=""):
+        self.__conn = SMBConnection(username=username,password=password,my_name=gethostname(),remote_name=dest_name,use_ntlm_v2=True)
+        self.__share_name = share_name
+        assert self.__conn.connect(ip=dest_ip,port=139,timeout=2)
+        self.move_to('/')
+        
+    def move_to(self,absolute_path):
+        try: self.__conn.listPath(self.__share_name,absolute_path)
+        except OperationFailure: raise
+        else: self.__current_directory=absolute_path
+    def read_file(self,file_name):
+        fp = None
+        if platform.system() == "Linux":
+            self.filename = "/tmp/%s" % file_name
+        else:
+            self.filename = "temp/%s" % file_name
+        try: 
+            with open(self.filename,'wb') as fp:
+                file_path = os.path.join(self.__current_directory,file_name[0],file_name)
+                result = self.__conn.retrieveFile(self.__share_name,file_path,fp)
+
+        except OSError as ex:
+            if ex.errno != errno.EEXIST:
+                if os.path.isfile(self.filename):
+                    fp.close()
+                    os.remove(self.filename)
+                raise ex   
+        except OperationFailure as ex: 
+            fp.close()
+            if os.path.isfile(self.filename):
+                fp.close()
+                os.remove(self.filename)
+            raise
+        fp = open(self.filename,'rb')
+        return fp
+    def read_file_as_string(self,file_name,encoding='utf-8'):
+        fp = self.read_file(file_name)
+        content = b''.join(fp.readlines()).decode(encoding)
+        fp.close()
+        os.remove(self.filename)
+        return content
+
+    
+
+if __name__ == '__main__':    
+    # SMB_USERNAME="XinnoCommon"
+    # SMB_PASSWORD="1conTrol)("
+    # smb = SMBConnection(username=SMB_USERNAME,password=SMB_PASSWORD,my_name=gethostname(),remote_name="SATURN",use_ntlm_v2=True)
+    # assert smb.connect(ip='192.168.1.70',port=139,timeout=10)
+    # inst = NetworkDriveConnector(username=SMB_USERNAME,password=SMB_PASSWORD,dest_name="SATURN",dest_ip='192.168.1.70',share_name="Upload")
+    # inst.move_to('/Layman/LaymanDictionary')
+    # f_pointer = inst.read_file('qaaf.xml')
+    # print (b''.join(list(f_pointer.readlines())).decode("utf-8"))
+    # print (inst.read_file_as_string('qaaf.xml',encoding='utf-16'))
+    pass
\ No newline at end of file

lib/predictCall.py

+def predict():
+    print("hello")
\ No newline at end of file

lib/trainCall.py

+from App import db
+from Models import *
+
+def load_paper():
+
+
+def train():
+    #print(Paper.query.count())
+
+    load_paper()
+    print("hello")
\ No newline at end of file

main.py

+from lib import trainCall,predictCall
+import argparse
+
+def main():
+
+    # arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument('run_opt', type=int, default=1, help='An integer: 1 to train, 2 to test')
+    args = parser.parse_args()
+
+    if(args.run_opt == 2):
+        trainCall.train()
+    else:
+        predictCall.predict()
+
+
+if __name__ == '__main__':
+    main()