certora-cli-beta-mirror 7.28.0__py3-none-any.whl → 8.5.0__py3-none-any.whl

certora_cli/CertoraProver/certoraCollectConfigurationLayout.py

@@ -12,10 +12,10 @@
 #
 #     You should have received a copy of the GNU General Public License
 #     along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
+import dataclasses
 import json
 from enum import Enum
-from typing import Optional, Dict, Any
+from typing import Optional, Any
 from pathlib import Path
 import sys
 
@@ -25,27 +25,46 @@ sys.path.insert(0, str(scripts_dir_path))
 import CertoraProver.certoraContextAttributes as Attrs
 from CertoraProver.certoraCollectRunMetadata import RunMetaData, MetadataEncoder
 import Shared.certoraUtils as Utils
+from typing import List
 
 
 class MainSection(Enum):
     GENERAL = "GENERAL"
+    OPTIONS = "OPTIONS"
     SOLIDITY_COMPILER = "SOLIDITY_COMPILER"
-    GIT = "GIT"
-    FILES = "FILES"
-    LINKS = "LINKS"
-    PACKAGES = "PACKAGES"
-    METADATA = "METADATA"
+    NEW_SECTION = "NEW_SECTION"
+
+
+class ContentType(Enum):
+    SIMPLE = "SIMPLE"
+    COMPLEX = "COMPLEX"
+    FLAG = "FLAG"
+
 
+@dataclasses.dataclass
+class InnerContent:
+    inner_title: str
+    content_type: str
+    content: Any
+    doc_link: str = ''
+    tooltip: str = ''
+    unsound: bool = False
 
-class FlagType(Enum):
-    VALUE_FLAG = "VALUE"
-    LIST_FLAG = "LIST"
-    MAP_FLAG = "MAP"
+    def __post_init__(self) -> None:
+        if isinstance(self.content, bool):
+            self.content = 'true' if self.content else 'false'
+
+
+@dataclasses.dataclass
+class CardContent:
+    card_title: str
+    content_type: str
+    content: Any
 
 
 DOC_LINK_PREFIX = 'https://docs.certora.com/en/latest/docs/'
 GIT_ATTRIBUTES = ['origin', 'revision', 'branch', 'dirty']
-SPECIAL_MAIN_SECTIONS = ['files', 'links', 'packages']
+ARG_LIST_ATTRIBUTES = ['prover_args', 'java_args']
 
 
 class AttributeJobConfigData:
@@ -54,13 +73,13 @@ class AttributeJobConfigData:
     This should be added to the AttributeDefinition and configured for every new attribute
     presented in the Rule report.
 
-    Note: Attributes which do not contain specific information will be assigned as a Flag in the General main section!
+    Note: Attributes that do not contain specific information will be presented in the OPTIONS main section!
 
     arguments:
     - main_section : MainSection -- the main section inside the config tab
-        default: MainSection.GENERAL
-    - subsection : str -- the subsection within the main_section (e.g Flags)
-        default: Flags
+        default: MainSection.OPTIONS
+    - subsection : str -- the subsection within the main_section
+        default: None - they will be presented inside the OPTIONS card
     - doc_link : Optional[str] -- a link to the Documentation page of this attribute (if exists)
         default: 'https://docs.certora.com/en/latest/docs/' + Solana/EVM path + #<attribute_name>
     - tooltip : Optional[str] -- a description of this attribute to present in the config tab
@@ -69,7 +88,7 @@ class AttributeJobConfigData:
         default: False
     """
 
-    def __init__(self, main_section: MainSection = MainSection.GENERAL, subsection: str = '',
+    def __init__(self, main_section: MainSection = MainSection.OPTIONS, subsection: str = '',
                  doc_link: Optional[str] = '', tooltip: Optional[str] = '', unsound: bool = False):
         self.main_section = main_section
         self.subsection = subsection
@@ -87,18 +106,25 @@ class RunConfigurationLayout:
     configuration_layout : Dict -- An aggregated configuration for a specific run, nested by main section, subsection.
         Each leaf contains data about attribute value, type, documentation link and UI data.
     """
-    def __init__(self, configuration_layout: Dict[str, Any]):
+
+    configuration_layout: list[Any]
+
+    def __init__(self, configuration_layout: list[Any]):
         # Dynamically allocate class attributes from dict
-        for key, value in configuration_layout.items():
-            setattr(self, key, value)
+        self.configuration_layout = configuration_layout
 
     def __repr__(self) -> str:
-        return "\n".join(f"{key}: {value}" for key, value in self.__dict__.items())
+        try:
+            return json.dumps(self.configuration_layout, indent=2, sort_keys=True)
+        except TypeError:
+            # Fallback if something isn't serializable
+            return str(self.configuration_layout)
 
     @classmethod
-    def dump_file(cls, data: dict) -> None:
+    def dump_file(cls, data: list) -> None:
+        sorted_data = sort_configuration_layout(data)
         with Utils.get_configuration_layout_data_file().open("w+") as f:
-            json.dump(data, f, indent=4, sort_keys=True, cls=MetadataEncoder)
+            json.dump(sorted_data, f, indent=4, cls=MetadataEncoder)
 
     @classmethod
     def load_file(cls) -> dict:
@@ -110,12 +136,11 @@ class RunConfigurationLayout:
             raise
 
     def dump(self) -> None:
-        if self.__dict__:  # dictionary containing all the attributes defined for GitInfo
-            try:
-                self.dump_file(self.__dict__)
-            except Exception as e:
-                print(f"failed to write configuration layout file {Utils.get_configuration_layout_data_file()}\n{e}")
-                raise
+        try:
+            self.dump_file(self.configuration_layout)
+        except Exception as e:
+            print(f"Failed to write configuration layout file: {Utils.get_configuration_layout_data_file()}\n{e}")
+            raise
 
 
 def collect_configuration_layout() -> RunConfigurationLayout:
@@ -127,7 +152,7 @@ def collect_configuration_layout() -> RunConfigurationLayout:
         metadata = RunMetaData.load_file()
     except Exception as e:
         print(f"failed to load job metadata! cannot create a configuration layout file without metadata!\n{e}")
-        return RunConfigurationLayout(configuration_layout={})
+        return RunConfigurationLayout(configuration_layout=[])
 
     attributes_configs = collect_attribute_configs(metadata)
     configuration_layout = collect_run_config_from_metadata(attributes_configs, metadata)
@@ -154,89 +179,210 @@ def get_doc_link(attr) -> str:  # type: ignore
     return doc_link
 
 
-def collect_attribute_configs(metadata: dict) -> dict:
+def create_or_get_card_content(output: list[CardContent], name: str) -> CardContent:
+    """
+        Returns an existing CardContent by name or creates and appends a new one if it doesn't exist.
+        Card content type will always be complex in this case.
+        Args:
+            output (list[CardContent]): List of CardContent objects.
+            name (str): Title of the card to find or create.
+
+        Returns:
+            CardContent: The found or newly created CardContent.
+        """
+    main_section = next((section for section in output if section.card_title == name), None)
+    if main_section is None:
+        main_section = CardContent(
+            card_title=name,
+            content_type=ContentType.COMPLEX.value,
+            content=[]
+        )
+        output.append(main_section)
+    return main_section
+
+
+def split_and_sort_arg_list_value(args_list: List[str]) -> List[str]:
+    """
+    Splits a unified CLI argument list of strings into a sorted list of flag+value groups.
+    This is useful mainly for --prover_args and --java_args.
+
+    For example:
+    "-depth 15 -adaptiveSolverConfig false" → ["-adaptiveSolverConfig false", "-depth 15"]
+
+    Assumes each flag starts with '-' and its value follows immediately, if exists.
+    Lines are sorted alphabetically.
+    """
+    unified_args = ' '.join(str(arg) for arg in args_list)
+
+    if not unified_args.strip():
+        return []
+
+    lines: List[str] = []
+    tokens = unified_args.split()
+    curr_line = ""
+
+    for token in tokens:
+        if token.startswith('-'):
+            if curr_line:
+                lines.append(curr_line)
+            curr_line = token
+        else:
+            curr_line += f" {token}"
+
+    if curr_line:
+        lines.append(curr_line)
+
+    return sorted(lines)
+
+
+def create_inner_content(name: str, content_type: ContentType, value: Any, doc_link: str,
+                         config_data: AttributeJobConfigData) -> InnerContent:
+    return InnerContent(
+        inner_title=name,
+        content_type=content_type.value,
+        content=value,
+        doc_link=doc_link,
+        tooltip=config_data.tooltip or '',
+        unsound=config_data.unsound
+    )
+
+
+def collect_attribute_configs(metadata: dict) -> list[CardContent]:
+    """
+    Collects and organizes attribute configurations into a structured list of CardContent objects.
+
+    This function iterates through all available attributes defined, checks if relevant metadata is provided
+    for each attribute, and organizes the data into sections and subsections based on configuration rules.
+
+    Attributes are grouped under their respective main sections, with special handling for:
+    - Simple value attributes
+    - List and dictionary attributes
+    - Attributes requiring new sections (e.g., Files, Links, Packages)
+
+    Args:
+        metadata (dict): Metadata dictionary containing attribute values.
+
+    Returns:
+        list: A list of CardContent objects representing the structured configuration view,
+              ready for rendering or further processing.
+    """
     attr_list = Attrs.get_attribute_class().attribute_list()
-    output: Dict[str, Any] = {}
+    output: list[CardContent] = []
 
     for attr in attr_list:
         attr_name = attr.name.lower()
         if attr.config_data is None:
             continue
 
-        if metadata.get(attr_name) is None and metadata.get('conf', {}).get(attr_name) is None:
+        attr_value = metadata.get(attr_name) or metadata.get('conf', {}).get(attr_name)
+        if attr_value is None:
             continue
 
-        attr_value = metadata.get(attr_name) or metadata.get('conf', {}).get(attr_name)
         config_data: AttributeJobConfigData = attr.config_data
         doc_link = config_data.doc_link or get_doc_link(attr)
 
-        # Get or create the main section
+        # Find or create the main section
         main_section_key = config_data.main_section.value.lower()
-        main_section = output.setdefault(main_section_key, {})
+        main_section = create_or_get_card_content(output, main_section_key)
+
+        # Files, Links and Packages are special cases where the main section is the attribute itself
+        if main_section_key == MainSection.NEW_SECTION.value.lower():
+            main_section.card_title = attr_name
+            main_section.content_type = ContentType.SIMPLE.value
+            main_section.content.append(
+                create_inner_content(attr_name, ContentType.SIMPLE, attr_value, doc_link, config_data)
+            )
+            continue
 
-        # Get or create the subsection (if it exists) and flag_type
+        # Find or create the subsection (if it doesn't exist)
         if isinstance(attr_value, list):
-            # Files, Links and Packages are special cases where the main section is the attribute itself
-            if main_section_key in SPECIAL_MAIN_SECTIONS:
-                current_section = output
-                attr_name = main_section_key
-            else:
-                current_section = main_section
-
-            flag_type = FlagType.LIST_FLAG
+            content_type = ContentType.SIMPLE
+            if attr_name in ARG_LIST_ATTRIBUTES:
+                attr_value = split_and_sort_arg_list_value(attr_value)
+
         elif isinstance(attr_value, dict):
-            current_section = main_section
-            flag_type = FlagType.MAP_FLAG
+            content_type = ContentType.COMPLEX
+            attr_value = [
+                create_inner_content(key, ContentType.FLAG, value, doc_link, config_data)
+                for key, value in attr_value.items()
+            ]
         else:
-            subsection_key = config_data.subsection.lower() if config_data.subsection else 'flags'
-            current_section = main_section.setdefault(subsection_key, {})
-            flag_type = FlagType.VALUE_FLAG
+            content_type = ContentType.FLAG
 
         # Update the current section with attribute details
-        current_section[attr_name] = {
-            'value': attr_value,
-            'flag_type': flag_type.value.lower(),
-            'doc_link': doc_link,
-            'tooltip': config_data.tooltip,
-            'unsound': config_data.unsound
-        }
+        main_section.content.append(
+            create_inner_content(attr_name, content_type, attr_value, doc_link, config_data)
+        )
 
     return output
 
 
-def collect_run_config_from_metadata(attributes_configs: dict, metadata: dict) -> dict:
+def collect_run_config_from_metadata(attributes_configs: list[CardContent], metadata: dict) -> list[CardContent]:
     """
     Adding CLI and Git configuration from metadata
     """
-    metadata_section = attributes_configs.setdefault(MainSection.METADATA.value.lower(), {})
 
-    # Define a mapping of metadata attributes to their keys in general_section
-    metadata_mappings = {
-        'cli_version': metadata.get('CLI_version'),
-        'main_spec': metadata.get('main_spec'),
-        'solc_version': metadata.get('conf', {}).get('solc'),
-        'verify': metadata.get('conf', {}).get('verify'),
-    }
+    general_section = create_or_get_card_content(attributes_configs, MainSection.GENERAL.value.lower())
+
+    if cli_version := metadata.get('CLI_version'):
+        general_section.content.append(InnerContent(
+            inner_title='CLI Version',
+            content_type=ContentType.FLAG.value,
+            content=cli_version,
+        ))
 
-    # Add metadata attributes dynamically if they exist
-    for key, value in metadata_mappings.items():
-        if value:
-            metadata_section[key] = {
-                'value': value,
-                'flag_type': FlagType.VALUE_FLAG.value,
-                'doc_link': '',
-                'tooltip': '',
-            }
-
-    # Adding GIT configuration from metadata
-    git_section = attributes_configs.setdefault(MainSection.GIT.value.lower(), {})
     for attr in GIT_ATTRIBUTES:
         if attr_value := metadata.get(attr):
-            git_section[attr] = {
-                'value': attr_value,
-                'flag_type': FlagType.MAP_FLAG.value,
-                'doc_link': '',
-                'tooltip': ''
-            }
+            general_section.content.append(InnerContent(
+                inner_title=attr,
+                content_type=ContentType.FLAG.value,
+                content=attr_value,
+            ))
 
     return attributes_configs
+
+
+def sort_configuration_layout(data: list[CardContent]) -> list[CardContent]:
+    """
+    Sorts a configuration layout:
+    - Top-level sorted by 'card_title'
+    - Nested content sorted by 'inner_title', with 'verify' first
+    """
+    priority = {
+        # Priorities for top-level cards
+        "general": 0,
+        "files": 1,
+        "options": 2,
+        # Top level items inside their respective cards
+        "verify": 0,
+        "solc": 0,
+        "CLI Version": 0
+    }
+
+    def inner_sort_key(item: Any) -> Any:
+        if isinstance(item, CardContent):
+            title = item.card_title
+            return priority.get(title, 3), title.lower()
+        elif isinstance(item, InnerContent):
+            title = item.inner_title
+            return priority.get(title, 3), title.lower()
+        else:
+            return item
+
+    def sort_content(content: list[InnerContent]) -> list[InnerContent]:
+        sorted_content = []
+        for item in content:
+            if isinstance(item.content, list):
+                # Recurse into nested 'content'
+                item.content = sorted(item.content, key=inner_sort_key)
+            sorted_content.append(item)
+        return sorted(sorted_content, key=inner_sort_key)
+
+    # Sort top-level entries by 'card_title'
+    sorted_data = sorted(data, key=inner_sort_key)
+
+    # Sort nested 'content'
+    for section in sorted_data:
+        section.content = sort_content(section.content)
+
+    return sorted_data

certora_cli/CertoraProver/certoraCollectRunMetadata.py

@@ -12,8 +12,9 @@
 #
 #     You should have received a copy of the GNU General Public License
 #     along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
+import dataclasses
 import json
+import re
 from typing import Any, Dict, List, Optional
 import subprocess
 from datetime import datetime, timezone
@@ -31,6 +32,7 @@ import CertoraProver.certoraContextAttributes as Attrs
 
 metadata_logger = logging.getLogger("metadata")
 
+
 def collect_args_with_jar_flags() -> List[str]:
     return_array = []
     for attr in Attrs.get_attribute_class().attribute_list():
@@ -47,6 +49,8 @@ class MetadataEncoder(json.JSONEncoder):
     def default(self, obj: Any) -> Any:
         if isinstance(obj, set):
             return list(obj)
+        if dataclasses.is_dataclass(obj):
+            return dataclasses.asdict(obj)
         return json.JSONEncoder.default(self, obj)
 
 
@@ -68,10 +72,19 @@ class RunMetaData:
     dirty -- true iff the git repository has changes (git diff is not empty)
     main_spec -- the relative path to the main spec file that should be displayed by default at the web report
     conf_path -- the relative path form the cwd_relative to the configuration file
+    group_id -- optional identifier for grouping this run
+    java_version -- version of Java used during the run, if available
+    default_solc_version -- version of default solc version on current machine, if available
+    python_version -- version of Python running the process
+    certora_ci_client -- name of the CI client if available, derived from environment
+    timestamp -- UTC timestamp when the run metadata was generated
+    CLI_package_name -- name of the CLI package
+    CLI_version -- version of the CLI
+    jar_flag_info -- CLI attributes which are jarFlags
     """
     def __init__(self, raw_args: List[str], conf: Dict[str, Any], origin: str, revision: str,
                  branch: str, cwd_relative: Path, dirty: bool, main_spec: Optional[str],
-                 conf_path: Optional[Path], group_id: Optional[str]):
+                 conf_path: Optional[Path], group_id: Optional[str], java_version: str):
         self.raw_args = raw_args
         self.conf = conf
         self.origin = origin
@@ -83,6 +96,8 @@ class RunMetaData:
         self.conf_path = conf_path
         self.group_id = group_id
         self.python_version = ".".join(str(x) for x in sys.version_info[:3])
+        self.java_version = java_version
+        self.default_solc_version = get_solc_version(self.conf)
         self.certora_ci_client = Utils.get_certora_ci_name()
         self.timestamp = str(datetime.now(timezone.utc).timestamp())
         _, self.CLI_package_name, self.CLI_version = Utils.get_package_and_version()
@@ -103,6 +118,8 @@ class RunMetaData:
             f" conf_path: {self.conf_path}\n"
             f" group_id: {self.group_id}\n"
             f" python_version: {self.python_version}\n"
+            f" java_version: {self.java_version}\n"
+            f" default_solc_version: {self.default_solc_version}\n"
             f" CertoraCI client: {self.certora_ci_client}\n"
             f" jar_flag_info: {self.jar_flag_info}\n"
         )
@@ -180,7 +197,8 @@ def collect_run_metadata(wd: Path, raw_args: List[str], context: CertoraContext)
                            dirty=True,
                            main_spec=None,
                            conf_path=None,
-                           group_id=None)
+                           group_id=None,
+                           java_version=context.java_version)
 
     # collect information about current git snapshot
     cwd_abs = wd.absolute()
@@ -208,7 +226,8 @@ def collect_run_metadata(wd: Path, raw_args: List[str], context: CertoraContext)
                            dirty=True,
                            main_spec=get_main_spec(context),
                            conf_path=conf_path,
-                           group_id=context.group_id)
+                           group_id=context.group_id,
+                           java_version=context.java_version)
 
     try:
         sha_out = subprocess.run(['git', 'rev-parse', 'HEAD'], cwd=wd,
@@ -243,7 +262,8 @@ def collect_run_metadata(wd: Path, raw_args: List[str], context: CertoraContext)
                            dirty=dirty,
                            main_spec=get_main_spec(context),
                            conf_path=conf_path,
-                           group_id=context.group_id)
+                           group_id=context.group_id,
+                           java_version=context.java_version)
 
         metadata_logger.debug(f' collected data:\n{str(data)}')
 
@@ -261,4 +281,30 @@ def collect_run_metadata(wd: Path, raw_args: List[str], context: CertoraContext)
                            dirty=True,
                            main_spec=get_main_spec(context),
                            conf_path=conf_path,
-                           group_id=context.group_id)
+                           group_id=context.group_id,
+                           java_version=context.java_version)
+
+
+def get_solc_version(conf: Dict[str, Any]) -> Optional[str]:
+    if conf.get('solc') or conf.get('solc_map') or conf.get('compiler_map'):
+        return None
+
+    try:
+        result = subprocess.run(
+            ["solc", "--version"],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        for line in result.stdout.splitlines():
+            if line.startswith("Version:"):
+                version_matches = re.findall(r'^Version: (\d+)\.(\d+)\.(\d+)', line, re.MULTILINE)
+                if len(version_matches) != 1:
+                    return None
+                match = version_matches[0]
+                return f'solc{int(match[1])}.{int(match[2])}'
+
+    except Exception as e:
+        metadata_logger.debug(f'Error while trying to fetch default solc version: {e}')
+        return None
+    return None

certora_cli/CertoraProver/certoraCompilerParameters.py

@@ -35,3 +35,14 @@ class SolcParameters(CompilerParameters):
         as_dict.update({"optimizerOn": self.optimizer_on, "optimizerRuns": self.optimizer_runs, "viaIR": self.via_ir,
                         "type": "SolcParameters"})
         return as_dict
+
+class VyperParameters(CompilerParameters):
+
+    def __init__(self, is_venom: bool):
+        self.is_venom = is_venom
+        CompilerParameters.__init__(self)
+
+    def as_dict(self) -> Dict[str, Any]:
+        as_dict = CompilerParameters.as_dict(self)
+        as_dict.update({"is_venom": self.is_venom, "type": "VyperParameters"})
+        return as_dict