nas-lang 1.0.0__tar.gz

nas_lang-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: nas-lang
+Version: 1.0.0
+Summary: NAS Language - Java power with Python easy yarn printing, by Kelly
+Author: Edward Kelly
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-python
+Dynamic: summary

nas_lang-1.0.0/nas_lang/__init__.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+import sys, math, random
+variables = {}; functions = {}; BUILTINS = {}
+
+def get_val(raw):
+    if raw is None: return ""
+    raw = str(raw).strip()
+    if raw == "": return ""
+    try:
+        if "." in raw and raw.replace(".","",1).lstrip("-").isdigit(): return float(raw)
+        if raw.lstrip("-").isdigit(): return int(raw)
+    except: pass
+    if raw in variables: return variables[raw]
+    try:
+        expr = raw
+        for k,v in sorted(variables.items(), key=lambda x: -len(x[0])):
+            if isinstance(v, (int,float)): expr = expr.replace(k, str(v))
+        if any(op in expr for op in ["+","-","*","/","%"]): return eval(expr)
+    except: pass
+    return raw
+
+def builtin(name):
+    def wrap(fn):
+        BUILTINS[name]=fn; return fn
+    return wrap
+
+@builtin("abs")
+def b_abs(a): return abs(float(a))
+@builtin("max")
+def b_max(a,b): return max(float(a),float(b))
+@builtin("min")
+def b_min(a,b): return min(float(a),float(b))
+@builtin("pow")
+def b_pow(a,b): return math.pow(float(a),float(b))
+@builtin("sqrt")
+def b_sqrt(a): return math.sqrt(float(a))
+@builtin("ceil")
+def b_ceil(a): return math.ceil(float(a))
+@builtin("floor")
+def b_floor(a): return math.floor(float(a))
+@builtin("round")
+def b_round(a): return round(float(a))
+@builtin("random")
+def b_random(a=0,b=1): return random.uniform(float(a),float(b))
+@builtin("len")
+def b_len(a): return len(str(a))
+@builtin("upper")
+def b_upper(a): return str(a).upper()
+@builtin("lower")
+def b_lower(a): return str(a).lower()
+@builtin("trim")
+def b_trim(a): return str(a).strip()
+@builtin("contains")
+def b_contains(a,b): return str(b) in str(a)
+@builtin("starts")
+def b_starts(a,b): return str(a).startswith(str(b))
+@builtin("ends")
+def b_ends(a,b): return str(a).endswith(str(b))
+@builtin("replace")
+def b_replace(a,b,c): return str(a).replace(str(b),str(c))
+@builtin("slice")
+def b_slice(a,b,c=None):
+    s=str(a); start=int(float(b))
+    if c is None: return s[start:]
+    return s[start:int(float(c))]
+
+def eval_condition(cond):
+    cond = cond.strip()
+    # replace vars with python literal
+    for k,v in sorted(variables.items(), key=lambda x: -len(x[0])):
+        if isinstance(v, str):
+            cond = cond.replace(k, f'"{v}"')
+        else:
+            cond = cond.replace(k, str(v))
+    # now bare words like Edward that remain and are not true/false/and/or/numbers -> make them string
+    import re
+    def repl_word(m):
+        w=m.group(0)
+        if w in ["and","or","True","False","==","!=","<",">","<=",">="]: return w
+        if w.replace(".","",1).isdigit(): return w
+        if w.startswith('"') and w.endswith('"'): return w
+        # if already quoted inside, skip
+        return f'"{w}"'
+    # find bare words not in quotes
+    cond = re.sub(r'\b[A-Za-z_][A-Za-z0-9_]*\b', repl_word, cond)
+    cond = cond.replace('""','"')
+    cond = cond.replace('""""','"')
+    # fix double quoted
+    cond = cond.replace('""Edward""','"Edward"')
+    try:
+        return bool(eval(cond))
+    except Exception as e:
+        # print(f"cond debug: {cond} -> {e}")
+        return False
+
+def call_func(tokens):
+    name=tokens[0]; raw_args=tokens[1:]; args=[]
+    for a in raw_args:
+        a=a.replace(",","").strip()
+        if a=="": continue
+        args.append(get_val(a))
+    if name in BUILTINS:
+        try: return BUILTINS[name](*args)
+        except Exception as e: return f"Error {name}: {e}"
+    if name in functions:
+        f=functions[name]; old=variables.copy()
+        for p,v in zip(f["params"], args): variables[p]=v
+        run_block(f["body"])
+        ret=None
+        for l in f["body"]:
+            if l.strip().startswith("return "): ret=get_val(l.strip()[7:]); break
+        variables.clear(); variables.update(old)
+        return ret
+    return None
+
+def run_block(block):
+    i=0
+    while i < len(block):
+        line=block[i].strip(); i+=1
+        if not line or line.startswith("//") or line.startswith("#"): continue
+        if line.startswith("if "):
+            cond=line[3:].split(" be")[0].strip()
+            truth=eval_condition(cond)
+            inner=[]; else_inner=[]; in_else=False; depth=1
+            while i < len(block):
+                l=block[i].strip(); i+=1
+                if l.startswith("if "): depth+=1
+                if l=="end":
+                    depth-=1
+                    if depth==0: break
+                if l=="else" and depth==1:
+                    in_else=True; continue
+                if not in_else: inner.append(l)
+                else: else_inner.append(l)
+            if truth: run_block(inner)
+            else: run_block(else_inner)
+            continue
+        if line.startswith("for "):
+            header=line[4:].split(" be")[0].strip()
+            var_name=None; start=0; end=0
+            if " to " in header:
+                left,right=header.split(" to ")
+                left=left.strip()
+                if "=" in left:
+                    var_name,start=[s.strip() for s in left.split("=")]
+                end=right.strip()
+                start=int(float(get_val(start))); end=int(float(get_val(end)))
+            body=[]; depth=1
+            while i < len(block):
+                l=block[i].strip(); i+=1
+                if l.startswith("for "): depth+=1
+                if l=="end":
+                    depth-=1
+                    if depth==0: break
+                body.append(l)
+            for v in range(start, end+1):
+                variables[var_name]=v
+                run_block(body)
+            continue
+        if line.startswith("ask "):
+            rest=line[4:].strip()
+            if "=" in rest:
+                var,prompt=rest.split("=",1)
+                var=var.strip(); prompt=prompt.strip()
+                ans=input(prompt+" ")
+                try:
+                    if "." in ans: ans=float(ans)
+                    else: ans=int(ans)
+                except: pass
+                variables[var]=ans
+            continue
+        if line.startswith("yarn "):
+            content=line[5:].strip()
+            tok=content.split()
+            if tok and (tok[0] in functions or tok[0] in BUILTINS):
+                val=call_func(tok)
+                if val is not None: print(val)
+            else:
+                print(get_val(content))
+            continue
+        if line.startswith("return "):
+            return get_val(line[7:])
+        if "=" in line:
+            n,v=line.split("=",1)
+            v=v.strip(); parts=v.split()
+            if parts and (parts[0] in BUILTINS or parts[0] in functions):
+                variables[n.strip()]=call_func(parts)
+            else:
+                variables[n.strip()]=get_val(v)
+
+def run_file(path):
+    with open(path) as f:
+        lines=[l.rstrip("\n") for l in f]
+    i=0; cleaned=[]
+    while i < len(lines):
+        line=lines[i].strip(); i+=1
+        if line.startswith("func "):
+            header=line[5:].strip()
+            if " be" in header: header=header.split(" be")[0]
+            header=header.replace("(", " ").replace(")", " ").replace(",", " ")
+            parts=header.split()
+            fname=parts[0]; params=parts[1:]
+            body=[]
+            while i < len(lines):
+                l=lines[i].strip(); i+=1
+                if l=="end": break
+                body.append(l)
+            functions[fname]={"params":params,"body":body}
+        else:
+            cleaned.append(line)
+    run_block(cleaned)
+
+if len(sys.argv)<2:
+    print("Usage: nas file.yarn")
+else:
+    run_file(sys.argv[1])

nas_lang-1.0.0/nas_lang/__main__.py

@@ -0,0 +1,4 @@
+from.cli import run_file
+import sys
+if __name__ == "__main__":
+    run_file(sys.argv[1] if len(sys.argv)>1 else "")

nas_lang-1.0.0/nas_lang/cli.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+import sys, math, random
+variables = {}; functions = {}; BUILTINS = {}
+
+def get_val(raw):
+    if raw is None: return ""
+    raw = str(raw).strip()
+    if raw == "": return ""
+    try:
+        if "." in raw and raw.replace(".","",1).lstrip("-").isdigit(): return float(raw)
+        if raw.lstrip("-").isdigit(): return int(raw)
+    except: pass
+    if raw in variables: return variables[raw]
+    try:
+        expr = raw
+        for k,v in sorted(variables.items(), key=lambda x: -len(x[0])):
+            if isinstance(v, (int,float)): expr = expr.replace(k, str(v))
+        if any(op in expr for op in ["+","-","*","/","%"]): return eval(expr)
+    except: pass
+    return raw
+
+def builtin(name):
+    def wrap(fn):
+        BUILTINS[name]=fn; return fn
+    return wrap
+
+@builtin("abs")
+def b_abs(a): return abs(float(a))
+@builtin("max")
+def b_max(a,b): return max(float(a),float(b))
+@builtin("min")
+def b_min(a,b): return min(float(a),float(b))
+@builtin("pow")
+def b_pow(a,b): return math.pow(float(a),float(b))
+@builtin("sqrt")
+def b_sqrt(a): return math.sqrt(float(a))
+@builtin("ceil")
+def b_ceil(a): return math.ceil(float(a))
+@builtin("floor")
+def b_floor(a): return math.floor(float(a))
+@builtin("round")
+def b_round(a): return round(float(a))
+@builtin("random")
+def b_random(a=0,b=1): return random.uniform(float(a),float(b))
+@builtin("len")
+def b_len(a): return len(str(a))
+@builtin("upper")
+def b_upper(a): return str(a).upper()
+@builtin("lower")
+def b_lower(a): return str(a).lower()
+@builtin("trim")
+def b_trim(a): return str(a).strip()
+@builtin("contains")
+def b_contains(a,b): return str(b) in str(a)
+@builtin("starts")
+def b_starts(a,b): return str(a).startswith(str(b))
+@builtin("ends")
+def b_ends(a,b): return str(a).endswith(str(b))
+@builtin("replace")
+def b_replace(a,b,c): return str(a).replace(str(b),str(c))
+@builtin("slice")
+def b_slice(a,b,c=None):
+    s=str(a); start=int(float(b))
+    if c is None: return s[start:]
+    return s[start:int(float(c))]
+
+def eval_condition(cond):
+    cond = cond.strip()
+    # replace vars with python literal
+    for k,v in sorted(variables.items(), key=lambda x: -len(x[0])):
+        if isinstance(v, str):
+            cond = cond.replace(k, f'"{v}"')
+        else:
+            cond = cond.replace(k, str(v))
+    # now bare words like Edward that remain and are not true/false/and/or/numbers -> make them string
+    import re
+    def repl_word(m):
+        w=m.group(0)
+        if w in ["and","or","True","False","==","!=","<",">","<=",">="]: return w
+        if w.replace(".","",1).isdigit(): return w
+        if w.startswith('"') and w.endswith('"'): return w
+        # if already quoted inside, skip
+        return f'"{w}"'
+    # find bare words not in quotes
+    cond = re.sub(r'\b[A-Za-z_][A-Za-z0-9_]*\b', repl_word, cond)
+    cond = cond.replace('""','"')
+    cond = cond.replace('""""','"')
+    # fix double quoted
+    cond = cond.replace('""Edward""','"Edward"')
+    try:
+        return bool(eval(cond))
+    except Exception as e:
+        # print(f"cond debug: {cond} -> {e}")
+        return False
+
+def call_func(tokens):
+    name=tokens[0]; raw_args=tokens[1:]; args=[]
+    for a in raw_args:
+        a=a.replace(",","").strip()
+        if a=="": continue
+        args.append(get_val(a))
+    if name in BUILTINS:
+        try: return BUILTINS[name](*args)
+        except Exception as e: return f"Error {name}: {e}"
+    if name in functions:
+        f=functions[name]; old=variables.copy()
+        for p,v in zip(f["params"], args): variables[p]=v
+        run_block(f["body"])
+        ret=None
+        for l in f["body"]:
+            if l.strip().startswith("return "): ret=get_val(l.strip()[7:]); break
+        variables.clear(); variables.update(old)
+        return ret
+    return None
+
+def run_block(block):
+    i=0
+    while i < len(block):
+        line=block[i].strip(); i+=1
+        if not line or line.startswith("//") or line.startswith("#"): continue
+        if line.startswith("if "):
+            cond=line[3:].split(" be")[0].strip()
+            truth=eval_condition(cond)
+            inner=[]; else_inner=[]; in_else=False; depth=1
+            while i < len(block):
+                l=block[i].strip(); i+=1
+                if l.startswith("if "): depth+=1
+                if l=="end":
+                    depth-=1
+                    if depth==0: break
+                if l=="else" and depth==1:
+                    in_else=True; continue
+                if not in_else: inner.append(l)
+                else: else_inner.append(l)
+            if truth: run_block(inner)
+            else: run_block(else_inner)
+            continue
+        if line.startswith("for "):
+            header=line[4:].split(" be")[0].strip()
+            var_name=None; start=0; end=0
+            if " to " in header:
+                left,right=header.split(" to ")
+                left=left.strip()
+                if "=" in left:
+                    var_name,start=[s.strip() for s in left.split("=")]
+                end=right.strip()
+                start=int(float(get_val(start))); end=int(float(get_val(end)))
+            body=[]; depth=1
+            while i < len(block):
+                l=block[i].strip(); i+=1
+                if l.startswith("for "): depth+=1
+                if l=="end":
+                    depth-=1
+                    if depth==0: break
+                body.append(l)
+            for v in range(start, end+1):
+                variables[var_name]=v
+                run_block(body)
+            continue
+        if line.startswith("ask "):
+            rest=line[4:].strip()
+            if "=" in rest:
+                var,prompt=rest.split("=",1)
+                var=var.strip(); prompt=prompt.strip()
+                ans=input(prompt+" ")
+                try:
+                    if "." in ans: ans=float(ans)
+                    else: ans=int(ans)
+                except: pass
+                variables[var]=ans
+            continue
+        if line.startswith("yarn "):
+            content=line[5:].strip()
+            tok=content.split()
+            if tok and (tok[0] in functions or tok[0] in BUILTINS):
+                val=call_func(tok)
+                if val is not None: print(val)
+            else:
+                print(get_val(content))
+            continue
+        if line.startswith("return "):
+            return get_val(line[7:])
+        if "=" in line:
+            n,v=line.split("=",1)
+            v=v.strip(); parts=v.split()
+            if parts and (parts[0] in BUILTINS or parts[0] in functions):
+                variables[n.strip()]=call_func(parts)
+            else:
+                variables[n.strip()]=get_val(v)
+
+def run_file(path):
+    with open(path) as f:
+        lines=[l.rstrip("\n") for l in f]
+    i=0; cleaned=[]
+    while i < len(lines):
+        line=lines[i].strip(); i+=1
+        if line.startswith("func "):
+            header=line[5:].strip()
+            if " be" in header: header=header.split(" be")[0]
+            header=header.replace("(", " ").replace(")", " ").replace(",", " ")
+            parts=header.split()
+            fname=parts[0]; params=parts[1:]
+            body=[]
+            while i < len(lines):
+                l=lines[i].strip(); i+=1
+                if l=="end": break
+                body.append(l)
+            functions[fname]={"params":params,"body":body}
+        else:
+            cleaned.append(line)
+    run_block(cleaned)
+
+if len(sys.argv)<2:
+    print("Usage: nas file.yarn")
+else:
+    run_file(sys.argv[1])
+def main():
+    import sys
+    from nas_lang import run_file
+    run_file(sys.argv[1] if len(sys.argv)>1 else "")
+

nas_lang-1.0.0/nas_lang.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: nas-lang
+Version: 1.0.0
+Summary: NAS Language - Java power with Python easy yarn printing, by Kelly
+Author: Edward Kelly
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-python
+Dynamic: summary

nas_lang-1.0.0/nas_lang.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+setup.py
+nas_lang/__init__.py
+nas_lang/__main__.py
+nas_lang/cli.py
+nas_lang.egg-info/PKG-INFO
+nas_lang.egg-info/SOURCES.txt
+nas_lang.egg-info/dependency_links.txt
+nas_lang.egg-info/entry_points.txt
+nas_lang.egg-info/top_level.txt

nas_lang-1.0.0/nas_lang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nas_lang-1.0.0/nas_lang.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nas = nas_lang.cli:main

nas_lang-1.0.0/nas_lang.egg-info/top_level.txt

@@ -0,0 +1 @@
+nas_lang

nas_lang-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nas_lang-1.0.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="nas-lang",
+    version="1.0.0",
+    description="NAS Language - Java power with Python easy yarn printing, by Kelly",
+    author="Edward Kelly",
+    packages=find_packages(),
+    entry_points={
+        "console_scripts": [
+            "nas=nas_lang.cli:main",
+        ]
+    },
+    python_requires=">=3.8",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+    ],
+)