superacli 1.1.6 → 1.1.8

package/ref-monty/examples/web_scraper/sub_agent.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass, field
-from textwrap import indent
-from typing import Any
-
-from pydantic import BaseModel, ValidationError
-from pydantic_ai import Agent, ModelRetry, format_as_xml
-
-
-class ModelInfo(BaseModel, use_attribute_docstrings=True):
-    unique_id: str
-    """Unique identifier for the model."""
-    name: str
-    """Name of the model."""
-    description: str | None = None
-    """Description of the model."""
-    input_mtok: float
-    """Input tokens per million tokens."""
-    output_mtok: float
-    """Output tokens per million tokens."""
-    attributes: dict[str, float | str] | None = None
-    """Any other attributes of the model."""
-
-
-agent = Agent(
-    'gateway/anthropic:claude-sonnet-4-5',
-    output_type=ModelInfo | str,
-    instructions="Try to coerce the input into a ModelInfo object, if you're unable to do so, return a string describing the error.",
-    name='extraction-sub-agent',
-)
-
-
-@dataclass
-class RecordModels:
-    models: dict[str, ModelInfo] = field(default_factory=dict)
-
-    async def record_model_info(self, model_information: dict[str, Any]) -> str:
-        """Record information about a model."""
-
-        try:
-            output = ModelInfo.model_validate(model_information)
-        except ValidationError:
-            pass
-        else:
-            self.models[output.unique_id] = output
-            return f'Model information recorded successfully for {output.unique_id}'
-
-        try:
-            result = await agent.run(format_as_xml(model_information))
-        except ModelRetry:
-            return 'Error, unable to validate model information'
-        else:
-            output = result.output
-            if isinstance(output, str):
-                return output
-            else:
-                self.models[output.unique_id] = output
-                return f'Model information recorded successfully for {output.unique_id}'
-
-    @classmethod
-    def record_model_info_stub(cls) -> str:
-        return f'''\
-from typing import Any
-
-def record_model_info(model_information: dict[str, Any]) -> str:
-    """Record information about a model.
-
-    NOTE: this method takes a python dict argument, not JSON.
-
-    The dict should have this schema:
-
-    ```json
-    {indent(json.dumps(ModelInfo.model_json_schema(), indent=2), prefix='    ')}
-    ```
-    """
-    ...
-'''

package/ref-monty/monty-npm.md

@@ -1,235 +0,0 @@
-skip to:contentpackage search
-❤
-Pro
-Teams
-Pricing
-Documentation
-npm
-Search packages
-Search
-@pydantic/monty
-TypeScript icon, indicating that this package has built-in type declarations
-0.0.8 • Public • Published 20 hours ago
-@pydantic/monty
-JavaScript/TypeScript bindings for the Monty sandboxed Python interpreter.
-
-Installation
-npm install @pydantic/monty
-Basic Usage
-import { Monty } from '@pydantic/monty'
-
-// Create interpreter and run code
-const m = new Monty('1 + 2')
-const result = m.run() // returns 3
-Input Variables
-const m = new Monty('x + y', { inputs: ['x', 'y'] })
-const result = m.run({ inputs: { x: 10, y: 20 } }) // returns 30
-External Functions
-For synchronous external functions, pass them directly to run():
-
-const m = new Monty('add(2, 3)')
-
-const result = m.run({
-  externalFunctions: {
-    add: (a: number, b: number) => a + b,
-  },
-}) // returns 5
-For async external functions, use runMontyAsync():
-
-import { Monty, runMontyAsync } from '@pydantic/monty'
-
-const m = new Monty('fetch_data(url)', {
-  inputs: ['url'],
-})
-
-const result = await runMontyAsync(m, {
-  inputs: { url: 'https://example.com' },
-  externalFunctions: {
-    fetch_data: async (url: string) => {
-      const response = await fetch(url)
-      return response.text()
-    },
-  },
-})
-Iterative Execution
-For fine-grained control over external function calls, use start() and resume():
-
-const m = new Monty('a() + b()')
-
-let progress = m.start()
-while (progress instanceof MontySnapshot) {
-  console.log(`Calling: ${progress.functionName}`)
-  console.log(`Args: ${progress.args}`)
-  // Provide the return value and resume
-  progress = progress.resume({ returnValue: 10 })
-}
-// progress is now MontyComplete
-console.log(progress.output) // 20
-Error Handling
-import { Monty, MontySyntaxError, MontyRuntimeError, MontyTypingError } from '@pydantic/monty'
-
-try {
-  const m = new Monty('1 / 0')
-  m.run()
-} catch (error) {
-  if (error instanceof MontySyntaxError) {
-    console.log('Syntax error:', error.message)
-  } else if (error instanceof MontyRuntimeError) {
-    console.log('Runtime error:', error.message)
-    console.log('Traceback:', error.traceback())
-  } else if (error instanceof MontyTypingError) {
-    console.log('Type error:', error.displayDiagnostics())
-  }
-}
-Type Checking
-const m = new Monty('"hello" + 1')
-try {
-  m.typeCheck()
-} catch (error) {
-  if (error instanceof MontyTypingError) {
-    console.log(error.displayDiagnostics('concise'))
-  }
-}
-
-// Or enable during construction
-const m2 = new Monty('1 + 1', { typeCheck: true })
-Resource Limits
-const m = new Monty('1 + 1')
-const result = m.run({
-  limits: {
-    maxAllocations: 10000,
-    maxDurationSecs: 5,
-    maxMemory: 1024 * 1024, // 1MB
-    maxRecursionDepth: 100,
-  },
-})
-Serialization
-// Save parsed code to avoid re-parsing
-const m = new Monty('complex_code()')
-const data = m.dump()
-
-// Later, restore without re-parsing
-const m2 = Monty.load(data)
-const result = m2.run()
-
-// Snapshots can also be serialized
-const snapshot = m.start()
-if (snapshot instanceof MontySnapshot) {
-  const snapshotData = snapshot.dump()
-  // Later, restore and resume
-  const restored = MontySnapshot.load(snapshotData)
-  const result = restored.resume({ returnValue: 42 })
-}
-API Reference
-Monty Class
-constructor(code: string, options?: MontyOptions) - Parse Python code
-run(options?: RunOptions) - Execute and return the result
-start(options?: StartOptions) - Start iterative execution
-typeCheck(prefixCode?: string) - Perform static type checking
-dump() - Serialize to binary format
-Monty.load(data) - Deserialize from binary format
-scriptName - The script name (default: 'main.py')
-inputs - Declared input variable names
-MontyOptions
-scriptName?: string - Name used in tracebacks (default: 'main.py')
-inputs?: string[] - Input variable names
-typeCheck?: boolean - Enable type checking on construction
-typeCheckPrefixCode?: string - Code to prepend for type checking
-RunOptions
-inputs?: object - Input variable values
-limits?: ResourceLimits - Resource limits
-externalFunctions?: object - External function callbacks
-ResourceLimits
-maxAllocations?: number - Maximum heap allocations
-maxDurationSecs?: number - Maximum execution time in seconds
-maxMemory?: number - Maximum heap memory in bytes
-gcInterval?: number - Run GC every N allocations
-maxRecursionDepth?: number - Maximum call stack depth (default: 1000)
-MontySnapshot Class
-Returned by start() when execution pauses at an external function call.
-
-scriptName - The script being executed
-functionName - The external function being called
-args - Positional arguments
-kwargs - Keyword arguments
-resume(options: ResumeOptions) - Resume with return value or exception
-dump() / MontySnapshot.load(data) - Serialization
-MontyComplete Class
-Returned by start() or resume() when execution completes.
-
-output - The final result value
-Error Classes
-MontyError - Base class for all Monty errors
-MontySyntaxError - Syntax/parsing errors
-MontyRuntimeError - Runtime exceptions (with traceback())
-MontyTypingError - Type checking errors (with displayDiagnostics())
-Readme
-Keywords
-none
-Provenance
-Built and signed on
-GitHub Actions
-View build summary
-Source Commit
-
-github.com/pydantic/monty@61770e5
-Build File
-
-.github/workflows/ci.yml
-Public Ledger
-
-Transparency log entry
-Share feedback
-Package Sidebar
-Install
-npm i @pydantic/monty
-
-
-Repository
-github.com/pydantic/monty
-
-Homepage
-github.com/pydantic/monty#readme
-
-Weekly Downloads
-1,082
-
-Version
-0.0.8
-
-
-License
-MIT
-
-Unpacked Size
-78.5 kB
-
-Total Files
-7
-
-Last publish
-20 hours ago
-
-Collaborators
-viicos
-samuelcolvin
-pydantic-user
-petyosi
-Analyze security with SocketCheck bundle sizeView package healthExplore dependencies
-Report malware
-Footer
-Support
-Help
-Advisories
-Status
-Contact npm
-Company
-About
-Blog
-Press
-Terms & Policies
-Policies
-Terms of Use
-Code of Conduct
-Privacy
-Viewing @pydantic/monty version 0.0.8

package/ref-monty/pyproject.toml

@@ -1,162 +0,0 @@
-[project]
-name = "monty-workspace"
-version = "0"
-requires-python = ">=3.10"
-
-[tool.uv.workspace]
-members = ["crates/monty-python"]
-
-[dependency-groups]
-dev = [
-    "basedpyright>=1.34.0",
-    "maturin>=1.9.4,<2.0",
-    "mypy>=1.19.1",
-    "ruff>=0.14.7",
-    "duckdb>=1.0.0",
-    "httpx>=0.28.1",
-    "playwright>=1.58.0",
-    "beautifulsoup4>=4.14.3",
-    "logfire>=4.25.0",
-    "devtools>=0.12.2",
-    "pydantic-ai-slim[anthropic,openai]>=1.63.0",
-]
-
-# https://beta.ruff.rs/docs/configuration/
-[tool.ruff]
-line-length = 120
-include = [
-    "scripts/**/*.py",
-    "crates/**/*.py",
-    "crates/**/*.pyi",
-]
-# Exclude files with intentional syntax errors or special formatting requirements
-extend-exclude = [
-    "crates/monty/test_cases/nonlocal__error_module_level.py",
-    "crates/monty/test_cases/traceback__nonlocal_module_scope.py",
-    # These files test specific quote styles in error messages and must not be reformatted
-    "crates/monty/test_cases/type__float_repr_newline.py",
-    "crates/monty/test_cases/type__float_repr_both_quotes.py",
-]
-
-[tool.ruff.lint]
-extend-select = [
-    "Q",      # https://docs.astral.sh/ruff/rules/#flake8-quotes-q
-    "RUF100", # https://docs.astral.sh/ruff/rules/unused-noqa/
-    "I",      # https://docs.astral.sh/ruff/rules/#isort-i
-    "FA",     # https://docs.astral.sh/ruff/rules/#flake8-future-annotations-fa
-]
-flake8-quotes = { inline-quotes = "single", multiline-quotes = "double" }
-mccabe = { max-complexity = 14 }
-
-[tool.ruff.lint.isort]
-combine-as-imports = true
-known-first-party = ["pydantic_monty"]
-
-[tool.ruff.lint.per-file-ignores]
-"crates/monty/test_cases/*.py" = [
-    "E722", # bare except - needed for testing try/except with bare except clauses
-    "E711", # Comparison to `None` should be `cond is None`
-    "E712", # Comparison to True/False - needed for testing boolean behavior
-    "E714", # Test for object identity should be `is not`
-    "E721", # Use `is` and `is not` for type comparisons, or `isinstance()` for isinstance checks
-    "E731", # Do not assign a lambda expression, use a def - needed for testing lambda expressions
-    "F541", # f-string without any placeholders
-    "F632", # ignore replace `is` with `==` - we have lots of these tests
-    "F701", # break outside loop - needed for testing break error handling
-    "F702", # continue not properly in loop - needed for testing continue error handling
-    "F704", # await outside function - needed for testing top-level async/await
-    "F811", # Redefinition of unused variable
-    "F821", # traceback undefined call test intentionally uses undefined name
-    "F841", # unused variable - needed for testing exception variable cleanup
-    "F401", # Intentionally imports unknown typing constructs to test silent ignore behavior
-    "F403", # star import test intentionally uses `from sys import *`
-    "E402", # Typing test file has multiple import sections to test different import patterns
-]
-
-"crates/monty-typeshed/vendor/typeshed/stdlib/**/*.pyi" = [
-    "F403", # unable to detect undefined names
-    "F821", # Undefined name
-]
-"crates/monty-type-checking/tests/good_types.py" = [
-    "F704", # await outside function - needed for testing top-level async/await
-]
-
-[tool.ruff.format]
-docstring-code-format = true
-quote-style = "single"
-
-[tool.pyright]
-pythonVersion = "3.14"
-typeCheckingMode = "strict"
-reportUnnecessaryTypeIgnoreComment = true
-include = ["scripts", "crates/monty/test_cases", "crates/monty-python", "crates/monty-type-checking", "examples"]
-exclude = [
-    "crates/monty-type-checking/tests/bad_types.py",
-    "crates/monty-type-checking/tests/reveal_types.py",
-    # break/continue outside loop tests intentionally test error handling
-    "crates/monty/test_cases/loop__break_outside_error.py",
-    "crates/monty/test_cases/loop__continue_outside_error.py",
-    "crates/monty/test_cases/loop__break_in_function_error.py",
-    "crates/monty/test_cases/loop__continue_in_function_error.py",
-    "crates/monty/test_cases/loop__break_in_if_error.py",
-    "crates/monty/test_cases/loop__continue_in_if_error.py",
-    "scripts/startup_performance.py",
-    "examples/web_scraper/example_code.py",
-]
-venv = ".venv"
-
-# we include tests cases in type checking then switch off all rules that break
-# so the files don't show as errors in the IDE
-[[tool.pyright.executionEnvironments]]
-root = "crates/monty/test_cases"
-reportUnusedExpression = false
-reportOperatorIssue = false
-reportGeneralTypeIssues = false
-reportMissingImports = false
-reportUnknownMemberType = false
-reportUnnecessaryComparison = false
-reportUnnecessaryIsInstance = false
-reportUnknownArgumentType = false
-reportUnknownVariableType = false
-reportUnhashable = false
-reportCallIssue = false
-reportUnknownParameterType = false
-reportMissingParameterType = false
-reportUnknownLambdaType = false
-reportArgumentType = false
-# iter mode tests use external functions defined in the test runner
-reportUndefinedVariable = false
-# loop variable persistence tests have "possibly unbound" variables
-reportPossiblyUnboundVariable = false
-# exception variable cleanup tests intentionally access unbound variables
-reportUnboundVariable = false
-# attribute error tests intentionally access/assign non-existent attributes
-reportAttributeAccessIssue = false
-# unused variables and imports are fine in test cases
-reportUnusedVariable = false
-reportUnusedImport = false
-reportAssignmentType = false
-reportFunctionMemberAccess = false
-# ~bool is deprecated in Python 3.16 but valid in 3.14
-reportDeprecated = false
-# star import test intentionally uses `from sys import *`
-reportWildcardImportFromLibrary = false
-# some test cases intentionally exercise invalid index assignment/runtime error paths
-reportIndexIssue = false
-
-[[tool.pyright.executionEnvironments]]
-root = "crates/monty-type-checking"
-reportUnnecessaryIsInstance = false
-
-[tool.codespell]
-# Ref: https://github.com/codespell-project/codespell#using-a-config-file
-ignore-words-list = 'crate,NotIn,ser'
-skip = [
-    "Cargo.lock",
-    "crates/monty-js/package-lock.json",
-    "crates/monty-typeshed/vendor/typeshed/stdlib/*",
-    "crates/monty/src/types/str.rs",
-]
-
-[tool.inline-snapshot]
-format-command="ruff format --stdin-filename {filename}"

package/ref-monty/scripts/check_imports.py

@@ -1,91 +0,0 @@
-#!/usr/bin/env python3
-"""Check that all `use` statements in Rust files are at the top of the file.
-
-Exits with code 1 if any misplaced imports are found.
-"""
-
-import re
-import sys
-from pathlib import Path
-
-
-def check_file(path: Path) -> list[str]:
-    """Check a single Rust file for misplaced imports.
-
-    Returns a list of error messages for any `use` statements found after
-    the import block (i.e., after non-import code has started).
-
-    Handles these valid patterns:
-    - mod declarations followed by pub use re-exports
-    - use statements inside mod/fn/impl blocks (tracked via brace depth)
-    """
-    errors: list[str] = []
-    past_imports = False
-    brace_depth = 0
-
-    # Patterns that are allowed before/during the import block at top level
-    allowed_pattern = re.compile(
-        r'^(\s*$'  # empty lines
-        r'|//[!/]'  # doc comments (//! or ///)
-        r'|//'  # regular comments
-        r'|/\*'  # block comment start
-        r'|\*'  # block comment continuation
-        r'|\*/'  # block comment end
-        r'|#\['  # attributes
-        r'|#!\['  # inner attributes
-        r'|pub use '  # pub use statements
-        r'|pub\(crate\) use '  # pub(crate) use statements
-        r'|use '  # use statements
-        r'|(pub )?mod (r#)?\w+;'  # mod declarations (mod foo; or pub mod r#type;)
-        r'|\}'  # closing braces
-        r')'
-    )
-
-    use_pattern = re.compile(r'^use |^pub use ')
-
-    with open(path) as f:
-        for line_num, line in enumerate(f, 1):
-            stripped = line.strip()
-
-            # Track brace depth to detect when we're inside a block
-            brace_depth += line.count('{') - line.count('}')
-
-            # Only check top-level imports (brace_depth == 0)
-            if brace_depth > 0:
-                continue
-
-            # Skip allowed lines if we haven't passed the import block
-            if not past_imports and allowed_pattern.match(stripped):
-                continue
-
-            # Once we see a non-allowed line at top level, we're past imports
-            if not past_imports and stripped:
-                past_imports = True
-
-            # Check for use statements after the import block at top level
-            if past_imports and use_pattern.match(stripped):
-                errors.append(f'{path}:{line_num}: {stripped}')
-
-    return errors
-
-
-def main() -> int:
-    """Find all Rust files and check for misplaced imports."""
-    all_errors: list[str] = []
-
-    for rs_file in Path('./crates').rglob('*.rs'):
-        all_errors += check_file(rs_file)
-
-    if all_errors:
-        print('Error: Found `use` statements outside the import block:', file=sys.stderr)
-        print('Move these imports to the top of the file.', file=sys.stderr)
-        print(file=sys.stderr)
-        for error in all_errors:
-            print(error, file=sys.stderr)
-        return 1
-
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main())