flyconf 0.1.0__tar.gz

flyconf-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,115 @@
+# 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/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-0.1.0/flyconf/__main__.py

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

flyconf-0.1.0/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-0.1.0/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)})"