obsidian-lang 0.0.1__tar.gz

obsidian_lang-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Obsidian Language Contributors
+
+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.

obsidian_lang-0.0.1/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: obsidian-lang
+Version: 0.0.1
+Summary: Obsidian is a compiled programming language that combines memory safety, zero-cost abstractions, and minimalist syntax. Built for developers who want the speed of Rust without the boilerplate.
+Author: Obsidian Language Team
+License: MIT
+Project-URL: Homepage, https://github.com/example/obsidian-lang
+Project-URL: Repository, https://github.com/example/obsidian-lang
+Project-URL: Bug Tracker, https://github.com/example/obsidian-lang/issues
+Keywords: programming-language,compiler,transpiler,rust-like,toy-language
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Obsidian Language v0.0.1
+
+**Obsidian** is a compiled programming language that combines memory safety, zero-cost abstractions, and minimalist syntax. Built for developers who want the speed of Rust without the boilerplate.
+
+This is a toy implementation (v0.0.1) written in Python. It features a lexer, parser, AST, and a transpiler to Python (which simulates "compilation" by generating and executing equivalent Python code). Published on PyPI as `obsidian-lang`.
+
+## Features (v0.0.1)
+- Minimalist syntax inspired by Rust
+- Variables with `let`
+- Functions with `fn`
+- Basic expressions + comparison operators (< > <= >= == !=)
+- Control flow with `if` / `else`
+- Function calls (including built-in `println`)
+
+## Installation
+```bash
+pip install obsidian-lang
+```
+
+## Usage
+```bash
+# After pip install obsidian-lang
+obsidian examples/hello.obs --show-code
+
+# Or from source (development)
+PYTHONPATH=. python -m obsidian.main examples/hello.obs --show-code
+```
+
+## Example (hello.obs)
+```
+fn main() {
+    let x = 5;
+    let y = x + 3;
+    println(y);
+    println("Hello from Obsidian!");
+}
+```

obsidian_lang-0.0.1/README.md

@@ -0,0 +1,37 @@
+# Obsidian Language v0.0.1
+
+**Obsidian** is a compiled programming language that combines memory safety, zero-cost abstractions, and minimalist syntax. Built for developers who want the speed of Rust without the boilerplate.
+
+This is a toy implementation (v0.0.1) written in Python. It features a lexer, parser, AST, and a transpiler to Python (which simulates "compilation" by generating and executing equivalent Python code). Published on PyPI as `obsidian-lang`.
+
+## Features (v0.0.1)
+- Minimalist syntax inspired by Rust
+- Variables with `let`
+- Functions with `fn`
+- Basic expressions + comparison operators (< > <= >= == !=)
+- Control flow with `if` / `else`
+- Function calls (including built-in `println`)
+
+## Installation
+```bash
+pip install obsidian-lang
+```
+
+## Usage
+```bash
+# After pip install obsidian-lang
+obsidian examples/hello.obs --show-code
+
+# Or from source (development)
+PYTHONPATH=. python -m obsidian.main examples/hello.obs --show-code
+```
+
+## Example (hello.obs)
+```
+fn main() {
+    let x = 5;
+    let y = x + 3;
+    println(y);
+    println("Hello from Obsidian!");
+}
+```

obsidian_lang-0.0.1/obsidian/__init__.py

@@ -0,0 +1,7 @@
+"""
+Obsidian Programming Language
+v0.0.1a - A toy implementation in Python
+"""
+
+__version__ = "0.0.1a"
+__description__ = "Obsidian is a compiled programming language that combines memory safety, zero-cost abstractions, and minimalist syntax. Built for developers who want to speed of Rust without the boilerplate."

obsidian_lang-0.0.1/obsidian/ast.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+
+class ASTNode: pass
+
+@dataclass
+class Program(ASTNode):
+    functions: List['Function'] = field(default_factory=list)
+
+@dataclass
+class Function(ASTNode):
+    name: str
+    params: List[str]
+    body: List['Statement']
+
+@dataclass
+class Statement(ASTNode): pass
+
+@dataclass
+class LetStatement(Statement):
+    name: str
+    value: 'Expression'
+
+@dataclass
+class ReturnStatement(Statement):
+    value: Optional['Expression'] = None
+
+@dataclass
+class IfStatement(Statement):
+    condition: 'Expression'
+    then_block: List[Statement]
+    else_block: Optional[List[Statement]] = None
+
+@dataclass
+class ExpressionStatement(Statement):
+    expression: 'Expression'
+
+@dataclass
+class Expression(ASTNode): pass
+
+@dataclass
+class Literal(Expression):
+    value: Union[int, float, str]
+    typ: str
+
+@dataclass
+class Identifier(Expression):
+    name: str
+
+@dataclass
+class BinaryOp(Expression):
+    left: Expression
+    op: str
+    right: Expression
+
+@dataclass
+class Call(Expression):
+    callee: str
+    args: List[Expression]

obsidian_lang-0.0.1/obsidian/lexer.py

@@ -0,0 +1,90 @@
+from enum import Enum, auto
+from dataclasses import dataclass
+from typing import List
+
+class TokenType(Enum):
+    FN = auto(); LET = auto(); RETURN = auto(); IF = auto(); ELSE = auto()
+    NUMBER = auto(); STRING = auto(); IDENTIFIER = auto()
+    LPAREN = auto(); RPAREN = auto(); LBRACE = auto(); RBRACE = auto()
+    COMMA = auto(); SEMICOLON = auto(); COLON = auto(); ASSIGN = auto()
+    PLUS = auto(); MINUS = auto(); STAR = auto(); SLASH = auto()
+    LT = auto(); GT = auto(); LTE = auto(); GTE = auto(); EQ = auto(); NEQ = auto()
+    EOF = auto()
+
+@dataclass
+class Token:
+    type: TokenType
+    value: str
+    line: int
+    column: int
+
+class Lexer:
+    def __init__(self, source: str):
+        self.source = source
+        self.tokens: List[Token] = []
+        self.pos = 0
+        self.line = 1
+        self.column = 1
+        self.keywords = {'fn':TokenType.FN,'let':TokenType.LET,'return':TokenType.RETURN,'if':TokenType.IF,'else':TokenType.ELSE}
+
+    def _peek(self): return self.source[self.pos] if self.pos < len(self.source) else '\0'
+    def _advance(self):
+        ch = self._peek(); self.pos += 1
+        if ch == '\n': self.line += 1; self.column = 1
+        else: self.column += 1
+        return ch
+    def _skip_ws(self):
+        while self._peek() in ' \t\r\n': self._advance()
+
+    def tokenize(self):
+        self.tokens = []
+        while self.pos < len(self.source):
+            self._skip_ws()
+            if self.pos >= len(self.source): break
+            sl, sc = self.line, self.column
+            ch = self._advance()
+            if ch.isdigit():
+                num = ch
+                while self._peek().isdigit() or self._peek() == '.': num += self._advance()
+                self.tokens.append(Token(TokenType.NUMBER, num, sl, sc))
+            elif ch.isalpha() or ch == '_':
+                ident = ch
+                while self._peek().isalnum() or self._peek() == '_': ident += self._advance()
+                tt = self.keywords.get(ident, TokenType.IDENTIFIER)
+                self.tokens.append(Token(tt, ident, sl, sc))
+            elif ch == '"':
+                s = ''
+                while self._peek() != '"' and self._peek() != '\0':
+                    if self._peek() == '\\':
+                        self._advance()
+                        s += {'n':'\n','t':'\t'}.get(self._peek(), self._peek()); self._advance()
+                    else: s += self._advance()
+                if self._peek() == '"': self._advance()
+                self.tokens.append(Token(TokenType.STRING, s, sl, sc))
+            elif ch=='(': self.tokens.append(Token(TokenType.LPAREN,'(',sl,sc))
+            elif ch==')': self.tokens.append(Token(TokenType.RPAREN,')',sl,sc))
+            elif ch=='{': self.tokens.append(Token(TokenType.LBRACE,'{',sl,sc))
+            elif ch=='}': self.tokens.append(Token(TokenType.RBRACE,'}',sl,sc))
+            elif ch==',': self.tokens.append(Token(TokenType.COMMA,',',sl,sc))
+            elif ch==';': self.tokens.append(Token(TokenType.SEMICOLON,';',sl,sc))
+            elif ch==':': self.tokens.append(Token(TokenType.COLON,':',sl,sc))
+            elif ch=='+': self.tokens.append(Token(TokenType.PLUS,'+',sl,sc))
+            elif ch=='-': self.tokens.append(Token(TokenType.MINUS,'-',sl,sc))
+            elif ch=='*': self.tokens.append(Token(TokenType.STAR,'*',sl,sc))
+            elif ch=='/': self.tokens.append(Token(TokenType.SLASH,'/',sl,sc))
+            elif ch=='<':
+                if self._peek()=='=': self._advance(); self.tokens.append(Token(TokenType.LTE,'<=',sl,sc))
+                else: self.tokens.append(Token(TokenType.LT,'<',sl,sc))
+            elif ch=='>':
+                if self._peek()=='=': self._advance(); self.tokens.append(Token(TokenType.GTE,'>=',sl,sc))
+                else: self.tokens.append(Token(TokenType.GT,'>',sl,sc))
+            elif ch=='=':
+                if self._peek()=='=': self._advance(); self.tokens.append(Token(TokenType.EQ,'==',sl,sc))
+                else: self.tokens.append(Token(TokenType.ASSIGN,'=',sl,sc))
+            elif ch=='!':
+                if self._peek()=='=': self._advance(); self.tokens.append(Token(TokenType.NEQ,'!=',sl,sc))
+                else: raise SyntaxError("!")
+            else:
+                raise SyntaxError(f"Unexpected '{ch}' at {sl}:{sc}")
+        self.tokens.append(Token(TokenType.EOF, '', self.line, self.column))
+        return self.tokens

obsidian_lang-0.0.1/obsidian/main.py

@@ -0,0 +1,66 @@
+import sys
+import argparse
+from pathlib import Path
+from .lexer import Lexer
+from .parser import Parser
+from .transpiler import Transpiler
+from . import __version__, __description__
+
+def run_obsidian_file(filepath: str, execute: bool = True, show_code: bool = False):
+    path = Path(filepath)
+    if not path.exists():
+        print(f"Error: File not found: {filepath}")
+        sys.exit(1)
+    source = path.read_text(encoding="utf-8")
+    print(f"Obsidian v{__version__} - Processing {filepath}")
+    print("Parsing source...")
+    lexer = Lexer(source)
+    try:
+        tokens = lexer.tokenize()
+    except Exception as e:
+        print(f"Lexing error: {e}")
+        sys.exit(1)
+    parser = Parser(tokens)
+    try:
+        ast = parser.parse()
+    except Exception as e:
+        print(f"Parsing error: {e}")
+        sys.exit(1)
+    print(f"Successfully parsed {len(ast.functions)} function(s)")
+    transpiler = Transpiler()
+    try:
+        python_code = transpiler.transpile(ast)
+    except Exception as e:
+        print(f"Transpilation error: {e}")
+        sys.exit(1)
+    if show_code:
+        print("\n--- Generated Python Code ---")
+        print(python_code)
+        print("--- End of generated code ---\n")
+    if execute:
+        print("Executing (transpiled) program...\n")
+        try:
+            namespace = {"__name__": "__main__"}
+            exec(python_code, namespace)
+        except Exception as e:
+            print(f"Runtime error: {e}")
+            sys.exit(1)
+        print("\nProgram finished successfully.")
+
+def main():
+    parser = argparse.ArgumentParser(description=__description__, prog="obsidian")
+    parser.add_argument("file", nargs="?", help="Obsidian source file (.obs)")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--show-code", action="store_true", help="Print the generated Python code")
+    parser.add_argument("--no-exec", action="store_true", help="Do not execute the program, only transpile")
+    args = parser.parse_args()
+    if not args.file:
+        print("Obsidian Language v0.0.1a")
+        print(__description__)
+        print("\nUsage: python -m obsidian.main <file.obs> [--show-code] [--no-exec]")
+        print("Example: python -m obsidian.main examples/hello.obs")
+        sys.exit(0)
+    run_obsidian_file(args.file, execute=not args.no_exec, show_code=args.show_code)
+
+if __name__ == "__main__":
+    main()

obsidian_lang-0.0.1/obsidian/parser.py

@@ -0,0 +1,127 @@
+from typing import List, Optional
+from .lexer import Token, TokenType
+from .ast import *
+
+class Parser:
+    def __init__(self, tokens: List[Token]):
+        self.tokens = tokens
+        self.pos = 0
+
+    def _cur(self): return self.tokens[self.pos]
+    def _adv(self):
+        t = self._cur()
+        if self.pos < len(self.tokens)-1: self.pos += 1
+        return t
+    def _eat(self, tt: TokenType):
+        t = self._cur()
+        if t.type != tt: raise SyntaxError(f"Expected {tt.name} got {t.type.name}")
+        return self._adv()
+
+    def parse(self) -> Program:
+        p = Program()
+        while self._cur().type != TokenType.EOF:
+            if self._cur().type == TokenType.FN: p.functions.append(self._fn())
+            else: raise SyntaxError("Only fn at top level")
+        return p
+
+    def _fn(self):
+        self._eat(TokenType.FN)
+        name = self._eat(TokenType.IDENTIFIER).value
+        self._eat(TokenType.LPAREN)
+        params = []
+        if self._cur().type != TokenType.RPAREN:
+            while True:
+                params.append(self._eat(TokenType.IDENTIFIER).value)
+                if self._cur().type == TokenType.COMMA: self._adv()
+                else: break
+        self._eat(TokenType.RPAREN)
+        self._eat(TokenType.LBRACE)
+        body = []
+        while self._cur().type not in (TokenType.RBRACE, TokenType.EOF):
+            body.append(self._stmt())
+        self._eat(TokenType.RBRACE)
+        return Function(name, params, body)
+
+    def _stmt(self):
+        t = self._cur()
+        if t.type == TokenType.LET: return self._let()
+        if t.type == TokenType.RETURN: return self._ret()
+        if t.type == TokenType.IF: return self._if()
+        e = self._expr()
+        if self._cur().type == TokenType.SEMICOLON: self._adv()
+        return ExpressionStatement(e)
+
+    def _let(self):
+        self._eat(TokenType.LET)
+        name = self._eat(TokenType.IDENTIFIER).value
+        self._eat(TokenType.ASSIGN)
+        val = self._expr()
+        self._eat(TokenType.SEMICOLON)
+        return LetStatement(name, val)
+
+    def _ret(self):
+        self._eat(TokenType.RETURN)
+        val = self._expr() if self._cur().type != TokenType.SEMICOLON else None
+        self._eat(TokenType.SEMICOLON)
+        return ReturnStatement(val)
+
+    def _if(self):
+        self._eat(TokenType.IF)
+        cond = self._expr()
+        self._eat(TokenType.LBRACE)
+        thenb = []
+        while self._cur().type not in (TokenType.RBRACE, TokenType.EOF): thenb.append(self._stmt())
+        self._eat(TokenType.RBRACE)
+        elseb = None
+        if self._cur().type == TokenType.ELSE:
+            self._adv(); self._eat(TokenType.LBRACE)
+            elseb = []
+            while self._cur().type not in (TokenType.RBRACE, TokenType.EOF): elseb.append(self._stmt())
+            self._eat(TokenType.RBRACE)
+        return IfStatement(cond, thenb, elseb)
+
+    def _expr(self): return self._bin(0)
+
+    def _bin(self, minp):
+        left = self._prim()
+        while True:
+            t = self._cur()
+            prec = 0; op = None
+            if t.type == TokenType.STAR: prec,op = 3,'*'
+            elif t.type == TokenType.SLASH: prec,op=3,'/'
+            elif t.type == TokenType.PLUS: prec,op=2,'+'
+            elif t.type == TokenType.MINUS: prec,op=2,'-'
+            elif t.type == TokenType.LT: prec,op=1,'<'
+            elif t.type == TokenType.GT: prec,op=1,'>'
+            elif t.type == TokenType.LTE: prec,op=1,'<='
+            elif t.type == TokenType.GTE: prec,op=1,'>='
+            elif t.type == TokenType.EQ: prec,op=1,'=='
+            elif t.type == TokenType.NEQ: prec,op=1,'!='
+            else: break
+            if prec < minp: break
+            self._adv()
+            right = self._bin(prec+1)
+            left = BinaryOp(left, op, right)
+        return left
+
+    def _prim(self):
+        t = self._adv()
+        if t.type == TokenType.NUMBER:
+            v = int(t.value) if '.' not in t.value else float(t.value)
+            return Literal(v, 'int' if '.' not in t.value else 'float')
+        if t.type == TokenType.STRING: return Literal(t.value, 'string')
+        if t.type == TokenType.IDENTIFIER:
+            if self._cur().type == TokenType.LPAREN:
+                self._adv()
+                args = []
+                if self._cur().type != TokenType.RPAREN:
+                    while True:
+                        args.append(self._expr())
+                        if self._cur().type == TokenType.COMMA: self._adv()
+                        else: break
+                self._eat(TokenType.RPAREN)
+                return Call(t.value, args)
+            return Identifier(t.value)
+        if t.type == TokenType.LPAREN:
+            e = self._expr(); self._eat(TokenType.RPAREN); return e
+        raise SyntaxError(f"bad primary {t.type.name}")

obsidian_lang-0.0.1/obsidian/transpiler.py

@@ -0,0 +1,64 @@
+from typing import List
+from .ast import *
+
+class Transpiler:
+    def __init__(self):
+        self.indent = 0
+        self.out: List[str] = []
+    def emit(self, s): self.out.append("    " * self.indent + s)
+
+    def transpile(self, prog: Program) -> str:
+        self.out = []
+        self.emit("# Generated by Obsidian v0.0.1")
+        self.emit("def println(*args): print(*args)")
+        self.emit("")
+        for f in prog.functions:
+            self._fn(f)
+        if any(f.name == "main" for f in prog.functions):
+            self.emit("")
+            self.emit("if __name__ == '__main__':")
+            self.indent += 1
+            self.emit("main()")
+            self.indent -= 1
+        return "\n".join(self.out)
+
+    def _fn(self, f: Function):
+        ps = ", ".join(f.params)
+        self.emit(f"def {f.name}({ps}):")
+        self.indent += 1
+        for s in f.body: self._stmt(s)
+        if not f.body: self.emit("pass")
+        self.indent -= 1
+        self.emit("")
+
+    def _stmt(self, s: Statement):
+        if isinstance(s, LetStatement):
+            self.emit(f"{s.name} = {self._expr(s.value)}")
+        elif isinstance(s, ReturnStatement):
+            self.emit("return " + (self._expr(s.value) if s.value is not None else ""))
+        elif isinstance(s, IfStatement):
+            self.emit(f"if {self._expr(s.condition)}:")
+            self.indent += 1
+            for ss in s.then_block: self._stmt(ss)
+            self.indent -= 1
+            if s.else_block:
+                self.emit("else:")
+                self.indent += 1
+                for ss in s.else_block: self._stmt(ss)
+                self.indent -= 1
+        elif isinstance(s, ExpressionStatement):
+            self.emit(self._expr(s.expression))
+        else:
+            self.emit("# unknown")
+
+    def _expr(self, e: Expression) -> str:
+        if isinstance(e, Literal):
+            return repr(e.value) if e.typ == "string" else str(e.value)
+        if isinstance(e, Identifier):
+            return e.name
+        if isinstance(e, BinaryOp):
+            return f"({self._expr(e.left)} {e.op} {self._expr(e.right)})"
+        if isinstance(e, Call):
+            args = ", ".join(self._expr(a) for a in e.args)
+            return f"{e.callee}({args})"
+        raise RuntimeError(f"Transpiler: unknown expression {type(e)}")

obsidian_lang-0.0.1/obsidian_lang.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: obsidian-lang
+Version: 0.0.1
+Summary: Obsidian is a compiled programming language that combines memory safety, zero-cost abstractions, and minimalist syntax. Built for developers who want the speed of Rust without the boilerplate.
+Author: Obsidian Language Team
+License: MIT
+Project-URL: Homepage, https://github.com/example/obsidian-lang
+Project-URL: Repository, https://github.com/example/obsidian-lang
+Project-URL: Bug Tracker, https://github.com/example/obsidian-lang/issues
+Keywords: programming-language,compiler,transpiler,rust-like,toy-language
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Obsidian Language v0.0.1
+
+**Obsidian** is a compiled programming language that combines memory safety, zero-cost abstractions, and minimalist syntax. Built for developers who want the speed of Rust without the boilerplate.
+
+This is a toy implementation (v0.0.1) written in Python. It features a lexer, parser, AST, and a transpiler to Python (which simulates "compilation" by generating and executing equivalent Python code). Published on PyPI as `obsidian-lang`.
+
+## Features (v0.0.1)
+- Minimalist syntax inspired by Rust
+- Variables with `let`
+- Functions with `fn`
+- Basic expressions + comparison operators (< > <= >= == !=)
+- Control flow with `if` / `else`
+- Function calls (including built-in `println`)
+
+## Installation
+```bash
+pip install obsidian-lang
+```
+
+## Usage
+```bash
+# After pip install obsidian-lang
+obsidian examples/hello.obs --show-code
+
+# Or from source (development)
+PYTHONPATH=. python -m obsidian.main examples/hello.obs --show-code
+```
+
+## Example (hello.obs)
+```
+fn main() {
+    let x = 5;
+    let y = x + 3;
+    println(y);
+    println("Hello from Obsidian!");
+}
+```

obsidian_lang-0.0.1/obsidian_lang.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+obsidian/__init__.py
+obsidian/ast.py
+obsidian/lexer.py
+obsidian/main.py
+obsidian/parser.py
+obsidian/transpiler.py
+obsidian_lang.egg-info/PKG-INFO
+obsidian_lang.egg-info/SOURCES.txt
+obsidian_lang.egg-info/dependency_links.txt
+obsidian_lang.egg-info/entry_points.txt
+obsidian_lang.egg-info/top_level.txt

obsidian_lang-0.0.1/obsidian_lang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

obsidian_lang-0.0.1/obsidian_lang.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+obsidian = obsidian.main:main

obsidian_lang-0.0.1/obsidian_lang.egg-info/top_level.txt

@@ -0,0 +1 @@
+obsidian

obsidian_lang-0.0.1/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "obsidian-lang"
+version = "0.0.1"
+authors = [
+  { name = "Obsidian Language Team" },
+]
+description = "Obsidian is a compiled programming language that combines memory safety, zero-cost abstractions, and minimalist syntax. Built for developers who want the speed of Rust without the boilerplate."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+keywords = ["programming-language", "compiler", "transpiler", "rust-like", "toy-language"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Compilers",
+    "Topic :: Software Development :: Interpreters",
+]
+
+[project.urls]
+Homepage = "https://github.com/example/obsidian-lang"
+Repository = "https://github.com/example/obsidian-lang"
+"Bug Tracker" = "https://github.com/example/obsidian-lang/issues"
+
+[project.scripts]
+obsidian = "obsidian.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["obsidian*"]
+exclude = ["examples*", "tests*"]
+
+[tool.setuptools.package-data]
+obsidian = ["*.py"]

obsidian_lang-0.0.1/setup.cfg

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