flyconf 0.1.0__py3-none-any.whl

flyconf/__init__.py

@@ -0,0 +1,13 @@
+"""
+FlyConf Parser - A parser for fc configuration files.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Your Name"
+__email__ = "your.email@example.com"
+
+from .parser import FCConfigParser
+from .model import FCConfig, FCBlock
+from .transformer import ConfigTransformer
+
+__all__ = ["FCConfigParser", "FCConfig", "FCBlock", "ConfigTransformer"]

flyconf/__main__.py

@@ -0,0 +1,8 @@
+"""
+Main entry point for the flyconf module.
+"""
+
+from . import main
+
+if __name__ == "__main__":
+    main.main()

flyconf/lexer.py

@@ -0,0 +1,245 @@
+"""
+Lexer for fc configuration files.
+"""
+
+from enum import Enum
+from typing import List, Iterator, NamedTuple
+import re
+
+
+class TokenType(Enum):
+    """Token types for fc configuration files."""
+    AT = "@"  # @
+    BLOCK_NAME = "BLOCK_NAME"  # Block name identifier
+    LPAREN = "("  # (
+    RPAREN = ")"  # )
+    LBRACKET = "["  # [
+    RBRACKET = "]"  # ]
+    GT = ">"  # >
+    CARET = "^"  # ^
+    DOUBLE_CARET = "^^"  # ^^
+    HASH = "#"  # #
+    DOLLAR_PAREN = "$("  # $(
+    IDENTIFIER = "IDENTIFIER"  # General identifier
+    STRING = "STRING"  # String content
+    COMMA = ","  # ,
+    EQUALS = "="  # =
+    NEWLINE = "NEWLINE"  # \n
+    WHITESPACE = "WHITESPACE"  # Spaces, tabs
+    EOF = "EOF"  # End of file
+
+
+class Token(NamedTuple):
+    """Represents a token with type, value, and position."""
+    type: TokenType
+    value: str
+    line: int
+    column: int
+
+
+class LexerError(Exception):
+    """Exception raised for lexer errors."""
+    pass
+
+
+class Lexer:
+    """Lexer for fc configuration files."""
+    
+    def __init__(self, text: str):
+        self.text: str = text
+        self.pos: int = 0
+        self.line: int = 1
+        self.column: int = 1
+        self.tokens: List[Token] = []
+    
+    def _current_char(self) -> str:
+        """Get the current character."""
+        if self.pos >= len(self.text):
+            return '\0'
+        return self.text[self.pos]
+    
+    def _peek_char(self, offset: int = 1) -> str:
+        """Peek at the next character."""
+        if self.pos + offset >= len(self.text):
+            return '\0'
+        return self.text[self.pos + offset]
+    
+    def _advance(self) -> None:
+        """Advance the position."""
+        if self._current_char() == '\n':
+            self.line += 1
+            self.column = 1
+        else:
+            self.column += 1
+        self.pos += 1
+    
+    def _skip_whitespace(self) -> None:
+        """Skip whitespace characters."""
+        while self._current_char().isspace() and self._current_char() != '\0':
+            if self._current_char() == '\n':
+                token = Token(TokenType.NEWLINE, '\n', self.line, self.column)
+                self.tokens.append(token)
+            self._advance()
+    
+    def _read_identifier(self) -> str:
+        """Read an identifier."""
+        start = self.pos
+        while (self._current_char().isalnum() or 
+               self._current_char() in ['_', '-', '.']) and \
+              self._current_char() != '\0':
+            self._advance()
+        return self.text[start:self.pos]
+    
+    def _read_string(self, delimiter: str) -> str:
+        """Read a string until the delimiter."""
+        start = self.pos
+        while self._current_char() != delimiter and self._current_char() != '\0':
+            # Handle escaped characters
+            if self._current_char() == '\\' and self._peek_char() != '\0':
+                self._advance()
+            self._advance()
+        
+        if self._current_char() == '\0':
+            raise LexerError(f"Unterminated string at line {self.line}, column {self.column}")
+        
+        value = self.text[start:self.pos]
+        # Skip the closing delimiter
+        self._advance()
+        return value
+    
+    def _read_multiline_string(self, delimiter: str) -> str:
+        """Read a multiline string until the delimiter."""
+        start = self.pos
+        # Look for the closing delimiter (two consecutive ^)
+        while not (self._current_char() == delimiter and 
+                   self._peek_char() == delimiter) and \
+              self._current_char() != '\0':
+            # Handle escaped characters
+            if self._current_char() == '\\' and self._peek_char() != '\0':
+                self._advance()
+            self._advance()
+        
+        if self._current_char() == '\0':
+            raise LexerError(f"Unterminated multiline string at line {self.line}, column {self.column}")
+        
+        value = self.text[start:self.pos]
+        # Skip the closing delimiters
+        self._advance()  # Skip first ^
+        self._advance()  # Skip second ^
+        return value
+    
+    def _read_raw_string(self, delimiter: str) -> str:
+        """Read a raw string until the delimiter."""
+        start = self.pos
+        # Look for the closing delimiter (three consecutive ^)
+        while not (self._current_char() == delimiter and 
+                   self._peek_char() == delimiter and 
+                   self._peek_char(2) == delimiter) and \
+              self._current_char() != '\0':
+            self._advance()
+        
+        if self._current_char() == '\0':
+            raise LexerError(f"Unterminated raw string at line {self.line}, column {self.column}")
+        
+        value = self.text[start:self.pos]
+        # Skip the closing delimiters
+        self._advance()  # Skip first ^
+        self._advance()  # Skip second ^
+        self._advance()  # Skip third ^
+        return value
+    
+    def _skip_comment(self) -> None:
+        """Skip a comment until end of line."""
+        while self._current_char() != '\n' and self._current_char() != '\0':
+            self._advance()
+    
+    def tokenize(self) -> List[Token]:
+        """Tokenize the input text."""
+        while self._current_char() != '\0':
+            # Skip whitespace but capture newlines
+            self._skip_whitespace()
+            
+            if self._current_char() == '\0':
+                break
+            
+            # Handle comments
+            if self._current_char() == '#':
+                self._skip_comment()
+                continue
+            
+            # Handle special tokens
+            char = self._current_char()
+            next_char = self._peek_char()
+            next_next_char = self._peek_char(2)
+            
+            # Handle triple caret (raw string) (^^^)
+            if char == '^' and next_char == '^' and next_next_char == '^':
+                self._advance()
+                self._advance()
+                self._advance()
+                # Read raw string
+                string_value = self._read_raw_string('^')
+                string_token = Token(TokenType.STRING, string_value, self.line, self.column)
+                self.tokens.append(string_token)
+                continue
+            
+            # Handle double caret (multiline string) (^^)
+            if char == '^' and next_char == '^' and next_next_char != '^':
+                self._advance()
+                self._advance()
+                # Read multiline string
+                string_value = self._read_multiline_string('^')
+                string_token = Token(TokenType.STRING, string_value, self.line, self.column)
+                self.tokens.append(string_token)
+                continue
+            
+            # Handle single caret (^)
+            if char == '^':
+                self._advance()
+                # Read string
+                string_value = self._read_string('^')
+                string_token = Token(TokenType.STRING, string_value, self.line, self.column)
+                self.tokens.append(string_token)
+                continue
+            
+            # Handle other special tokens
+            special_tokens = {
+                '@': TokenType.AT,
+                '(': TokenType.LPAREN,
+                ')': TokenType.RPAREN,
+                '[': TokenType.LBRACKET,
+                ']': TokenType.RBRACKET,
+                '>': TokenType.GT,
+                ',': TokenType.COMMA,
+                '=': TokenType.EQUALS,
+                '#': TokenType.HASH,
+            }
+            
+            # Handle $(
+            if char == '$' and next_char == '(':
+                token = Token(TokenType.DOLLAR_PAREN, '$(', self.line, self.column)
+                self.tokens.append(token)
+                self._advance()
+                self._advance()
+                continue
+            
+            # Handle other special tokens
+            if char in special_tokens:
+                token = Token(special_tokens[char], char, self.line, self.column)
+                self.tokens.append(token)
+                self._advance()
+                continue
+            
+            # Handle identifiers
+            if char.isalnum() or char == '_':
+                value = self._read_identifier()
+                token = Token(TokenType.IDENTIFIER, value, self.line, self.column)
+                self.tokens.append(token)
+                continue
+            
+            # Skip unknown characters
+            self._advance()
+        
+        # Add EOF token
+        self.tokens.append(Token(TokenType.EOF, '', self.line, self.column))
+        return self.tokens

flyconf/model.py

@@ -0,0 +1,93 @@
+"""
+Data models for fc configuration files.
+"""
+
+from typing import List, Dict, Any, Optional
+
+
+class FCBlock:
+    """
+    Represents a block in fc configuration file.
+    
+    A block consists of:
+    - name: Block identifier
+    - meta: Metadata dictionary
+    - data: Data dictionary containing key-value pairs
+    """
+    
+    def __init__(self, name: str):
+        self.name: str = name
+        self.meta: Dict[str, Any] = {}
+        self.data: Dict[str, Any] = {}
+    
+    def __repr__(self) -> str:
+        return f"FCBlock(name='{self.name}', meta={self.meta}, data={self.data})"
+
+
+class FCConfig:
+    """
+    Represents a complete fc configuration.
+    
+    Contains:
+    - blocks: List of FCBlock objects
+    - variables: Global variables dictionary
+    """
+    
+    def __init__(self):
+        self.blocks: List[FCBlock] = []
+        self.variables: Dict[str, Any] = {}
+    
+    def get_block(self, name: str) -> Optional[FCBlock]:
+        """Get a block by name."""
+        for block in self.blocks:
+            if block.name == name:
+                return block
+        return None
+    
+    def add_block(self, block: FCBlock) -> None:
+        """Add a block to the configuration."""
+        self.blocks.append(block)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the configuration to a dictionary."""
+        result = {
+            "variables": self.variables,
+            "blocks": {}
+        }
+        
+        for block in self.blocks:
+            result["blocks"][block.name] = {
+                "meta": block.meta,
+                "data": block.data
+            }
+        
+        return result
+    
+    def to_json(self) -> str:
+        """Convert the configuration to JSON string."""
+        import json
+        return json.dumps(self.to_dict(), indent=2, ensure_ascii=False)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FCConfig":
+        """Create a configuration from a dictionary."""
+        config = cls()
+        config.variables = data.get("variables", {})
+        
+        for block_name, block_data in data.get("blocks", {}).items():
+            block = FCBlock(block_name)
+            block.meta = block_data.get("meta", {})
+            block.data = block_data.get("data", {})
+            config.add_block(block)
+        
+        return config
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> "FCConfig":
+        """Create a configuration from a JSON string."""
+        import json
+        data = json.loads(json_str)
+        return cls.from_dict(data)
+    
+    def __repr__(self) -> str:
+        return f"FCConfig(blocks={len(self.blocks)}, variables={len(self.variables)})"

flyconf/parser.py

@@ -0,0 +1,295 @@
+from typing import List, Dict, Any, Optional
+from .lexer import Lexer, Token, TokenType
+from .model import FCConfig, FCBlock
+
+
+class ParserError(Exception):
+    """Exception raised for parser errors."""
+    pass
+
+
+class FCConfigParser:
+    """Parser for fc configuration files."""
+    
+    def __init__(self, text: str):
+        self.lexer = Lexer(text)
+        self.tokens: List[Token] = []
+        self.pos: int = 0
+        self.config: FCConfig = FCConfig()
+    
+    def _current_token(self) -> Token:
+        """Get the current token."""
+        if self.pos >= len(self.tokens):
+            return Token(TokenType.EOF, '', 0, 0)
+        return self.tokens[self.pos]
+    
+    def _peek_token(self, offset: int = 1) -> Token:
+        """Peek at the next token."""
+        if self.pos + offset >= len(self.tokens):
+            return Token(TokenType.EOF, '', 0, 0)
+        return self.tokens[self.pos + offset]
+    
+    def _consume_token(self) -> Token:
+        """Consume the current token and advance."""
+        token = self._current_token()
+        self.pos += 1
+        return token
+    
+    def _match_token(self, token_type: TokenType) -> bool:
+        """Check if the current token matches the expected type."""
+        if self._current_token().type == token_type:
+            self._consume_token()
+            return True
+        return False
+    
+    def _expect_token(self, token_type: TokenType) -> Token:
+        """Expect a specific token type or raise an error."""
+        if self._current_token().type == token_type:
+            return self._consume_token()
+        raise ParserError(
+            f"Expected token {token_type}, got {self._current_token().type} "
+            f"at line {self._current_token().line}, column {self._current_token().column}"
+        )
+    
+    def _parse_block_name(self) -> str:
+        """Parse a block name."""
+        token = self._expect_token(TokenType.IDENTIFIER)
+        return token.value
+    
+    def _parse_key_value_list(self) -> Dict[str, Any]:
+        """Parse a key-value list."""
+        result = {}
+        
+        while self._current_token().type not in [TokenType.RPAREN, TokenType.RBRACKET, TokenType.EOF]:
+            # Skip newlines
+            if self._current_token().type == TokenType.NEWLINE:
+                self._consume_token()
+                continue
+                
+            # Check if we've reached the start of a new block
+            if self._current_token().type == TokenType.AT:
+                break
+            
+            # Check if the first token is a list (special case for lists without keys)
+            if self._current_token().type == TokenType.LBRACKET:
+                # This is a list without a key, which is not valid in our format
+                raise ParserError(
+                    f"Unexpected list at line {self._current_token().line}, column {self._current_token().column}. "
+                    f"Lists must be associated with a key."
+                )
+                
+            # Parse key
+            key_token = self._expect_token(TokenType.IDENTIFIER)
+            key = key_token.value
+            
+            # Check if there's a value (indicated by > or directly a list)
+            if self._current_token().type == TokenType.GT:
+                self._consume_token()  # Consume >
+                # Parse value
+                value = self._parse_value()
+                result[key] = value
+            elif self._current_token().type == TokenType.LBRACKET:
+                # Direct list value without >
+                value = self._parse_value()
+                result[key] = value
+            else:
+                # No value, treat as a flag
+                result[key] = True
+            
+            # Optional comma
+            if self._current_token().type == TokenType.COMMA:
+                self._consume_token()
+                # Handle trailing comma
+                if self._current_token().type in [TokenType.RPAREN, TokenType.RBRACKET, TokenType.EOF]:
+                    break
+        
+        return result
+    
+    def _parse_value(self) -> Any:
+        """Parse a value."""
+        token = self._current_token()
+        
+        # Handle string
+        if token.type == TokenType.STRING:
+            return self._consume_token().value
+        
+        # Handle list
+        if token.type == TokenType.LBRACKET:
+            return self._parse_list()
+        
+        # Handle variable reference
+        if token.type == TokenType.DOLLAR_PAREN:
+            return self._parse_variable_reference()
+        
+        # Handle identifier (can be a simple value or part of a list)
+        if token.type == TokenType.IDENTIFIER:
+            return self._consume_token().value
+        
+        # Default - consume and return as string
+        return self._consume_token().value
+    
+    def _parse_list_item(self) -> Dict[str, Any]:
+        """Parse a single list item (object with key-value pairs)."""
+        result = {}
+        
+        # Parse key-value pairs until we hit a comma, bracket, or EOF
+        while self._current_token().type not in [TokenType.COMMA, TokenType.RBRACKET, TokenType.EOF]:
+            # Skip newlines
+            if self._current_token().type == TokenType.NEWLINE:
+                self._consume_token()
+                continue
+            
+            # Check if we've reached the start of a new block
+            if self._current_token().type == TokenType.AT:
+                break
+                
+            # Parse key
+            key_token = self._expect_token(TokenType.IDENTIFIER)
+            key = key_token.value
+            
+            # Check if there's a value (indicated by >)
+            if self._current_token().type == TokenType.GT:
+                self._consume_token()  # Consume >
+                # Parse value
+                value = self._parse_value()
+                result[key] = value
+            else:
+                # No value, treat as a flag
+                result[key] = True
+        
+        return result
+    
+    def _parse_list(self) -> List[Any]:
+        """Parse a list."""
+        # Expect [
+        self._expect_token(TokenType.LBRACKET)
+        
+        items = []
+        while self._current_token().type != TokenType.RBRACKET and \
+              self._current_token().type != TokenType.EOF:
+            
+            # Skip newlines
+            if self._current_token().type == TokenType.NEWLINE:
+                self._consume_token()
+                continue
+            
+            # Check if we've reached the start of a new block
+            if self._current_token().type == TokenType.AT:
+                break
+            
+            # Handle comma separator between list items
+            if self._current_token().type == TokenType.COMMA:
+                self._consume_token()
+                continue
+            
+            # Check if this is the start of a list item (key-value pairs)
+            if self._current_token().type == TokenType.IDENTIFIER:
+                # Parse list item as an object
+                item = self._parse_list_item()
+                items.append(item)
+            elif self._current_token().type == TokenType.RBRACKET:
+                # End of list
+                break
+            else:
+                # Unexpected token in list
+                raise ParserError(
+                    f"Unexpected token {self._current_token().type} in list "
+                    f"at line {self._current_token().line}, column {self._current_token().column}"
+                )
+        
+        # Expect ]
+        self._expect_token(TokenType.RBRACKET)
+        return items
+    
+    def _parse_variable_reference(self) -> str:
+        """Parse a variable reference."""
+        # Expect $(
+        self._expect_token(TokenType.DOLLAR_PAREN)
+        
+        # Parse variable name
+        var_name = ""
+        while self._current_token().type != TokenType.EOF and \
+              self._current_token().type != TokenType.RPAREN:
+            var_name += self._consume_token().value
+        
+        # Expect )
+        self._expect_token(TokenType.RPAREN)
+        
+        return f"$({var_name})"
+    
+    def _parse_meta_part(self) -> Dict[str, Any]:
+        """Parse the meta part of a block."""
+        # Expect (
+        self._expect_token(TokenType.LPAREN)
+        
+        # Parse key-value list
+        meta = self._parse_key_value_list()
+        
+        # Expect )
+        self._expect_token(TokenType.RPAREN)
+        
+        return meta
+    
+    def _parse_data_part(self) -> Dict[str, Any]:
+        """Parse the data part of a block."""
+        # Parse key-value list directly (no braces)
+        return self._parse_key_value_list()
+    
+    def _parse_block(self) -> FCBlock:
+        """Parse a block."""
+        # Expect @
+        self._expect_token(TokenType.AT)
+        
+        # Parse block name
+        block_name = self._parse_block_name()
+        block = FCBlock(block_name)
+        
+        # Optional meta part
+        if self._current_token().type == TokenType.LPAREN:
+            block.meta = self._parse_meta_part()
+        
+        # Skip newlines before data part
+        while self._current_token().type == TokenType.NEWLINE:
+            self._consume_token()
+        
+        # Optional data part - check if the next token is an identifier (start of key-value pair)
+        # Lists are not allowed directly in the data part without a key
+        if self._current_token().type == TokenType.IDENTIFIER:
+            block.data = self._parse_data_part()
+        
+        return block
+    
+    def parse(self) -> FCConfig:
+        """Parse the entire configuration."""
+        # Tokenize the input
+        self.tokens = self.lexer.tokenize()
+        
+        # Parse blocks
+        while self._current_token().type != TokenType.EOF:
+            # Skip newlines
+            if self._current_token().type == TokenType.NEWLINE:
+                self._consume_token()
+                continue
+            
+            # Parse block
+            if self._current_token().type == TokenType.AT:
+                block = self._parse_block()
+                self.config.add_block(block)
+            else:
+                # Skip unknown tokens
+                self._consume_token()
+        
+        return self.config
+    
+    @classmethod
+    def parse_text(cls, text: str) -> FCConfig:
+        """Parse configuration from text."""
+        parser = cls(text)
+        return parser.parse()
+    
+    @classmethod
+    def parse_file(cls, file_path: str) -> FCConfig:
+        """Parse configuration from a file."""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            text = f.read()
+        return cls.parse_text(text)

flyconf/transformer.py

@@ -0,0 +1,137 @@
+"""
+Transformer for fc configuration files.
+Handles variable resolution and advanced transformations.
+"""
+
+import os
+from typing import Any, Dict
+from .model import FCConfig, FCBlock
+
+
+class VariableResolver:
+    """Resolves variable references in the configuration."""
+    
+    def __init__(self, config: FCConfig):
+        self.config = config
+    
+    def resolve_variable(self, var_ref: str) -> str:
+        """Resolve a variable reference."""
+        # Remove the $() wrapper
+        if var_ref.startswith("$(") and var_ref.endswith(")"):
+            var_name = var_ref[2:-1]
+        else:
+            var_name = var_ref
+        
+        # Handle environment variables
+        if var_name.startswith("ENV:"):
+            env_var_name = var_name[4:]  # Remove "ENV:" prefix
+            return os.getenv(env_var_name, "")
+        
+        # Handle internal references (this.block_name.key)
+        if var_name.startswith("this."):
+            parts = var_name[5:].split(".")  # Remove "this." prefix
+            if len(parts) >= 2:
+                block_name = parts[0]
+                key = ".".join(parts[1:])  # Join remaining parts with dots
+                
+                block = self.config.get_block(block_name)
+                if block:
+                    # Navigate through nested dictionaries if needed
+                    value = block.data
+                    key_parts = key.split(".")
+                    try:
+                        for part in key_parts:
+                            if isinstance(value, dict) and part in value:
+                                value = value[part]
+                            else:
+                                return var_ref  # Return original if not found
+                        return str(value)
+                    except (KeyError, TypeError):
+                        return var_ref  # Return original if error occurs
+        
+        # Handle global variables
+        if var_name in self.config.variables:
+            return str(self.config.variables[var_name])
+        
+        # Variable not found
+        return var_ref
+    
+    def resolve_value(self, value: Any) -> Any:
+        """Recursively resolve variables in a value."""
+        if isinstance(value, str):
+            if value.startswith("$(") and value.endswith(")"):
+                return self.resolve_variable(value)
+            return value
+        elif isinstance(value, dict):
+            resolved = {}
+            for k, v in value.items():
+                resolved[k] = self.resolve_value(v)
+            return resolved
+        elif isinstance(value, list):
+            return [self.resolve_value(item) for item in value]
+        else:
+            return value
+    
+    def resolve_config(self) -> FCConfig:
+        """Resolve all variables in the configuration."""
+        resolved_config = FCConfig()
+        resolved_config.variables = self.config.variables.copy()
+        
+        # Copy and resolve each block
+        for block in self.config.blocks:
+            resolved_block = FCBlock(block.name)
+            resolved_block.meta = block.meta.copy()
+            
+            # Resolve data values
+            for key, value in block.data.items():
+                resolved_block.data[key] = self.resolve_value(value)
+            
+            resolved_config.add_block(resolved_block)
+        
+        return resolved_config
+
+
+class ConfigTransformer:
+    """Transforms and processes FCConfig objects."""
+    
+    @staticmethod
+    def resolve_variables(config: FCConfig) -> FCConfig:
+        """Resolve all variable references in the configuration."""
+        resolver = VariableResolver(config)
+        return resolver.resolve_config()
+    
+    @staticmethod
+    def apply_environment(config: FCConfig, env_name: str = None) -> FCConfig:
+        """Apply environment-specific configurations."""
+        # For now, we'll just return the config as-is
+        # In a full implementation, this would merge environment-specific blocks
+        return config
+    
+    @staticmethod
+    def merge_configs(base_config: FCConfig, override_config: FCConfig) -> FCConfig:
+        """Merge two configurations, with override_config taking precedence."""
+        merged_config = FCConfig()
+        
+        # Copy base variables and update with override variables
+        merged_config.variables = base_config.variables.copy()
+        merged_config.variables.update(override_config.variables)
+        
+        # Create a dict of base blocks for easy lookup
+        base_blocks = {block.name: block for block in base_config.blocks}
+        
+        # Add all base blocks
+        for block in base_config.blocks:
+            merged_config.add_block(block)
+        
+        # Add or replace with override blocks
+        for override_block in override_config.blocks:
+            existing_block = merged_config.get_block(override_block.name)
+            if existing_block:
+                # Replace existing block
+                existing_block.meta.update(override_block.meta)
+                existing_block.data.update(override_block.data)
+            else:
+                # Add new block
+                merged_config.add_block(override_block)
+        
+        return merged_config

flyconf-0.1.0.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: flyconf
+Version: 0.1.0
+Summary: A parser for fc configuration files with support for complex structures, variables, and environment-aware configurations
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/flyconf
+Project-URL: Repository, https://github.com/yourusername/flyconf
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+
+# FlyConf Parser
+
+FlyConf Parser 是一个用于解析fc配置文件格式的Python库。fc配置文件是一种具有特定语法的配置格式，支持复杂的数据结构、变量引用和环境感知配置。
+
+## 特性
+
+- 词法分析器，支持识别fc配置文件中的各种标记
+- 语法分析器，构建配置块的抽象语法树
+- 数据模型，用于表示解析后的配置结构
+- 字符串处理（原生多行字符串和单行字符串）
+- 变量引用系统（支持外部变量、环境变量和配置内引用）
+- 列表解析（简单列表和嵌套列表）
+- 导入导出功能（支持JSON格式）
+- 环境感知配置合并
+
+## 安装
+
+```bash
+pip install flyconf
+```
+
+## 使用方法
+
+### 基本用法
+
+```python
+from flyconf.parser import FCConfigParser
+
+# 解析fc配置文件
+config = FCConfigParser.parse_file("config.fc")
+
+# 访问配置块
+block = config.get_block("server")
+print(block.data)
+
+# 导出为JSON
+import json
+json_data = config.to_json()
+```
+
+### fc配置文件语法
+
+fc配置文件具有以下语法结构：
+
+```
+@block_name(meta_key>meta_value) data_key>data_value
+```
+
+示例：
+```fc
+@mysql_default(type>conf.db)
+dbtype>mysql
+host>localhost
+port>3306
+database>oax
+user>root
+password>1234
+
+@remember_me(type>conf.txt)
+username>admin
+password>1234
+
+@test_list
+users>[user1,user2,user3]
+```
+
+### 字符串
+
+使用 `^...^` 表示单行字符串，使用 `^^^...^^^` 表示多行字符串：
+
+```fc
+@get_users(type>conf.sql)
+dbtype>mysql
+sql>^
+SELECT id, username, email FROM users
+^
+```
+
+### 列表
+
+使用 `[...]` 表示列表：
+
+```fc
+@test_list
+users>[user1,user2,user3]
+```
+
+### 变量引用
+
+使用 `$(variable_name)` 表示变量引用：
+
+```fc
+@server
+path>$(config.path)
+```
+
+## API
+
+### FCConfigParser
+
+- `FCConfigParser.parse_text(text)` - 从文本解析配置
+- `FCConfigParser.parse_file(file_path)` - 从文件解析配置
+
+### FCConfig
+
+- `config.get_block(name)` - 获取指定名称的块
+- `config.add_block(block)` - 添加块
+- `config.to_dict()` - 转换为字典
+- `config.to_json()` - 转换为JSON字符串
+
+### FCBlock
+
+- `block.name` - 块名称
+- `block.meta` - 元数据字典
+- `block.data` - 数据字典

flyconf-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+flyconf/__init__.py,sha256=_PT5-vFjh_YVnoYsLA1y1sVQDx3R-OlzzuGuxbXLd9I,336
+flyconf/__main__.py,sha256=gQnC64sonT2uTaPysH9xAoDWmBtkJuuXryCku2JJCtQ,112
+flyconf/lexer.py,sha256=UAqB0-ZcJokmGDJoy8Pr5B5q-EIxjhxrEBdyfa30jdI,8585
+flyconf/model.py,sha256=6OQjTJDXQDemWpUIeBDt9-iElroFn0bvkn-VRnoi2kY,2666
+flyconf/parser.py,sha256=RYEApDRcVHHmSRwRg56v25h4EBdBMnY5v64FJl1RBBM,10674
+flyconf/transformer.py,sha256=qvnIh96DCVTJ2xaxCFskEzrDsuNMUEpmsHUG-0zq-2Y,5207
+flyconf-0.1.0.dist-info/METADATA,sha256=1titiEHcU7oCOhSz3LjNvJ2ZbWaP8IUUOqgdpoltEUg,2868
+flyconf-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flyconf-0.1.0.dist-info/entry_points.txt,sha256=_Li-kCD7D12azPA5hhPYlZ9rZX0LcfkHO3jjXMkc5TE,50
+flyconf-0.1.0.dist-info/top_level.txt,sha256=kYvV-mkBd_1kvtge2WbuH6VKn5Uodp72rZM4g2W6oZE,8
+flyconf-0.1.0.dist-info/RECORD,,

flyconf-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flyconf-0.1.0.dist-info/entry_points.txt

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

flyconf-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flyconf