midas-civil 1.4.1__py3-none-any.whl

midas_civil/_loadcomb.py

@@ -0,0 +1,159 @@
+from ._mapi import MidasAPI
+# from ._model import *
+
+
+#28 Class to generate load combinations
+class LoadCombination:
+    data = []
+    valid = ["General", "Steel", "Concrete", "SRC", "Composite Steel Girder", "Seismic", "All"]
+    com_map = {
+            "General": "/db/LCOM-GEN",
+            "Steel": "/db/LCOM-STEEL",
+            "Concrete": "/db/LCOM-CONC",
+            "SRC": "/db/LCOM-SRC",
+            "Composite Steel Girder": "/db/LCOM-STLCOMP",
+            "Seismic": "/db/LCOM-SEISMIC"
+        }
+    def __init__(self, name, case, classification = "General", active = "ACTIVE", typ = "Add", id:int = None, desc = ""):
+        """Name, List of tuple of load cases & factors, classification, active, type. \n
+        Sample: LoadCombination('LCB1', [('Dead Load(CS)',1.5), ('Temperature(ST)',0.9)], 'General', 'Active', 'Add')"""
+        if id == None: id =0
+        if not isinstance(case, list):
+            print("case should be a list that contains tuple of load cases & factors.\nEg: [('Load1(ST)', 1.5), ('Load2(ST)',0.9)]")
+            return
+        for i in case:
+            if not isinstance(i, tuple):
+                print(f"{i} is not a tuple.  case should be a list that contains tuple of load cases & factors.\nEg: [('Load1(ST)', 1.5), ('Load2(ST)',0.9)]")
+                return
+            if not isinstance(i[0], str):
+                print(f"{i[0]} is not a string.  case should be a list that contains tuple of load cases & factors.\nEg: [('Load1(ST)', 1.5), ('Load2(ST)',0.9)]")
+                return
+            if i[0][-1] != ")":
+                print(f"Load case type is not mentioned for {i[0]}.  case should be a list that contains tuple of load cases & factors.\nEg: [('Load1(ST)', 1.5), ('Load2(ST)',0.9)]")
+                return
+            if not isinstance(i[1],(int, float)):
+                print(f"{i[1]} is not a number.  case should be a list that contains tuple of load cases & factors.\nEg: [('Load1(ST)', 1.5), ('Load2(ST)',0.9)]")
+                return
+
+        if classification not in LoadCombination.valid[:-1]:
+            print(f'"{classification}" is not a valid input.  It is changed to "General".')
+            classification = "General"
+            
+        if classification in ["General", "Seismic"]:
+            if active not in ["ACTIVE", "INACTIVE"]: active = "ACTIVE"
+        if classification in  ["Steel", "Concrete", "SRC", "Composite Steel Girder"]:
+            if active not in ["STRENGTH", "SERVICE", "INACTIVE"]: active = "STRENGTH"
+        
+        typ_map = {"Add": 0, "Envelope": 1, "ABS": 2, "SRSS": 3, 0:0, 1:1, 2:2, 3:3}
+        if typ not in list(typ_map.keys()): typ = "Add"
+        if classification not in ["General", "Seismic"] and typ_map.get(typ) == 2: typ = "Add"
+        
+        if id == 0 and len(LoadCombination.data) == 0: 
+            id = 1
+        elif id == 0 and len(LoadCombination.data) != 0:
+            id = max([i.ID for i in LoadCombination.data]) + 1
+        elif id != 0 and id in [i.ID for i in LoadCombination.data]:
+            if classification in [i.CLS for i in LoadCombination.data if i.ID == id]:
+                print(f"ID {id} is already defined.  Existing combination would be replaced.")
+                
+        
+        combo = []
+        valid_anl = ["ST", "CS", "MV", "SM", "RS", "TH", "CB", "CBC", "CBS", "CBR", "CBSC", "CBSM"] #Need to figure out for all combination types
+        for i in case:
+            a = i[0].rsplit('(', 1)[1].rstrip(')')
+            if a in valid_anl:
+                combo.append({
+                    "ANAL": a,
+                    "LCNAME":i[0].rsplit('(', 1)[0],
+                    "FACTOR": i[1]
+                })
+        self.NAME = name
+        self.CASE = combo
+        self.CLS = classification
+        self.ACT = active
+        self.TYPE = typ_map.get(typ)
+        self.ID = id
+        self.DESC = desc
+        LoadCombination.data.append(self)
+    
+    @classmethod
+    def json(cls, classification = "All"):
+        if len(LoadCombination.data) == 0:
+            print("No Load Combinations defined!  Define the load combination using the 'LoadCombination' class before making json file.")
+            return
+        if classification not in LoadCombination.valid:
+            print(f'"{classification}" is not a valid input.  It is changed to "General".')
+            classification = "General"
+        json = {k:{'Assign':{}} for k in LoadCombination.valid[:-1]}
+        for i in LoadCombination.data:
+            if i.CLS == classification or classification == "All":
+                json[i.CLS]['Assign'][i.ID] = {
+                    "NAME": i.NAME,
+                    "ACTIVE": i.ACT,
+                    "iTYPE": i.TYPE,
+                    "DESC": i.DESC,
+                    "vCOMB":i.CASE
+                }
+        json = {k:v for k,v in json.items() if v != {'Assign':{}}}
+        return json
+    
+    @classmethod
+    def get(cls, classification = "All"):
+        if classification not in LoadCombination.valid:
+            print(f'"{classification}" is not a valid input.  It is changed to "General".')
+            classification = "General"
+        combos = {k:{} for k in LoadCombination.valid[:-1]}
+        for i in LoadCombination.valid[:-1]:
+            if classification == i or classification == "All":
+                combos[i] = MidasAPI("GET",LoadCombination.com_map.get(i))
+        json = {k:v for k,v in combos.items() if v != {'message':''}}
+        return json
+    
+    @classmethod
+    def create(cls, classification = "All"):
+        if len(LoadCombination.data) == 0:
+            # print("No Load Combinations defined!  Define the load combination using the 'LoadCombination' class before creating these in the model.")
+            return
+        if classification not in LoadCombination.valid:
+            print(f'"{classification}" is not a valid input.  It is changed to "General".')
+            classification = "General"
+        json = LoadCombination.json(classification)
+        for i in LoadCombination.valid[:-1]:
+            if classification == i or classification == "All":
+                if i in list(json.keys()):
+                    a = list(json[i]['Assign'].keys())
+                    b=""
+                    for j in range(len(a)):
+                        b += str(a[j]) + ","
+                    if b != "": b = "/" + b[:-1]
+                    MidasAPI("DELETE", LoadCombination.com_map.get(i) + b)     #Delete existing combination if any
+                    MidasAPI("PUT", LoadCombination.com_map.get(i), json[i])   #Create new combination
+    
+    @classmethod
+    def sync(cls, classification = "All"):
+        json = LoadCombination.get(classification)
+        if json != {}:
+            keys = list(json.keys())
+            for i in keys:
+                for k,v in json[i][LoadCombination.com_map.get(i)[4:]].items():
+                    c = []
+                    for j in range(len(v['vCOMB'])):
+                        c.append((v['vCOMB'][j]['LCNAME'] + "("+ v['vCOMB'][j]['ANAL'] + ")", v['vCOMB'][j]['FACTOR']))
+                    LoadCombination(v['NAME'], c, i, v['ACTIVE'], v['iTYPE'], int(k), v['DESC'])
+    
+    @classmethod
+    def delete(cls, classification = "All", ids = []):
+        json = LoadCombination.json(classification)
+        a = ""
+        for i in range(len(ids)):
+            a += str(ids[i]) + ","
+        a = "/" + a[:-1]
+        if json == {}: 
+            print("No load combinations are defined to delete.")
+        for i in list(json.keys()):
+            MidasAPI("DELETE",LoadCombination.com_map.get(i) + a)
+
+    @classmethod
+    def clear(cls):
+        cls.data = []
+#---------------------------------------------------------------------------------------------------------------

midas_civil/_mapi.py

@@ -0,0 +1,249 @@
+import requests
+import sys
+from colorama import Fore, Style
+try:import winreg
+except: pass
+import time
+from tqdm import tqdm
+# import polars as pl
+
+
+
+def Midas_help():
+    """MIDAS Documnetation : https://midas-rnd.github.io/midasapi-python """
+    print('\n╭────────────────────────────────────────────────────────────────────────────────────╮')
+    print("│         HELP MANUAL   :     https://midas-rnd.github.io/midasapi-python/           │")
+    print('╰────────────────────────────────────────────────────────────────────────────────────╯\n')
+
+
+
+class NX:
+    version_check = True    # CHANGE IT TO FALSE TO SKIP VERSION CHECK OF LIBRARY
+    user_print = True
+    debug_request = False
+    debug_requestJSON = False
+    debug_response = False
+    onlyNode = False
+    visualiser = False
+
+    def saveJSON(jsonData,fileLocation = "jsData.json"):
+        import json
+        with open(fileLocation, "w", encoding="utf-8") as f:
+            json.dump(jsonData, f, indent=4, ensure_ascii=False)
+    
+
+class MAPI_COUNTRY:
+    
+    country = "US"
+
+    def __init__(self,country:str="US"):
+        ''' Define Civil NX country to automatically set Base URL and MAPI Key from registry.
+        ```
+        MAPI_COUNTRY('US') # For english version
+        MAPI_COUNTRY('KR') # For Korean version
+        MAPI_COUNTRY('CH') # For Chinese version
+        ```
+        '''
+        if country.lower() in ['us','ch','kr','jp']:
+            MAPI_COUNTRY.country = country.upper()
+        else:
+            MAPI_COUNTRY.country = 'US'
+        
+        MAPI_BASEURL.setURLfromRegistry()
+        MAPI_KEY.get_key()  # Intial Key from registry
+
+
+class MAPI_BASEURL:
+    baseURL = "https://moa-engineers.midasit.com:443/civil"
+    server_loc = "Global"
+    
+    def __init__(self, baseURL:str = "https://moa-engineers.midasit.com:443/civil"):
+        ''' Define the Base URL for API connection.
+        ```
+        MAPI_BASEURL('https://moa-engineers.midasit.com:443/civil')
+        ```
+        '''
+        MAPI_BASEURL.baseURL = baseURL
+        
+    @classmethod
+    def get_url(cls):
+        return MAPI_BASEURL.baseURL
+    
+    @classmethod
+    def setURLfromRegistry(cls):
+        try:
+            key_path = f"Software\\MIDAS\\CVLwNX_{MAPI_COUNTRY.country}\\CONNECTION"  
+            registry_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_READ)
+            url_reg = winreg.QueryValueEx(registry_key, "URI")
+            url_reg_key = url_reg[0]
+
+            port_reg = winreg.QueryValueEx(registry_key, "PORT")
+            port_reg_key = port_reg[0]
+
+            url_comb = f'https://{url_reg_key}:{port_reg_key}/civil'
+
+            tqdm.write(f' 🌐   BASE URL is taken from Registry entry.  >>  {url_comb}')
+            MAPI_BASEURL(url_comb)
+        except:
+            tqdm.write(" 🌐   BASE URL is not defined. Click on Apps > API Settings to copy the BASE URL Key.\nDefine it using MAPI_BASEURL('https://moa-engineers.midasit.com:443/civil')")
+            sys.exit(0)
+
+    @staticmethod
+    def autoURL():
+        base_urls = [
+            "https://moa-engineers-in.midasit.com:443/civil",
+            "https://moa-engineers-kr.midasit.com:443/civil",
+            "https://moa-engineers-gb.midasit.com:443/civil",
+            "https://moa-engineers-us.midasit.com:443/civil",
+            "https://moa-engineers.midasit.cn:443/civil"
+            ]
+        serv_locations = ["INDIA","KOREA","EUROPE","USA","CHINA"]
+        mapi_key = MAPI_KEY.get_key()
+        chk = 0
+        for i,base_url in enumerate(base_urls):
+            url = base_url + "/config/ver"
+            headers = {
+                "Content-Type": "application/json",
+                "MAPI-Key": mapi_key
+            }
+            response = requests.get(url=url, headers=headers)
+            if response.status_code == 200:
+                MAPI_BASEURL(base_url)
+                MAPI_BASEURL.server_loc = serv_locations[i]
+                chk=1
+                break
+        if chk==0:
+            tqdm.write(f" 🌐   Kindly manually enter the BASE URL. \nRefer to https://moa.midasit.com/services to find the correct URL.")
+            sys.exit(0)
+            
+class MAPI_KEY:
+    """MAPI key from Civil NX.\n\nEg: MAPI_Key("eadsfjaks568wqehhf.ajkgj345qfhh")"""
+    data = ""
+    count = 1
+    
+    def __init__(self, mapi_key:str):
+        MAPI_KEY.data = mapi_key
+        
+    @classmethod
+    def get_key(cls):
+        if MAPI_KEY.data == "":
+            try:
+                key_path = f"Software\\MIDAS\\CVLwNX_{MAPI_COUNTRY.country}\\CONNECTION"  
+                registry_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_READ)
+                value = winreg.QueryValueEx(registry_key, "Key")
+                my_key = value[0]
+                MAPI_KEY(my_key)
+                tqdm.write(f' 🔑   MAPI-KEY is taken from Registry entry.  >>  {my_key[:35]}...')
+            except:
+                tqdm.write(f"🔑   MAPI KEY is not defined. Click on Apps > API Settings to copy the MAPI Key.\n Define it using MAPI_KEY('xxxx')")
+                sys.exit(0)
+        else:
+            my_key = MAPI_KEY.data
+        
+        return my_key
+#---------------------------------------------------------------------------------------------------------------
+
+#2 midas API link code:
+def MidasAPI(method:str, command:str, body:dict={})->dict:
+    """Sends HTTP Request to MIDAS Civil NX
+            Parameters:
+                Method: "PUT" , "POST" , "GET" or "DELETE"
+                Command: eg. "/db/NODE"
+                Body: {{"Assign":{{1{{'X':0, 'Y':0, 'Z':0}}}}}}            
+            Examples:
+                ```python
+                # Create a node
+                MidasAPI("PUT","/db/NODE",{{"Assign":{{"1":{{'X':0, 'Y':0, 'Z':0}}}}}})"""
+    
+    base_url = MAPI_BASEURL.baseURL
+    mapi_key = MAPI_KEY.get_key()
+
+    url = base_url + command
+    headers = {
+        "Content-Type": "application/json",
+        "MAPI-Key": mapi_key
+    }
+
+    if MAPI_KEY.count == 1:
+        MAPI_KEY.count =0
+        if NX.user_print:
+            _checkUSER()
+
+
+
+
+    start_time = time.perf_counter()
+
+
+    if method == "POST":
+        response = requests.post(url=url, headers=headers, json=body)
+    elif method == "PUT":
+        response = requests.put(url=url, headers=headers, json=body)
+    elif method == "GET":
+        response = requests.get(url=url, headers=headers)
+    elif method == "DELETE":
+        response = requests.delete(url=url, headers=headers)
+
+    end_time = time.perf_counter()
+    elapsed_time = end_time - start_time
+
+    if NX.debug_request:
+        tqdm.write(Fore.RED+f">>   METHOD : {method} |  URL : {command} | STATUS :  {response.status_code} | TIME : {elapsed_time:.4f} sec "+Style.RESET_ALL)
+    if NX.debug_requestJSON:
+        tqdm.write(Fore.CYAN+">>  "+str(body)+Style.RESET_ALL)
+    if NX.debug_response:
+        tqdm.write(Fore.GREEN+"<<  "+str(response.json())+Style.RESET_ALL)
+
+    if MAPI_KEY.count == 0:
+        MAPI_KEY.count = -1
+        if response.status_code == 404:
+            print(Fore.RED +'\n╭─ 💀   ─────────────────────────────────────────────────────────────────────────────╮')
+            print(f"│  Civil NX model is not connected.  Click on 'Apps > Connect' in Civil NX.          │")
+            print(f"│  Make sure the MAPI Key in python code is matching with the MAPI key in Civil NX.  │")
+            print('╰────────────────────────────────────────────────────────────────────────────────────╯\n'+Style.RESET_ALL)
+            sys.exit(0)
+    
+
+
+    return response.json()
+
+
+#--------------------------------------------------------------------
+
+def _getUNIT():
+    return MidasAPI('GET','/db/UNIT',{})['UNIT']['1']
+
+def _setUNIT(unitJS):
+    js = {
+        "Assign" : {
+            "1" : unitJS
+        }
+    }
+    MidasAPI('PUT','/db/UNIT',js)
+
+
+def _checkUSER():
+    try:
+        resp =  MidasAPI('GET','/config/ver',{})['VER']
+
+        # print(f"{' '*15}Connected to {resp['NAME']}")
+        # print(f"{' '*15}USER : {resp['USER']}          COMPANY : {resp['COMPANY']}")
+
+        ln1 = f"Connected to {resp['NAME']}            SERVER : {MAPI_BASEURL.server_loc}"
+        ln2 = f"USER : {resp['USER']}          COMPANY : {resp['COMPANY']}"
+
+        lg_ln1 = 66-len(ln1)
+        lg_ln2 = 70-len(ln2)
+
+        line1 = f"│{' '*12} {ln1} {' '*lg_ln1} 🟢 │"
+        line2 = f"│{' '*12} {ln2} {' '*lg_ln2}│"
+        tqdm.write(Fore.GREEN+'\n╭─ 🔔  ──────────────────────────────────────────────────────────────────────────────╮')
+        tqdm.write(line1)
+        tqdm.write(line2)
+        tqdm.write('╰────────────────────────────────────────────────────────────────────────────────────╯\n'+Style.RESET_ALL)
+
+
+        # print('─'*86)
+
+    except:
+        pass