{"id":"0135aefd-fb2d-433d-aa84-9e6fc53c2887","entityType":"agent","slug":"clawhub-sdk-team-alibabacloud-odps-maxframe-coding","name":"Alibabacloud Odps Maxframe Coding","canonicalUrl":"https://www.xpersona.co/agent/clawhub-sdk-team-alibabacloud-odps-maxframe-coding","canonicalPath":"/agent/clawhub-sdk-team-alibabacloud-odps-maxframe-coding","generatedAt":"2026-10-09T12:57:01.843Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"editorial-content","verified":true,"confidence":"high","updatedAt":"2026-10-09T05:30:50.389Z","emptyReason":null},"description":"Use this skill for MaxFrame SDK development and documentation navigation on Alibaba Cloud MaxCompute (ODPS). Helps answer MaxFrame API, concept, official exa... Skill: Alibabacloud Odps Maxframe Coding Owner: sdk-team Summary: Use this skill for MaxFrame SDK development and documentation navigation on Alibaba Cloud MaxCompute (ODPS). Helps answer MaxFrame API, concept, official exa... Tags: latest:0.0.2 Version history: v0.0.2 | 2026-06-02T09:40:39.558Z | auto - Added support for MaxFrame documentation and API navigation—users can now ask questions about MaxFrame APIs, conce","descriptionLabel":"Technical summary","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. 4.4K downloads reported by the source. Last updated 10/9/2026.","installCommand":"clawhub skill install s173swjet2yrebzqrp6hjkvmy583mxef:alibabacloud-odps-maxframe-coding","sourceUrl":"https://clawhub.ai/sdk-team/alibabacloud-odps-maxframe-coding","homepage":"https://clawhub.ai/sdk-team/skills/alibabacloud-odps-maxframe-coding","primaryLinks":[{"label":"View on ClawHub","url":"https://clawhub.ai/sdk-team/alibabacloud-odps-maxframe-coding","kind":"source"},{"label":"Homepage","url":"https://clawhub.ai/sdk-team/skills/alibabacloud-odps-maxframe-coding","kind":"homepage"}],"safetyScore":84,"overallRank":62,"popularityScore":73,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"Use this skill for MaxFrame SDK development and documentation navigation on Alibaba Cloud MaxCompute (ODPS). Helps answer MaxFrame API, concept, official exa..."},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-10-09T05:30:50.389Z","emptyReason":null},"protocols":[{"protocol":"OPENCLEW","label":"OpenClaw","status":"self-declared","notes":"Declared in the public agent profile."}],"capabilities":[],"verifiedCount":0,"selfDeclaredCount":1,"capabilityMatrix":{"rows":[{"key":"OPENCLEW","type":"protocol","support":"unknown","confidenceSource":"profile","notes":"Listed on profile"}],"flattenedTokens":"protocol:OPENCLEW|unknown|profile"}},"adoption":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-09T05:30:50.389Z","emptyReason":null},"stars":null,"forks":null,"downloads":4387,"packageName":null,"latestVersion":"0.0.2","tractionLabel":"4.4K downloads"},"release":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-09T05:30:50.388Z","emptyReason":null},"lastUpdatedAt":"2026-10-09T05:30:50.389Z","lastCrawledAt":"2026-10-09T05:30:50.388Z","lastIndexedAt":null,"nextCrawlAt":"2026-10-10T05:30:50.388Z","lastVerifiedAt":null,"highlights":[{"version":"0.0.2","createdAt":"2026-06-02T09:40:39.558Z","changelog":"- Added support for MaxFrame documentation and API navigation—users can now ask questions about MaxFrame APIs, concepts, usage, and compatibility. - Enhanced scenario detection logic to handle documentation-only queries (Scenario 0), in addition to coding, debugging, and custom runtime scenarios. - Updated workflow and rules to clearly separate documentation navigation from code implementation. - Improved operator selection logic, allowing bypass when the user explicitly names the operation. - Removed outdated skill-card.md and refined documentation for conciseness and accuracy.","fileCount":984,"zipByteSize":1260196},{"version":"0.0.1","createdAt":"2026-04-23T11:27:20.211Z","changelog":"alibabacloud-odps-maxframe-coding v0.0.1 - Initial release of the MaxFrame coding skill for Alibaba Cloud MaxCompute (ODPS). - Provides workflows for creating, debugging, and customizing MaxFrame-based data processing jobs. - Includes mandatory scenario detection and operator confirmation before code implementation. - Features best practices for session management, error handling, and guidance on remote/local debugging and custom runtime builds. - Documentation optimized for clarity and step-by-step user support.","fileCount":984,"zipByteSize":1258674}]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install s173swjet2yrebzqrp6hjkvmy583mxef:alibabacloud-odps-maxframe-coding","setupComplexity":"low","setupSteps":["Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.","Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data."],"contract":{"contractStatus":"missing","authModes":[],"requires":[],"forbidden":[],"supportsMcp":false,"supportsA2a":false,"supportsStreaming":false,"inputSchemaRef":null,"outputSchemaRef":null,"dataRegion":null,"contractUpdatedAt":null,"sourceUpdatedAt":null,"freshnessSeconds":null},"invocationGuide":{"preferredApi":{"snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/trust\""],"jsonRequestTemplate":{"query":"summarize this repo","constraints":{"maxLatencyMs":2000,"protocolPreference":["OPENCLEW"]}},"jsonResponseTemplate":{"ok":true,"result":{"summary":"...","confidence":0.9},"meta":{"source":"CLAWHUB","generatedAt":"2026-10-09T12:57:01.840Z"}},"retryPolicy":{"maxAttempts":3,"backoffMs":[500,1500,3500],"retryableConditions":["HTTP_429","HTTP_503","NETWORK_TIMEOUT"]}},"endpoints":{"dossierUrl":"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-sdk-team-alibabacloud-odps-maxframe-coding/trust"}},"reliability":{"evidence":{"source":"runtime-metrics","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No trust, reliability, or runtime telemetry is available."},"trust":{"status":"unavailable","handshakeStatus":"UNKNOWN","verificationFreshnessHours":null,"reputationScore":null,"p95LatencyMs":null,"successRate30d":null,"fallbackRate":null,"attempts30d":null,"trustUpdatedAt":null,"trustConfidence":"unknown","sourceUpdatedAt":null,"freshnessSeconds":null},"decisionGuardrails":{"doNotUseIf":["Contract metadata is missing or unavailable for deterministic execution."],"safeUseWhen":[],"riskFlags":["missing_or_unavailable_contract","trust_data_unavailable","schema_references_missing"],"operationalConfidence":"low"},"executionMetrics":{"observedLatencyMsP50":null,"observedLatencyMsP95":null,"estimatedCostUsd":null,"uptime30d":null,"rateLimitRpm":null,"rateLimitBurst":null,"lastVerifiedAt":null,"verificationSource":null},"runtimeMetrics":{"successRate":null,"avgLatencyMs":null,"avgCostUsd":null,"hallucinationRate":null,"retryRate":null,"disputeRate":null,"p50Latency":null,"p95Latency":null,"lastUpdated":null}},"benchmarks":{"evidence":{"source":"no-benchmark-data","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No benchmark suites or observed failure patterns are available."},"suites":[],"failurePatterns":[]},"artifacts":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"high","updatedAt":"2026-10-09T05:30:50.389Z","emptyReason":null},"readme":"Skill: Alibabacloud Odps Maxframe Coding\n\nOwner: sdk-team\n\nSummary: Use this skill for MaxFrame SDK development and documentation navigation on Alibaba Cloud MaxCompute (ODPS). Helps answer MaxFrame API, concept, official exa...\n\nTags: latest:0.0.2\n\nVersion history:\n\nv0.0.2 | 2026-06-02T09:40:39.558Z | auto\n\n- Added support for MaxFrame documentation and API navigation—users can now ask questions about MaxFrame APIs, concepts, usage, and compatibility.\n- Enhanced scenario detection logic to handle documentation-only queries (Scenario 0), in addition to coding, debugging, and custom runtime scenarios.\n- Updated workflow and rules to clearly separate documentation navigation from code implementation.\n- Improved operator selection logic, allowing bypass when the user explicitly names the operation.\n- Removed outdated skill-card.md and refined documentation for conciseness and accuracy.\n\nv0.0.1 | 2026-04-23T11:27:20.211Z | auto\n\nalibabacloud-odps-maxframe-coding v0.0.1\n\n- Initial release of the MaxFrame coding skill for Alibaba Cloud MaxCompute (ODPS).\n- Provides workflows for creating, debugging, and customizing MaxFrame-based data processing jobs.\n- Includes mandatory scenario detection and operator confirmation before code implementation.\n- Features best practices for session management, error handling, and guidance on remote/local debugging and custom runtime builds.\n- Documentation optimized for clarity and step-by-step user support.\n\nArchive index:\n\nArchive v0.0.2: 984 files, 1260196 bytes\n\nFiles: assets/examples/ai_function_basic.py (2263b), assets/examples/complex_struct_arrow.py (3120b), assets/examples/complex_struct.py (2339b), assets/examples/dlf_table_write_basic.py (1788b), assets/examples/dlf_table_write_with_pk.py (2438b), assets/examples/fs_mount_example.py (7144b), assets/examples/gpu_unit_dpe_processing.py (2819b), assets/examples/groupby_batch_processing.py (2577b), assets/examples/oss_multi_mount.py (3714b), references/common-workflow.md (7542b), references/installation.md (6623b), references/local-debug-guide.md (10586b), references/maxframe-client-docs/getting_started/comparison/index.md (220b), references/maxframe-client-docs/getting_started/comparison/pyodps_df.md (11129b), references/maxframe-client-docs/getting_started/index.md (730b), references/maxframe-client-docs/getting_started/installation.md (3228b), references/maxframe-client-docs/getting_started/overview.md (307b), references/maxframe-client-docs/getting_started/tutorials/10min.md (8169b), references/maxframe-client-docs/getting_started/tutorials/index.md (66b), references/maxframe-client-docs/index.md (341b), references/maxframe-client-docs/reference/dataframe/frame.md (41870b), references/maxframe-client-docs/reference/dataframe/general_functions.md (3246b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.concat.md (6928b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.abs.md (57b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.add_prefix.md (1407b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.add_suffix.md (1406b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.add.md (4741b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.agg.md (2157b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.aggregate.md (2169b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.align.md (5363b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.all.md (117b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.any.md (117b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.append.md (2730b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.apply.md (7662b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.applymap.md (2629b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.assign.md (2176b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.astype.md (2930b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.at_time.md (1625b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.at.md (1345b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.between_time.md (2565b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.clip.md (2882b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.columns.md (74b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.combine_first.md (1675b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.combine.md (3466b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.compare.md (4483b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.convert_dtypes.md (4784b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.copy.md (76b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.corr.md (1753b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.corrwith.md (1589b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.count.md (107b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.cov.md (4159b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.describe.md (6057b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.diff.md (2292b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.div.md (4758b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.dot.md (2302b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.drop_duplicates.md (1372b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.drop.md (4449b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.droplevel.md (1575b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.dropna.md (3780b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.dtypes.md (932b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.duplicated.md (2606b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.eq.md (4809b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.eval.md (2885b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.ewm.md (3931b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.expanding.md (1480b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.fillna.md (3701b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.filter.md (2200b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.first_valid_index.md (1587b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.floordiv.md (4765b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.from_dict.md (3039b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.from_records.md (3119b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.ge.md (4825b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.groupby.md (2662b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.gt.md (4812b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.head.md (1512b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.iat.md (1370b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.idxmax.md (1985b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.idxmin.md (1988b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.iloc.md (3743b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.index.md (70b) (+584 more)\n\nFile v0.0.2:references/common-workflow.md\n\n# Common Workflow Complete Guide\n\nDetailed guide for the complete MaxFrame development workflow with comprehensive examples.\n\n## Session Setup Patterns\n\n### Pattern 1: Auto-detect (DataWorks/MaxCompute Notebook)\n\n```python\nimport os\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\n# Auto-detect from environment (preferred in DataWorks/MaxCompute Notebook)\nsession = new_session()\n```\n\n### Pattern 2: Explicit ODPS Connection\n\n```python\nimport os\nimport dotenv\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\ndotenv.load_dotenv()\n\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOINT\"),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\nsession = new_session(o)\n```\n\n### Pattern 3: Production-ready Session\n\n```python\nimport logging\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\n\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\nsession = new_session()\ntry:\n logger.info(f\"Session created. Logview: {session.get_logview_address()}\")\n # Your operations\n ...\nfinally:\n session.destroy()\n logger.info(\"Session destroyed\")\n```\n\n## Reading Data Patterns\n\n### Pattern 1: Basic Table Read\n\n```python\n# Read from MaxCompute table\ndf = md.read_odps_table(\"table_name\")\n\n# Read with index column\ndf = md.read_odps_table(\"table_name\", index_col=\"id\")\n\n# With column selection\ndf = md.read_odps_table(\"table_name\", columns=['id', 'value', 'timestamp'])\n\n# With partition filter\ndf = md.read_odps_table(\"table_name\", partition='ds=2024-01-01')\n```\n\n### Pattern 2: SQL Query Read\n\n```python\n# Read from SQL query with filters\ndf = md.read_odps_query(\n \"SELECT * FROM table WHERE date >= '2024-01-01' AND status = 'active'\"\n)\n\n# Complex SQL with joins\ndf = md.read_odps_query(\n \"SELECT a.*, b.value FROM table_a a JOIN table_b b ON a.id = b.id\"\n)\n```\n\n### Pattern 3: Sample Data Construction\n\nWhen user doesn't provide input table name, construct pandas DataFrame:\n\n```python\nimport pandas as pd\nimport numpy as np\n\n# Time series analysis example\nexample_pd_df = pd.DataFrame({\n 'timestamp': pd.date_range('2026-01-01', periods=1000, freq='H'),\n 'metric_name': np.random.choice(['cpu', 'memory', 'disk'], 1000),\n 'value': np.random.randn(1000) * 10 + 50,\n 'host_id': np.random.choice(['host1', 'host2', 'host3'], 1000)\n})\n\n# Load into MaxFrame\ndf = md.read_pandas(example_pd_df)\n```\n\n**Key guidelines for sample data:**\n- Match data types and structure to job requirements\n- Use realistic value ranges for the domain\n- Include 100-1000 rows to demonstrate logic\n- Use descriptive column names matching operations\n\n## Operator Selection Workflow\n\n### Step 1: Identify Required Operations\n\nBreak down the task into specific operations needed:\n- Filtering\n- Grouping\n- Aggregation\n- Transformation\n- Merging\n- Sorting\n\n### Step 2: Find MaxFrame Operators\n\nUse operator-selector agent or script:\n\n```bash\n# Search for operators by task description\npython scripts/lookup_operator.py search \"time series resampling\"\n\n# Check if a specific operator exists\npython scripts/lookup_operator.py info apply_chunk\n\n# Get detailed operator information\npython scripts/lookup_operator.py info groupby\n```\n\n### Step 3: Present Options to User\n\n```\nFor your data aggregation task, I've identified these options:\n\n1. `groupby().agg()` - Standard pandas-compatible approach\n - Pros: Familiar API, good for standard aggregations\n - Cons: May be slow for large datasets with custom logic\n\n2. `mf.apply_chunk()` - For custom aggregation with large datasets\n - Pros: Efficient batch processing, custom logic support\n - Cons: More complex, requires batch size tuning\n\nWhich approach do you prefer, or would you like me to explore other options?\n```\n\n### Step 4: Get User Confirmation\n\n**MANDATORY:** Do not proceed without user confirmation.\n\n## Processing Patterns\n\n### Pattern 1: Standard pandas Operations\n\n```python\n# Filter\nfiltered = df[df['column'] > 10]\n\n# GroupBy and aggregate\nresult = df.groupby('category').agg({'value': 'sum'})\n\n# Add columns\ndf['new_col'] = df['col1'] + df['col2']\n\n# Sort\ndf_sorted = df.sort_values('column')\n\n# Merge\ndf_merged = df1.merge(df2, on='key')\n\n# Multiple aggregations\nresult = df.groupby('category').agg({\n 'value': ['sum', 'mean', 'count'],\n 'price': 'max'\n})\n```\n\n### Pattern 2: Batch Processing (Large Datasets)\n\n```python\ndef process_batch(chunk):\n # Custom processing logic\n return chunk * 2\n\nresult = df.mf.apply_chunk(\n process_batch,\n batch_rows=1024, # Tune batch size for performance\n output_type='dataframe'\n)\n```\n\n### Pattern 3: UDF with Resource Allocation\n\n```python\nfrom maxframe.udf import with_running_options\n\n@with_running_options(engine=\"dpe\", cpu=2, memory=4)\ndef process_batch(batch):\n # CRITICAL: memory=4 means 4 GB, NOT 4 MB\n return batch * 2\n\nresult = df.mf.apply_chunk(process_batch)\n```\n\n## Writing Data Patterns\n\n### Pattern 1: Write to MaxCompute Table\n\n```python\n# Write to MaxCompute table\nmd.to_odps_table(df, \"output_table\", overwrite=True).execute()\n```\n\n### Pattern 2: Write to DLF External Table\n\n```python\nfrom maxframe import options\n\n# Enable DLF support\noptions.sql.settings = {\n \"odps.maxframe.resolve_dlf_tables\": \"true\"\n}\n\nmd.to_odps_table(df, \"dlf_table\").execute()\n```\n\n### Pattern 3: Multiple Output Tables\n\n```python\ntry:\n md.to_odps_table(df1, \"output_table1\").execute()\n md.to_odps_table(df2, \"output_table2\").execute()\nfinally:\n session.destroy()\n```\n\n## Execution and Cleanup Patterns\n\n### Pattern 1: Basic Execution\n\n```python\n# Execute operations (required for lazy execution)\nresult.execute()\n\n# Destroy session when done\nsession.destroy()\n```\n\n### Pattern 2: Safe Cleanup (Production)\n\n```python\ntry:\n # Execute operations\n result.execute()\nfinally:\n # Destroy session (always runs, even on error)\n session.destroy()\n```\n\n### Pattern 3: Comprehensive Cleanup\n\n```python\nimport logging\n\nlogger = logging.getLogger(__name__)\n\ntry:\n result.execute()\n logger.info(\"Execution successful\")\nexcept Exception as e:\n logger.error(f\"Execution failed: {e}\")\n raise\nfinally:\n try:\n session.destroy()\n logger.info(\"Session destroyed\")\n except Exception as cleanup_error:\n logger.warning(f\"Cleanup error: {cleanup_error}\")\n```\n\n## Verification Pattern\n\nUse `py_compile` to test generated job script:\n\n```bash\npython -m py_compile your_script.py\n```\n\n## Complete Example Pipeline\n\n```python\nimport os\nimport logging\nimport dotenv\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\n\ndotenv.load_dotenv()\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\n# Setup session\nsession = new_session()\ntry:\n logger.info(f\"Session created. Logview: {session.get_logview_address()}\")\n\n # Read data\n df = md.read_odps_table(\"source_table\", columns=['id', 'value', 'category'])\n\n # Process (after confirming operators with user)\n filtered = df[df['value'] > 100]\n result = filtered.groupby('category').agg({'value': 'sum'})\n\n # Write output\n md.to_odps_table(result, \"output_table\", overwrite=True).execute()\n\n logger.info(\"Job completed successfully\")\n logger.info(f\"Final Logview: {session.get_logview_address()}\")\n\nfinally:\n session.destroy()\n logger.info(\"Session destroyed\")\n```\n\nFile v0.0.2:references/installation.md\n\n# MaxFrame Installation Guide\n\nThis guide provides step-by-step instructions for installing and configuring MaxFrame for distributed data processing on MaxCompute.\n\n## Table of Contents\n\n- [Prerequisites](#prerequisites)\n- [Dependencies](#dependencies)\n- [Environment Configuration](#environment-config)\n - [Required Environment Variables](#required-environment-variables)\n - [Setting Environment Variables](#setting-environment-variables)\n - [Find Your MaxCompute Endpoint](#find-your-maxcompute-endpoint)\n- [Installation Verification](#installation-verification)\n- [Session Setup](#session-setup)\n - [Manual Session Creation](#manual-session-creation)\n - [Auto-Detect from Environment](#auto-detect-from-environment)\n- [Troubleshooting](#troubleshooting)\n - [Common Issues](#common-issues)\n - [Getting Help](#getting-help)\n- [Next Steps](#next-steps)\n- [Cleanup](#cleanup)\n\n## Prerequisites\n\n- Python 3.7 or higher\n- MaxCompute (ODPS) account with valid credentials\n- Access to a MaxCompute project\n\n## Dependencies\n\nInstall the required Python packages:\n\n```bash\npip install maxframe -U\n```\n\nThe required packages are:\n\n- **maxframe** - MaxFrame SDK for distributed data processing\n- **pyodps** - ODPS Python SDK for MaxCompute access\n- **pandas** - Data manipulation library (for pandas-compatible APIs)\n\n## Environment Configuration\n\n### Required Environment Variables\n\nConfigure the following environment variables to authenticate with MaxCompute:\n\n| Variable | Description |\n|----------|-------------|\n| `ODPS_ACCESS_ID` | MaxCompute access ID (username) |\n| `ODPS_ACCESS_KEY` | MaxCompute access key (password) |\n| `ODPS_PROJECT` | MaxCompute project name |\n| `ODPS_ENDPOINT` | MaxCompute endpoint URL |\n\n### Setting Environment Variables\n\n#### Option 1: Set in Shell\n\n```bash\nexport ODPS_ACCESS_ID=\"your_access_id\"\nexport ODPS_ACCESS_KEY=\"your_access_key\"\nexport ODPS_PROJECT=\"your_project_name\"\nexport ODPS_ENDPOINT=\"your_endpoint\"\n```\n\n#### Option 2: Use .env File\n\nCreate a `.env` file in your project directory:\n\n```env\nODPS_ACCESS_ID=your_access_id\nODPS_ACCESS_KEY=your_access_key\nODPS_PROJECT=your_project_name\nODPS_ENDPOINT=your_endpoint\n```\n\nThen load the environment variables in Python:\n\n```python\nfrom dotenv import load_dotenv\n\nload_dotenv()\n```\n\n### Find Your MaxCompute Endpoint\n\nMaxCompute endpoints vary by region, check the [MaxCompute documentation](https://www.alibabacloud.com/help/zh/maxcompute/user-guide/endpoints?spm=a2c63.p38356.help-menu-search-27797.d_0) for the correct endpoint for your region.\n\n## Installation Verification\n\nVerify your installation by running the following Python script:\n\n```python\nimport os\nfrom dotenv import load_dotenv\nfrom odps import ODPS\nfrom maxframe.session import new_session\n\n# Load environment variables\nload_dotenv()\n\n# Create ODPS connection\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOINT\"),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n\n# Create MaxFrame session\nsession = new_session(o)\n\nprint(\"MaxFrame installation verified successfully!\")\nprint(f\"Connected to project: {o.project}\")\n\n# Destroy session when done\nsession.destroy()\n```\n\n## Session Setup\n\n### Manual Session Creation\n\nCreate a session with explicit credentials:\n\n```python\nimport os\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\n# Create ODPS connection\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOINT\"),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n\n# Create MaxFrame session\nsession = new_session(o)\n```\n\n### Auto-Detect from Environment\n\nIn environments like DataWorks or MaxCompute Notebook, ODPS credentials are automatically available:\n\n```python\nfrom maxframe.session import new_session\n\n# Auto-detects ODPS from environment\nsession = new_session()\n```\n\n\n## Troubleshooting\n\n### Common Issues\n\n#### Issue: Connection Authentication Failed\n\n**Symptoms**: Error message indicating invalid credentials or authentication failure.\n\n**Solutions**:\n- Verify all environment variables are set correctly\n- Check that your access key has not expired\n- Ensure you have the correct endpoint for your region\n- Verify your project name is accurate\n\n```bash\n# Test environment variables\necho $ODPS_ACCESS_ID\necho $ODPS_PROJECT\necho $ODPS_ENDPOINT\n```\n\n#### Issue: Package Installation Fails\n\n**Symptoms**: `pip install` fails with dependency conflicts or permission errors.\n\n**Solutions**:\n- Use a virtual environment to isolate dependencies:\n\n```bash\npython -m venv maxframe_env\nsource maxframe_env/bin/activate # On Windows: maxframe_env\\Scripts\\activate\npip install maxframe pyodps pandas --prefer-binary\n```\n\n- Upgrade pip before installing:\n\n```bash\npip install --upgrade pip\npip install maxframe pyodps pandas --prefer-binary\n```\n\n#### Issue: Session Creation Fails\n\n**Symptoms**: `new_session()` raises an exception.\n\n**Solutions**:\n- Verify network connectivity to the MaxCompute endpoint\n- Check firewall rules allow outbound connections\n- Ensure your MaxCompute account has the necessary permissions\n- Try the auto-detect method if available in your environment\n- Use VPC endpoint if you are in vpc networking\n\n#### Issue: Lazy Execution Not Working\n\n**Symptoms**: Operations appear to do nothing until `.execute()` is called.\n\n**Note**: This is expected behavior. MaxFrame uses lazy execution. Always call `.execute()` to trigger computation:\n\n```python\n# This does not execute immediately\nresult = df.groupby('category').sum()\n\n# Execute the computation\nresult.execute()\n```\n\n### Getting Help\n\nIf you encounter issues not covered here:\n\n1. Check the [MaxFrame Documentation](https://maxframe.readthedocs.io/en/latest/)\n2. Review the [MaxFrame Client Repository](https://github.com/aliyun/alibabacloud-odps-maxframe-client.git)\n3. Consult the sample code in `assets/examples/` for working examples\n4. Contact your MaxCompute administrator for account-specific issues\n\n## Next Steps\n\nAfter successful installation:\n\n1. Review the [MaxFrame Context Guide](maxframe-context.md) for comprehensive feature documentation\n2. Explore the [sample code](../assets/examples/) for working examples\n3. Start building your first MaxFrame program using the [Common Workflow](../SKILL.md#common-workflow)\n\n## Cleanup\n\nDestroy your session when done to free resources:\n\n```python\nsession.destroy()\n```\n\nFile v0.0.2:references/local-debug-guide.md\n\n# MaxFrame Local Debug Mode Guide\n\nThis guide provides comprehensive instructions for using MaxFrame's local debug mode, which enables offline UDF development with full IDE debugging support.\n\n## Overview\n\nMaxFrame Local Debug Mode is designed for data development engineers to debug UDF (User-Defined Functions) locally without connecting to remote MaxCompute services. It provides a seamless development experience with IDE breakpoint support for functions like `apply()` and `apply_chunk()`.\n\n## Core Value\n\n| Feature | Traditional Approach | Local Debug Mode |\n|---------|---------------------|------------------|\n| Breakpoint Debugging | ❌ Not supported | ✅ Full IDE support |\n| Remote Dependency | ❌ Requires cluster connection | ✅ Completely offline |\n| Debug Cycle | ❌ Submit to remote each time | ✅ Local immediate execution |\n| Code Changes | ❌ Multiple code versions | ✅ Same code for dev/prod |\n\n### Key Benefits\n\n1. **Zero-Configuration Startup**: Simply use `debug=True` or `debug=\"local\"` - no additional tools or services required\n2. **Completely Offline**: No dependency on network or remote cluster resources\n3. **Native IDE Support**: Breakpoints, variable inspection, step-by-step execution - all debugging capabilities preserved\n4. **Flexible Data Sources**: Support for in-memory data, local files, or MaxCompute tables\n5. **Seamless Production Switch**: Remove `debug=True` parameter and code runs directly in production\n\n## When to Use Local Debug Mode\n\nUse local debug mode when:\n- Developing UDF functions (`apply`, `apply_chunk`)\n- Need IDE breakpoints and step-by-step debugging\n- Want to debug offline without network access\n- Working on complex logic that requires iterative testing\n- Need to verify data transformation logic quickly\n\n**Use remote debug mode instead when:**\n- Testing with production-scale data on MaxCompute\n- Need to verify execution on actual cluster\n- Investigating runtime issues that require logview URLs\n- Debugging distributed execution problems\n\n## Quick Start\n\n### Prerequisites\n\n```bash\npip install --upgrade maxframe # Requires MaxFrame SDK 2.5.0 or later\n```\n\n### Basic Example\n\n```python\nfrom odps import ODPS\nfrom maxframe import new_session\nimport maxframe.dataframe as md\nimport pandas as pd\n\n# Initialize ODPS object\n# Note: In local debug mode, ODPS object is only used for schema validation\n# Actual credentials are not used for execution\no = ODPS(\n access_id=os.getenv('ODPS_ACCESS_ID', 'dummy_access_id'),\n secret_access_key=os.getenv('ODPS_ACCESS_KEY', 'dummy_secret_key'),\n project=os.getenv('ODPS_PROJECT', 'dummy_project'),\n endpoint=os.getenv('ODPS_ENDPOINT', 'dummy_endpoint'),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n\n# Enable local debug mode\nsession = new_session(o, debug=True)\n\n# Prepare sample data\ndf = md.DataFrame(pd.DataFrame({\n \"sales\": [5000, 8000, 12000, 3000],\n \"region\": [\"A\", \"B\", \"C\", \"D\"]\n}))\n\ndef calculate_commission(row):\n sales = row['sales']\n if sales > 10000: # Set breakpoint here\n rate = 0.15\n print(rate)\n elif sales > 5000: # Set breakpoint here\n rate = 0.10\n print(rate)\n else:\n rate = 0.05\n return sales * rate\n\n# Execute and get results\nresult = df.apply(calculate_commission, axis=1).execute().fetch()\nprint(result)\n```\n\n## Key Features\n\n### 1. Zero-Configuration Startup\n\nSimply add `debug=True` or `debug=\"local\"` when creating a session:\n\n```python\n# Local debug mode\nsession = new_session(o, debug=True)\n# or\nsession = new_session(o, debug=\"local\")\n\n# Production mode (just remove debug parameter)\nsession = new_session(o)\n```\n\n### 2. IDE-Friendly Debugging\n\n- **Supported IDEs**: PyCharm, VSCode, and other mainstream IDEs, as well as DataWorks Notebook\n- **Breakpoints**: Set breakpoints anywhere in your UDF functions\n- **Step-by-Step Execution**: Use F5/F6/F7/F8 to navigate through code\n- **Variable Inspection**: View and modify variables during debugging\n- **Debugging Experience**: Identical to local Python development\n\n### 3. Multiple Data Sources\n\n| Data Source Type | Access Method | Use Case |\n|-----------------|---------------|----------|\n| In-Memory Data | `md.DataFrame(pd.DataFrame())` | Quick logic validation |\n| MaxCompute Table | `md.read_odps_table()` | Real data testing |\n| Local Files | `pd.read_csv()` and other native Pandas interfaces | Offline development |\n\n**Example with different data sources:**\n\n```python\n# 1. In-memory data (fastest for testing)\nimport pandas as pd\ndf = md.DataFrame(pd.DataFrame({\n \"col1\": [1, 2, 3],\n \"col2\": [\"a\", \"b\", \"c\"]\n}))\n\n# 2. MaxCompute table (real data)\ndf = md.read_odps_table(\"your_table_name\")\n\n# 3. Local file (offline development)\nlocal_df = pd.read_csv(\"local_data.csv\")\ndf = md.read_pandas(local_df)\n```\n\n### 4. Code Compatibility\n\nDebugging code is identical to production code. Simply remove the `debug` parameter when deploying:\n\n```python\n# Development environment\nsession = new_session(o, debug=True)\n# ... your code ...\n\n# Production environment\nsession = new_session(o)\n# ... same code ...\n```\n\n## Application Scenarios\n\n| Scenario | Description |\n|----------|-------------|\n| UDF Logic Development | Real-time debugging and verification when writing complex business logic |\n| Data Transformation Testing | Validate data cleaning and transformation rules |\n| Problem Investigation | Identify root causes of UDF execution exceptions |\n| Offline Development | Continue development work in environments without network access |\n\n## Important Considerations\n\n### 1. Performance Differences\n\nLocal debug mode is designed for development and verification. Performance characteristics differ from production environment:\n- Execution happens locally, not distributed\n- Performance is not representative of production cluster performance\n- Best suited for small-scale sample data\n\n### 2. Data Volume Limitations\n\nFor optimal debugging experience:\n- Use small-scale sample data (recommended: 100-1000 rows)\n- Large datasets may slow down local execution\n- Focus on logic correctness rather than performance\n\n### 3. Dependency Consistency\n\nEnsure local Python environment matches production:\n- Same Python version\n- Same package versions (maxframe, pandas, numpy, etc.)\n- Use `pip freeze > requirements.txt` to capture dependencies\n\n### 4. Sensitive Data Handling\n\nWhen debugging with MaxCompute tables:\n- Be aware of data permissions and access controls\n- Consider data masking for sensitive information\n- Use sample/partitioned data to limit exposure\n- Never commit sensitive credentials to version control\n\n## Common Debugging Patterns\n\n### Pattern 1: Breakpoint in Apply Function\n\n```python\ndef process_row(row):\n # Set breakpoint on this line\n value = row['column_name']\n\n if value > threshold:\n # Set breakpoint here to inspect condition\n result = transform(value)\n else:\n result = default_value\n\n return result\n\ndf = md.DataFrame(sample_data)\nresult = df.apply(process_row, axis=1).execute().fetch()\n```\n\n### Pattern 2: Debugging Apply_Chunk for Batch Processing\n\n```python\ndef process_batch(chunk):\n # Set breakpoint here to inspect entire chunk\n print(f\"Processing batch with {len(chunk)} rows\")\n\n # Debug data types\n print(f\"Chunk dtypes:\\n{chunk.dtypes}\")\n\n # Debug transformations\n chunk['new_col'] = chunk['col1'] * 2\n\n # Set breakpoint here to verify results\n return chunk\n\nresult = df.mf.apply_chunk(\n process_batch,\n batch_rows=100,\n output_type='dataframe'\n).execute().fetch()\n```\n\n### Pattern 3: Debugging with Print Statements\n\n```python\ndef debug_function(row):\n print(f\"Input row: {row.to_dict()}\")\n\n # Step 1\n intermediate = row['col1'] + row['col2']\n print(f\"After step 1: {intermediate}\")\n\n # Step 2\n result = intermediate * 2\n print(f\"Final result: {result}\")\n\n return result\n\n# Execute with debug output\nresult = df.apply(debug_function, axis=1).execute().fetch()\n```\n\n## Transitioning to Production\n\n### Steps to Deploy\n\n1. **Test Locally**: Develop and debug with local debug mode\n2. **Verify Logic**: Ensure all transformations work correctly\n3. **Remove Debug Parameter**: Change `new_session(o, debug=True)` to `new_session(o)`\n4. **Test on Cluster**: Run on MaxCompute with small dataset\n5. **Production Deploy**: Deploy to production environment\n\n### Code Checklist\n\nBefore deploying to production:\n- [ ] Remove `debug=True` parameter from session creation\n- [ ] Verify all data source paths are correct for production\n- [ ] Test with production-scale data on MaxCompute\n- [ ] Remove or reduce print statements used for debugging\n- [ ] Add proper error handling and logging\n- [ ] Verify resource quotas and permissions\n\n## Troubleshooting\n\n### Issue: IDE Breakpoints Not Triggering\n\n**Possible Causes:**\n- Session created without `debug=True`\n- Using incompatible IDE or debugger\n- Code not actually executing through apply/apply_chunk\n\n**Solutions:**\n- Verify `debug=True` in `new_session()`\n- Ensure you're using a supported IDE (PyCharm, VSCode)\n- Check that `.execute()` is called to trigger execution\n\n### Issue: Local Execution Too Slow\n\n**Possible Causes:**\n- Dataset too large for local debugging\n- Complex operations not optimized for local execution\n\n**Solutions:**\n- Reduce sample data size (use `df.head(100)` or sample)\n- Simplify operations for debugging purposes\n- Focus on specific problematic code sections\n\n### Issue: Results Differ from Production\n\n**Possible Causes:**\n- Data differences between sample and production data\n- Environmental differences (Python version, package versions)\n- Distributed vs. local execution semantics\n\n**Solutions:**\n- Verify data consistency between environments\n- Check Python and package versions match\n- Test on MaxCompute with `debug=False` to verify\n\n## Summary\n\nLocal debug mode provides a powerful development experience for MaxFrame UDF development:\n- Zero-configuration startup with `debug=True`\n- Full IDE debugging support with breakpoints\n- Flexible data source options\n- Seamless transition to production\n- Perfect for iterative UDF development\n\nUse local debug mode during development for rapid iteration, then switch to remote debug mode for cluster-based testing and validation.\n\n## Resources\n\n- **MaxFrame Context Guide**: `./maxframe-context.md` - Comprehensive MaxFrame features and workflows\n- **Interactive Coding Guide**: `./remote-debug-guide.md` - Remote debug mode with logview support\n- **Key Modules Reference**: `./key-modules.md` - DataFrame, Tensor, and ML operations\n\nFile v0.0.2:references/maxframe-client-docs/getting_started/comparison/index.md\n\n# Comparison with other tools\n\n* [Comparison with PyODPS DataFrame](pyodps_df.md)\n * [Object abstraction](pyodps_df.md#object-abstraction)\n * [Functions](pyodps_df.md#functions)\n * [Execution](pyodps_df.md#execution)\n\nFile v0.0.2:references/maxframe-client-docs/getting_started/comparison/pyodps_df.md\n\n# Comparison with PyODPS DataFrame\n\n[PyODPS DataFrame](https://pyodps.readthedocs.io/en/stable/df.html) is\na DataFrame-like package provided by MaxCompute as a part of PyODPS package.\nIt provides capability for Python data analyzers to query MaxCompute data\nwith a set of operators similar to pandas. Despite the similarity in operators,\nthe usage between two sets of APIs are quite different. It might not be easy\nfor a developer to dive deep into PyODPS DataFrame with knowledge about\npandas only.\n\nThough PyODPS DataFrame is still part of PyODPS, it is recommended to create\nnew applications with MaxFrame to enjoy its compatibility with pandas.\n\n## Object abstraction\n\nPyODPS DataFrame does not have indexes. This means that a majority of pandas\nAPIs with indexes cannot be used or not fully supported.\n\nFor instance, arithmetic operations in pandas relies on index alignment. That\nis, two DataFrames are aligned first, and then arithmetic operation is performed.\n\n```python\n>>> series1 = pd.Series([2, 1, 3], index=[1, 2, 4])\n>>> series2 = pd.Series([1, 5, 6], index=[1, 3, 4])\n>>> series1 + series2\n1 3.0\n2 NaN\n3 NaN\n4 9.0\ndtype: float64\n```\n\nHowever, when indexes are absent, this kind of operation is not supported.\n\nTo support this kind of operation, in MaxFrame, it is required to add an index\ncolumn to DataFrame or Series. If the index is absent, a default RangeIndex\nis added. Therefore the statement above can be supported.\n\nAnother huge difference between PyODPS DataFrame and MaxFrame is that in PyODPS\nDataFrame, representation of data objects and operators are mixed, and this\nmay confuse newcomers. For instance,\n\n```python\ndf = o.get_table('table_name').to_df() # df is a DataFrame instance\ndf2 = df[\"col1\", \"col2\"] # df2 is a CollectionExpr instance\n```\n\nIn the second line, `df2` is an instance of `CollectionExpr` which means\nit is an expression and different from a `DataFrame` instance. However, all\nDataFrame functions can be applied directly onto `df2` and there is nothing\ndifferent from `DataFrame` instance.\n\nIn MaxFrame, however, data objects and operators are defined separately. Data\nobjects users interact with are all instances of a few data classes, namely\n`DataFrame`, `Series` or `Index`. For the example above, now all\ninstances are DataFrame now.\n\n```python\ndf = md.read_odps_table('table_name') # df is a DataFrame instance\ndf2 = df[[\"col1\", \"col2\"]] # df2 is also a DataFrame instance\n```\n\n## Functions\n\nFunctions in PyODPS DataFrame are not fully compatible with pandas. Therefore\nto write code with PyODPS DataFrame, users need to read the documents first\nbefore start coding. However, the target of MaxFrame is to create a pandas-compatible\nAPI. Hence there are API differences between PyODPS DataFrame and MaxFrame.\nThese differences are listed below. Methods starts with `mf.` mean that these non-pandas\nmethods are added in MaxFrame to facilitate migrating from PyODPS DataFrame to MaxFrame.\nNote that you need to read API documents of these functions before rewriting your code.\n\n| PyODPS DataFrame API | MaxFrame API |\n|-------------------------------------|-------------------------------------------------|\n| DataFrame.append_id | Not needed. DataFrame index is added by default |\n| DataFrame.bloom_filter | Not implemented yet |\n| DataFrame.boxplot | DataFrame.plot.boxplot |\n| DataFrame.concat | maxframe.dataframe.concat |\n| DataFrame.describe | DataFrame.describe |\n| DataFrame.distinct | DataFrame.drop_duplicates |\n| DataFrame.except_ | DataFrame.merge with filter |\n| DataFrame.exclude | DataFrame.drop |\n| DataFrame.extract_kv | Not implemented yet |\n| DataFrame.hist | DataFrame.plot.hist |\n| DataFrame.inner_join | DataFrame.merge |\n| DataFrame.intersect | DataFrame.merge |\n| DataFrame.left_join | DataFrame.merge |\n| DataFrame.limit | DataFrame.head |\n| DataFrame.map_reduce | DataFrame.mf.map_reduce |\n| DataFrame.minmax_scale | Not implemented yet |\n| DataFrame.outer_join | DataFrame.merge |\n| DataFrame.persist | DataFrame.to_odps_table |\n| DataFrame.reshuffle | DataFrame.mf.reshuffle |\n| DataFrame.right_join | DataFrame.merge |\n| DataFrame.setdiff | DataFrame.merge |\n| DataFrame.split | Not implemented yet |\n| DataFrame.std_scale | Not implemented yet |\n| DataFrame.sort | DataFrame.sort_values |\n| DataFrame.switch | maxframe.dataframe.case_when |\n| DataFrame.to_kv | Not implemented yet |\n| DataFrame.union | maxframe.dataframe.concat |\n| DatetimeSequenceExpr.date | Series.dt.date |\n| DatetimeSequenceExpr.day | Series.dt.day |\n| DatetimeSequenceExpr.dayofweek | Series.dt.dayofweek |\n| DatetimeSequenceExpr.dayofyear | Series.dt.dayofyear |\n| DatetimeSequenceExpr.hour | Series.dt.hour |\n| DatetimeSequenceExpr.is_month_end | Series.dt.is_month_end |\n| DatetimeSequenceExpr.is_month_start | Series.dt.is_month_start |\n| DatetimeSequenceExpr.is_year_end | Series.dt.is_year_end |\n| DatetimeSequenceExpr.is_year_start | Series.dt.is_year_start |\n| DatetimeSequenceExpr.microsecond | Series.dt.microsecond |\n| DatetimeSequenceExpr.min | Series.dt.min |\n| DatetimeSequenceExpr.minute | Series.dt.minute |\n| DatetimeSequenceExpr.month | Series.dt.month |\n| DatetimeSequenceExpr.second | Series.dt.second |\n| DatetimeSequenceExpr.strftime | Series.dt.strftime |\n| DatetimeSequenceExpr.unix_timestamp | Not implemented yet |\n| DatetimeSequenceExpr.week | Series.dt.week |\n| DatetimeSequenceExpr.weekday | Series.dt.weekday |\n| DatetimeSequenceExpr.weekofyear | Series.dt.weekofyear |\n| DatetimeSequenceExpr.year | Series.dt.year |\n| SequenceExpr.degrees | np.degrees(Series) |\n| SequenceExpr.radians | np.radians(Series) |\n| SequenceExpr.tolist | Series.to_numpy |\n| SequenceExpr.to_datetime | maxframe.dataframe.to_datetime |\n| SequenceExpr.topk | Not implemented yet |\n| SequenceExpr.trunc | np.trunc(Series) |\n| SequenceExpr.hll_count | Not implemented yet |\n| StringSequenceExpr.capitalize | Series.str.capitalize |\n| StringSequenceExpr.contains | Series.str.contains |\n| StringSequenceExpr.count | Series.str.count |\n| StringSequenceExpr.endswith | Series.str.endswith |\n| StringSequenceExpr.find | Series.str.find |\n| StringSequenceExpr.len | Series.str.len |\n| StringSequenceExpr.ljust | Series.str.ljust |\n| StringSequenceExpr.lower | Series.str.lower |\n| StringSequenceExpr.lstrip | Series.str.lstrip |\n| StringSequenceExpr.pad | Series.str.pad |\n| StringSequenceExpr.repeat | Series.str.repeat |\n| StringSequenceExpr.replace | Series.str.replace |\n| StringSequenceExpr.rfind | Series.str.rfind |\n| StringSequenceExpr.rjust | Series.str.rjust |\n| StringSequenceExpr.rstrip | Series.str.rstrip |\n| StringSequenceExpr.slice | Series.str.slice |\n| StringSequenceExpr.startswith | Series.str.startswith |\n| StringSequenceExpr.strip | Series.str.strip |\n| StringSequenceExpr.swapcase | Series.str.swapcase |\n| StringSequenceExpr.title | Series.str.title |\n| StringSequenceExpr.translate | Series.str.translate |\n| StringSequenceExpr.upper | Series.str.upper |\n| StringSequenceExpr.zfill | Series.str.zfill |\n| StringSequenceExpr.isalnum | Series.str.isalnum |\n| StringSequenceExpr.isalpha | Series.str.isalpha |\n| StringSequenceExpr.isdigit | Series.str.isdigit |\n| StringSequenceExpr.isspace | Series.str.isspace |\n| StringSequenceExpr.islower | Series.str.islower |\n| StringSequenceExpr.isupper | Series.str.isupper |\n| StringSequenceExpr.istitle | Series.str.istitle |\n| StringSequenceExpr.isnumeric | Series.str.isnumeric |\n| StringSequenceExpr.isdecimal | Series.str.isdecimal |\n\n## Execution\n\nPyODPS DataFrame and MaxFrame both use lazy execution to leverage efficiency\nof code optimization. However, the way to invoke these jobs is changed.\n\nFile v0.0.2:references/maxframe-client-docs/getting_started/index.md\n\n\n\n# Getting Started\n\n* [Access and installation](installation.md)\n * [Enable MaxFrame for your MaxCompute project](installation.md#enable-maxframe-for-your-maxcompute-project)\n * [Install MaxFrame client locally](installation.md#install-maxframe-client-locally)\n * [Access MaxFrame with DataWorks](installation.md#access-maxframe-with-dataworks)\n * [Access MaxFrame with MaxCompute Notebook](installation.md#access-maxframe-with-maxcompute-notebook)\n* [Overview](overview.md)\n* [Getting started tutorials](tutorials/index.md)\n * [10 minutes to MaxFrame](tutorials/10min.md)\n* [Comparison with other tools](comparison/index.md)\n * [Comparison with PyODPS DataFrame](comparison/pyodps_df.md)\n\nFile v0.0.2:references/maxframe-client-docs/getting_started/installation.md\n\n# Access and installation\n\n## Enable MaxFrame for your MaxCompute project\n\nYou need to setup a MaxCompute project Before using MaxFrame. Please take a look at\n[here](https://www.alibabacloud.com/zh/product/maxcompute) for more information.\n\n#### NOTE\nCurrently MaxFrame is under trial. If you need to enable MaxFrame for your MaxCompute\nproject, please [fill the form to apply for trial](https://survey.aliyun.com/apps/zhiliao/m40AIrxhA?spm=a2c4g.11186623.0.0.a69340f2mJENKJ) here.\n\n## Install MaxFrame client locally\n\nAfter created your own MaxCompute project and enabled MaxFrame, you may install\nMaxFrame client with pip command:\n\n```bash\npip install maxframe\n```\n\nThen you can create a MaxCompute table, perform some transformation with MaxFrame\nand then store the result into another MaxCompute table.\n\n```python\nimport maxframe.dataframe as md\nfrom odps import ODPS\nfrom maxframe import new_session\n\n# create MaxCompute entrance object and test table\no = ODPS(\n access_id=os.getenv('ODPS_ACCESS_ID'),\n secret_access_key=os.getenv('ODPS_ACCESS_KEY'),\n project='your-default-project',\n endpoint='your-end-point',\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\ntable = o.create_table(\"test_source_table\", \"a string, b bigint\")\nwith table.open_writer() as writer:\n writer.write([\n [\"value1\", 0],\n [\"value2\", 1],\n ])\n\n# create maxframe session\nsession = new_session(o)\n\n# perform data transformation\ndf = md.read_odps_table(\"test_source_table\")\ndf[\"a\"] = \"prefix_\" + df[\"a\"]\nmd.to_odps_table(df, \"test_prefix_source_table\").execute()\n\n# destroy maxframe session\nsession.destroy()\n```\n\n## Access MaxFrame with DataWorks\n\nDataWorks provides task scheduling capability for MaxCompute projects. You can schedule\nand run MaxFrame job with DataWorks.\n\nTo run MaxFrame job with DataWorks, you need to create a PyODPS 3 node and write your code\ninside it. PyODPS nodes are executed with embedded MaxCompute accounts and project information,\nthus you may create your MaxFrame session directly.\n\n```python\nimport maxframe.dataframe as md\nfrom maxframe import new_session\n\n# create maxframe session\nsession = new_session(o)\n\n# perform data transformation\ndf = md.read_odps_table(\"test_source_table\")\ndf[\"a\"] = \"prefix_\" + df[\"a\"]\nmd.to_odps_table(df, \"test_prefix_source_table\").execute()\n\n# destroy maxframe session\nsession.destroy()\n```\n\n## Access MaxFrame with MaxCompute Notebook\n\n[MaxCompute Notebook](https://help.aliyun.com/zh/maxcompute/user-guide/maxcompute-notebook-instruction)\nalso provides MaxFrame package. It also provides MaxCompute account in environment variables\nin the notebook, thus account information is not needed.\n\n```python\nimport maxframe.dataframe as md\nfrom maxframe import new_session\n\n# create MaxCompute entrance object\no = ODPS(\n project='your-default-project',\n endpoint='your-end-point',\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n# create maxframe session\nsession = new_session(o)\n\n# perform data transformation\ndf = md.read_odps_table(\"test_source_table\")\ndf[\"a\"] = \"prefix_\" + df[\"a\"]\nmd.to_odps_table(df, \"test_prefix_source_table\").execute()\n\n# destroy maxframe session\nsession.destroy()\n```\n\nFile v0.0.2:references/maxframe-client-docs/getting_started/overview.md\n\n# Overview\n\nMaxFrame is a framework for large-scale data computation built on MaxCompute\nby Alibaba Cloud with API-compatibility for pandas. It intends to become\nan inplace replacement for Python users familiar with Numpy or Pandas APIs\nto utilize MaxCompute to run their code in a distributed environment.\n\nFile v0.0.2:references/maxframe-client-docs/getting_started/tutorials/10min.md\n\n# 10 minutes to MaxFrame\n\nHere, [movielens 100K](https://grouplens.org/datasets/movielens/100k/) is used\nas an example. Assume that three tables already exist, which are `maxframe_ml_100k_movies`\n(movie-related data), `maxframe_ml_100k_users` (user-related data), and\n`maxframe_ml_100k_ratings` (rating-related data).\n\nCreate a MaxFrame session object before starting the following steps:\n\n```python\nimport os\nfrom odps import ODPS\nfrom maxframe import new_session\n\n# Make sure environment variable ODPS_ACCESS_ID already set to Access Key ID of user\n# while environment variable ODPS_ACCESS_KEY set to Access Key Secret of user.\n# Not recommended to hardcode Access Key ID or Access Key Secret in your code.\no = ODPS(\n access_id=os.getenv('ODPS_ACCESS_ID'),\n secret_access_key=os.getenv('ODPS_ACCESS_KEY'),\n project='**your-project**',\n endpoint='**your-endpoint**',\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\nsession = new_session(o)\n```\n\nYou only need to use `read_odps_table` API to create a DataFrame object. For instance,\n\n```python\nimport maxframe.dataframe as md\n\nusers = md.read_odps_table('pyodps_ml_100k_users')\n```\n\nView columns of DataFrame and the types of the columns through the `dtypes` attribute,\nas shown in the following code:\n\n```python\n>>> users.dtypes\nuser_id int64\nage int64\nsex object\noccupation object\nzip_code object\ndtype: object\n```\n\nSimply view the representation of the object will automatically show the first and last\nrows of the DataFrame.\n\n```python\n>>> users\n user_id age sex occupation zip_code\n0 1 24 M technician 85711\n1 2 53 F other 94043\n2 3 23 M writer 32067\n3 4 24 M technician 43537\n4 5 33 F other 15213\n...\n5 6 42 M executive 98101\n6 7 57 M administrator 91344\n7 8 36 M administrator 05201\n8 9 29 M student 01002\n9 10 53 M lawyer 90703\n```\n\nYou can use the head method to obtain the first N data records for easy and quick data\npreview. For example:\n\n```python\n>>> users.head(10).execute().fetch()\n user_id age sex occupation zip_code\n0 1 24 M technician 85711\n1 2 53 F other 94043\n2 3 23 M writer 32067\n3 4 24 M technician 43537\n4 5 33 F other 15213\n5 6 42 M executive 98101\n6 7 57 M administrator 91344\n7 8 36 M administrator 05201\n8 9 29 M student 01002\n9 10 53 M lawyer 90703\n```\n\nYou can add a filter on the columns if you do not want to view all of them. For example:\n\n```python\n>>> users[['user_id', 'age']].head(5).execute().fetch()\n user_id age\n0 1 24\n1 2 53\n2 3 23\n3 4 24\n4 5 33\n```\n\nYou can also drop several columns. For example:\n\n```python\n>>> users.drop(columns=['zip_code', 'age']).head(5)\n user_id sex occupation\n0 1 M technician\n1 2 F other\n2 3 M writer\n3 4 M technician\n4 5 F other\n```\n\nWhen excluding some columns, you may want to obtain new columns through computation.\nFor example, add the sex_bool attribute and set it to True if sex is Male. Otherwise,\nset it to False. For example:\n\n```python\n>>> users = users.drop(['zip_code', 'sex'])\n>>> users[\"sex_bool\"] = users.sex == \"M\"\n>>> users.head(5).execute().fetch()\n user_id age occupation sex_bool\n0 1 24 technician True\n1 2 53 other False\n2 3 23 writer True\n3 4 24 technician True\n4 5 33 other False\n```\n\nObtain the number of persons at age of 20 to 25, as shown in the following code:\n\n```python\n>>> users[users.age.between(20, 25)].count().execute().fetch()\n195\n```\n\nObtain the numbers of male and female users, as shown in the following code:\n\n```python\n>>> users.groupby(users.sex).user_id.size()\nF 273\nM 670\ndtype: int64\n```\n\nTo divide users by job, obtain the first 10 jobs that have the largest population,\nand sort the jobs in the descending order of population. See the following:\n\n```python\n>>> df = users.groupby(\"occupation\").agg({\"user_id\": \"count\"})\n>>> df.sort_values(\"user_id\", ascending=False)[:10]\n user_id\noccupation\nstudent 196\nother 105\neducator 95\nadministrator 79\nengineer 67\nprogrammer 66\nlibrarian 51\nwriter 45\nexecutive 32\nscientist 31\n```\n\nDataFrame APIs provide the `value_counts` method to quickly achieve the same\nresult. An example is shown below.\n\n```python\n>>> uses.occupation.value_counts()[:10]\nstudent 196\nother 105\neducator 95\nadministrator 79\nengineer 67\nprogrammer 66\nlibrarian 51\nwriter 45\nexecutive 32\nscientist 31\ndtype: int64\n```\n\nShow data in a more intuitive graph, as shown in the following code:\n\n```python\n%matplotlib inline\n```\n\nUse a horizontal bar chart to visualize data, as shown in the following code:\n\n```python\n>>> users['occupation'].value_counts().plot(kind='barh', x='occupation', ylabel='prefession')\n\n```\n\n\\_images/df-value-count-plot.png\n\nDivide ages into 30 groups and view the histogram of age distribution,\nas shown in the following code:\n\n```python\n>>> users.age.hist(bins=30, title=\"Distribution of users' ages\", xlabel='age', ylabel='count of users')\n\n```\n\n\\_images/df-age-hist.png\n\nUse join to join the three tables and save the joined tables as a new table. For example:\n\n```python\n>>> movies = md.read_odps_table('pyodps_ml_100k_movies')\n>>> ratings = md.read_odps_table('pyodps_ml_100k_ratings')\n>>>\n>>> o.delete_table('pyodps_ml_100k_lens', if_exists=True)\n>>> lens = movies.join(ratings).join(users).persist('pyodps_ml_100k_lens')\n>>>\n>>> lens.dtypes\nodps.Schema {\nmovie_id int64\ntitle string\nrelease_date string\nvideo_release_date string\nimdb_url string\nuser_id int64\nrating int64\nunix_timestamp int64\nage int64\nsex string\noccupation string\nzip_code string\n}\n```\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nFile v0.0.2:references/maxframe-client-docs/getting_started/tutorials/index.md\n\n# Getting started tutorials\n\n* [10 minutes to MaxFrame](10min.md)\n\nFile v0.0.2:references/maxframe-client-docs/index.md\n\n\n\n# MaxFrame Documentation\n\nMaxFrame is a framework for large-scale data computation built on MaxCompute\nby Alibaba Cloud with API-compatibility for pandas. It intends to become\nan inplace replacement for Python users familiar with Numpy or Pandas APIs\nto utilize MaxCompute to run their code in a distributed environment.\n\nFile v0.0.2:references/maxframe-client-docs/reference/dataframe/frame.md\n\n\n\n# DataFrame\n\n## Constructor\n\n| [`DataFrame`](generated/maxframe.dataframe.DataFrame.md#maxframe.dataframe.DataFrame)([data, index, columns, dtype, ...]) | |\n|-----------------------------------------------------------------------------------------------------------------------------|----|\n\n## Attributes and underlying data\n\n**Axes**\n\n| [`DataFrame.index`](generated/maxframe.dataframe.DataFrame.index.md#maxframe.dataframe.DataFrame.index) | |\n|---------------------------------------------------------------------------------------------------------------|----|\n| [`DataFrame.columns`](generated/maxframe.dataframe.DataFrame.columns.md#maxframe.dataframe.DataFrame.columns) | |\n\n| [`DataFrame.dtypes`](generated/maxframe.dataframe.DataFrame.dtypes.md#maxframe.dataframe.DataFrame.dtypes) | Return the dtypes in the DataFrame. |\n|-----------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------|\n| [`DataFrame.memory_usage`](generated/maxframe.dataframe.DataFrame.memory_usage.md#maxframe.dataframe.DataFrame.memory_usage)([index, deep]) | Return the memory usage of each column in bytes. |\n| [`DataFrame.ndim`](generated/maxframe.dataframe.DataFrame.ndim.md#maxframe.dataframe.DataFrame.ndim) | Return an int representing the number of axes / array dimensions. |\n| [`DataFrame.select_dtypes`](generated/maxframe.dataframe.DataFrame.select_dtypes.md#maxframe.dataframe.DataFrame.select_dtypes)([include, exclude]) | Return a subset of the DataFrame's columns based on the column dtypes. |\n| [`DataFrame.shape`](generated/maxframe.dataframe.DataFrame.shape.md#maxframe.dataframe.DataFrame.shape) | |\n\n## Conversion\n\n| [`DataFrame.astype`](generated/maxframe.dataframe.DataFrame.astype.md#maxframe.dataframe.DataFrame.astype)(dtype[, copy, errors]) | Cast a pandas object to a specified dtype `dtype`. |\n|----------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------|\n| [`DataFrame.convert_dtypes`](generated/maxframe.dataframe.DataFrame.convert_dtypes.md#maxframe.dataframe.DataFrame.convert_dtypes)([infer_objects, ...]) | Convert columns to best possible dtypes using dtypes supporting `pd.NA`. |\n| [`DataFrame.copy`](generated/maxframe.dataframe.DataFrame.copy.md#maxframe.dataframe.DataFrame.copy)() | |\n| [`DataFrame.infer_objects`](generated/maxframe.dataframe.DataFrame.infer_objects.md#maxframe.dataframe.DataFrame.infer_objects)([copy]) | Attempt to infer better dtypes for object columns. |\n\n## Indexing, iteration\n\n| [`DataFrame.at`](generated/maxframe.dataframe.DataFrame.at.md#maxframe.dataframe.DataFrame.at) | Access a single value for a row/column label pair. |\n|-----------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|\n| [`DataFrame.head`](generated/maxframe.dataframe.DataFrame.head.md#maxframe.dataframe.DataFrame.head)([n]) | Return the first n rows. |\n| [`DataFrame.iat`](generated/maxframe.dataframe.DataFrame.iat.md#maxframe.dataframe.DataFrame.iat) | Access a single value for a row/column pair by integer position. |\n| [`DataFrame.iloc`](generated/maxframe.dataframe.DataFrame.iloc.md#maxframe.dataframe.DataFrame.iloc) | Purely integer-location based indexing for selection by position. |\n| [`DataFrame.insert`](generated/maxframe.dataframe.DataFrame.insert.md#maxframe.dataframe.DataFrame.insert)(loc, column, value[, ...]) | Insert column into DataFrame at specified location. |\n| [`DataFrame.loc`](generated/maxframe.dataframe.DataFrame.loc.md#maxframe.dataframe.DataFrame.loc) | Access a group of rows and columns by label(s) or a boolean array. |\n| [`DataFrame.mask`](generated/maxframe.dataframe.DataFrame.mask.md#maxframe.dataframe.DataFrame.mask)(cond[, other, inplace, axis, ...]) | Replace values where the condition is True. |\n| [`DataFrame.pop`](generated/maxframe.dataframe.DataFrame.pop.md#maxframe.dataframe.DataFrame.pop)(item) | Return item and drop from frame. |\n| [`DataFrame.query`](generated/maxframe.dataframe.DataFrame.query.md#maxframe.dataframe.DataFrame.query)(expr[, inplace]) | Query the columns of a DataFrame with a boolean expression. |\n| [`DataFrame.tail`](generated/maxframe.dataframe.DataFrame.tail.md#maxframe.dataframe.DataFrame.tail)([n]) | Return the last n rows. |\n| [`DataFrame.xs`](generated/maxframe.dataframe.DataFrame.xs.md#maxframe.dataframe.DataFrame.xs)(key[, axis, level, drop_level]) | Return cross-section from the Series/DataFrame. |\n| [`DataFrame.where`](generated/maxframe.dataframe.DataFrame.where.md#maxframe.dataframe.DataFrame.where)(cond[, other, inplace, ...]) | Replace values where the condition is False. |\n\n## Binary operator functions\n\n| [`DataFrame.add`](generated/maxframe.dataframe.DataFrame.add.md#maxframe.dataframe.DataFrame.add)(other[, axis, level, fill_value]) | Get Addition of dataframe and other, element-wise (binary operator add). |\n|------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------|\n| [`DataFrame.sub`](generated/maxframe.dataframe.DataFrame.sub.md#maxframe.dataframe.DataFrame.sub)(other[, axis, level, fill_value]) | Get Subtraction of dataframe and other, element-wise (binary operator subtract). |\n| [`DataFrame.mul`](generated/maxframe.dataframe.DataFrame.mul.md#maxframe.dataframe.DataFrame.mul)(other[, axis, level, fill_value]) | Get Multiplication of dataframe and other, element-wise (binary operator mul). |\n| [`DataFrame.div`](generated/maxframe.dataframe.DataFrame.div.md#maxframe.dataframe.DataFrame.div)(other[, axis, level, fill_value]) | Get Floating division of dataframe and other, element-wise (binary operator truediv). |\n| [`DataFrame.truediv`](generated/maxframe.dataframe.DataFrame.truediv.md#maxframe.dataframe.DataFrame.truediv)(other[, axis, level, ...]) | Get Floating division of dataframe and other, element-wise (binary operator truediv). |\n| [`DataFrame.floordiv`](generated/maxframe.dataframe.DataFrame.floordiv.md#maxframe.dataframe.DataFrame.floordiv)(other[, axis, level, ...]) | Get Integer division of dataframe and other, element-wise (binary operator floordiv). |\n| [`DataFrame.mod`](generated/maxframe.dataframe.DataFrame.mod.md#maxframe.dataframe.DataFrame.mod)(other[, axis, level, fill_value]) | Get Modulo of dataframe and other, element-wise (binary operator mod). |\n| [`DataFrame.pow`](generated/maxframe.dataframe.DataFrame.pow.md#maxframe.dataframe.DataFrame.pow)(other[, axis, level, fill_value]) | Get Exponential power of dataframe and other, element-wise (binary operator pow). |\n| [`DataFrame.dot`](generated/maxframe.dataframe.DataFrame.dot.md#maxframe.dataframe.DataFrame.dot)(other) | Compute the matrix multiplication between the DataFrame and other. |\n| [`DataFrame.radd`](generated/maxframe.dataframe.DataFrame.radd.md#maxframe.dataframe.DataFrame.radd)(other[, axis, level, fill_value]) | Get Addition of dataframe and other, element-wise (binary operator radd). |\n| [`DataFrame.rsub`](generated/maxframe.dataframe.DataFrame.rsub.md#maxframe.dataframe.DataFrame.rsub)(other[, axis, level, fill_value]) | Get Subtraction of dataframe and other, element-wise (binary operator rsubtract). |\n| [`DataFrame.rmul`](generated/maxframe.dataframe.DataFrame.rmul.md#maxframe.dataframe.DataFrame.rmul)(other[, axis, level, fill_value]) | Get Multiplication of dataframe and other, element-wise (binary operator rmul). |\n| [`DataFrame.rdiv`](generated/maxframe.dataframe.DataFrame.rdiv.md#maxframe.dataframe.DataFrame.rdiv)(other[, axis, level, fill_value]) | Get Floating division of dataframe and other, element-wise (binary operator rtruediv). |\n| [`DataFrame.rtruediv`](generated/maxframe.dataframe.DataFrame.rtruediv.md#maxframe.dataframe.DataFrame.rtruediv)(other[, axis, level, ...]) | Get Floating division of dataframe and other, element-wise (binary operator rtruediv). |\n| [`DataFrame.rfloordiv`](generated/maxframe.dataframe.DataFrame.rfloordiv.md#maxframe.dataframe.DataFrame.rfloordiv)(other[, axis, level, ...]) | Get Integer division of dataframe and other, element-wise (binary operator rfloordiv). |\n| [`DataFrame.rmod`](generated/maxframe.dataframe.DataFrame.rmod.md#maxframe.dataframe.DataFrame.rmod)(other[, axis, level, fill_value]) | Get Modulo of dataframe and other, element-wise (binary operator rmod). |\n| [`DataFrame.rpow`](generated/maxframe.dataframe.DataFrame.rpow.md#maxframe.dataframe.DataFrame.rpow)(other[, axis, level, fill_value]) | Get Exponential power of dataframe and other, element-wise (binary operator rpow). |\n| [`DataFrame.lt`](generated/maxframe.dataframe.DataFrame.lt.md#maxframe.dataframe.DataFrame.lt)(other[, axis, level, fill_value]) | Get Less than of dataframe and other, element-wise (binary operator lt). |\n| [`DataFrame.gt`](generated/maxframe.dataframe.DataFrame.gt.md#maxframe.dataframe.DataFrame.gt)(other[, axis, level, fill_value]) | Get Greater than of dataframe and other, element-wise (binary operator gt). |\n| [`DataFrame.le`](generated/maxframe.dataframe.DataFrame.le.md#maxframe.dataframe.DataFrame.le)(other[, axis, level, fill_value]) | Get Less than or equal to of dataframe and other, element-wise (binary operator le). |\n| [`DataFrame.ge`](generated/maxframe.dataframe.DataFrame.ge.md#maxframe.dataframe.DataFrame.ge)(other[, axis, level, fill_value]) | Get Greater than or equal to of dataframe and other, element-wise (binary operator ge). |\n| [`DataFrame.ne`](generated/maxframe.dataframe.DataFrame.ne.md#maxframe.dataframe.DataFrame.ne)(other[, axis, level, fill_value]) | Get Not equal to of dataframe and other, element-wise (binary operator ne). |\n| [`DataFrame.eq`](generated/maxframe.dataframe.DataFrame.eq.md#maxframe.dataframe.DataFrame.eq)(other[, axis, level, fill_value]) | Get Equal to of dataframe and other, element-wise (binary operator eq). |\n| [`DataFrame.combine`](generated/maxframe.dataframe.DataFrame.combine.md#maxframe.dataframe.DataFrame.combine)(other, func[, fill_value, ...]) | Perform column-wise combine with another DataFrame. |\n| [`DataFrame.combine_first`](generated/maxframe.dataframe.DataFrame.combine_first.md#maxframe.dataframe.DataFrame.combine_first)(other) | Update null elements with value in the same location in other. |\n\n## Function application, GroupBy & window\n\n| [`DataFrame.apply`](generated/maxframe.dataframe.DataFrame.apply.md#maxframe.dataframe.DataFrame.apply)(func[, axis, raw, ...]) | Apply a function along an axis of the DataFrame. |\n|------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|\n| [`DataFrame.applymap`](generated/maxframe.dataframe.DataFrame.applymap.md#maxframe.dataframe.DataFrame.applymap)(func[, na_action, ...]) | Apply a function to a Dataframe elementwise. |\n| [`DataFrame.agg`](generated/maxframe.dataframe.DataFrame.agg.md#maxframe.dataframe.DataFrame.agg)([func, axis]) | Aggregate using one or more operations over the specified axis. |\n| [`DataFrame.aggregate`](generated/maxframe.dataframe.DataFrame.aggregate.md#maxframe.dataframe.DataFrame.aggregate)([func, axis]) | Aggregate using one or more operations over the specified axis. |\n| [`DataFrame.ewm`](generated/maxframe.dataframe.DataFrame.ewm.md#maxframe.dataframe.DataFrame.ewm)([com, span, halflife, alpha, ...]) | Provide exponential weighted functions. |\n| [`DataFrame.expanding`](generated/maxframe.dataframe.DataFrame.expanding.md#maxframe.dataframe.DataFrame.expanding)([min_periods, shift, ...]) | Provide expanding transformations. |\n| [`DataFrame.groupby`](generated/maxframe.dataframe.DataFrame.groupby.md#maxframe.dataframe.DataFrame.groupby)([by, level, as_index, ...]) | Group DataFrame using a mapper or by a Series of columns. |\n| [`DataFrame.map`](generated/maxframe.dataframe.DataFrame.map.md#maxframe.dataframe.DataFrame.map)(func[, na_action, dtypes, ...]) | Apply a function to a Dataframe elementwise. |\n| [`DataFrame.rolling`](generated/maxframe.dataframe.DataFrame.rolling.md#maxframe.dataframe.DataFrame.rolling)(window[, min_periods, ...]) | Provide rolling window calculations. |\n| [`DataFrame.transform`](generated/maxframe.dataframe.DataFrame.transform.md#maxframe.dataframe.DataFrame.transform)(func[, axis, dtypes, ...]) | Call `func` on self producing a DataFrame with transformed values. |\n\n\n\n## Computations / descriptive stats\n\n| [`DataFrame.abs`](generated/maxframe.dataframe.DataFrame.abs.md#maxframe.dataframe.DataFrame.abs)() | |\n|--------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|\n| [`DataFrame.all`](generated/maxframe.dataframe.DataFrame.all.md#maxframe.dataframe.DataFrame.all)([axis, bool_only, skipna, ...]) | |\n| [`DataFrame.any`](generated/maxframe.dataframe.DataFrame.any.md#maxframe.dataframe.DataFrame.any)([axis, bool_only, skipna, ...]) | |\n| [`DataFrame.clip`](generated/maxframe.dataframe.DataFrame.clip.md#maxframe.dataframe.DataFrame.clip)([lower, upper, axis, inplace]) | Trim values at input threshold(s). |\n| [`DataFrame.count`](generated/maxframe.dataframe.DataFrame.count.md#maxframe.dataframe.DataFrame.count)([axis, level, numeric_only]) | |\n| [`DataFrame.corr`](generated/maxframe.dataframe.DataFrame.corr.md#maxframe.dataframe.DataFrame.corr)([method, min_periods]) | Compute pairwise correlation of columns, excluding NA/null values. |\n| [`DataFrame.corrwith`](generated/maxframe.dataframe.DataFrame.corrwith.md#maxframe.dataframe.DataFrame.corrwith)(other[, axis, drop, method]) | Compute pairwise correlation. |\n| [`DataFrame.cov`](generated/maxframe.dataframe.DataFrame.cov.md#maxframe.dataframe.DataFrame.cov)([min_periods, ddof, numeric_only]) | Compute pairwise covariance of columns, excluding NA/null values. |\n| [`DataFrame.describe`](generated/maxframe.dataframe.DataFrame.describe.md#maxframe.dataframe.DataFrame.describe)([percentiles, include, ...]) | Generate descriptive statistics. |\n| [`DataFrame.diff`](generated/maxframe.dataframe.DataFrame.diff.md#maxframe.dataframe.DataFrame.diff)([periods, axis]) | First discrete difference of element. |\n| [`DataFrame.eval`](generated/maxframe.dataframe.DataFrame.eval.md#maxframe.dataframe.DataFrame.eval)(expr[, inplace]) | Evaluate a string describing operations on DataFrame columns. |\n| [`DataFrame.max`](generated/maxframe.dataframe.DataFrame.max.md#maxframe.dataframe.DataFrame.max)([axis, skipna, level, ...]) | |\n| [`DataFrame.mean`](generated/maxframe.dataframe.DataFrame.mean.md#maxframe.dataframe.DataFrame.mean)([axis, skipna, level, ...]) | |\n| [`DataFrame.median`](generated/maxframe.dataframe.DataFrame.median.md#maxframe.dataframe.DataFrame.median)([axis, skipna, level, ...]) | |\n| [`DataFrame.min`](generated/maxframe.dataframe.DataFrame.min.md#maxframe.dataframe.DataFrame.min)([axis, skipna, level, ...]) | |\n| [`DataFrame.mode`](generated/maxframe.dataframe.DataFrame.mode.md#maxframe.dataframe.DataFrame.mode)([axis, numeric_only, dropna, ...]) | Get the mode(s) of each element along the selected axis. |\n| [`DataFrame.nunique`](generated/maxframe.dataframe.DataFrame.nunique.md#maxframe.dataframe.DataFrame.nunique)([axis, dropna]) | Count distinct observations over requested axis. |\n| [`DataFrame.pct_change`](generated/maxframe.dataframe.DataFrame.pct_change.md#maxframe.dataframe.DataFrame.pct_change)([periods, fill_method, ...]) | Percentage change between the current and a prior element. |\n| [`DataFrame.prod`](generated/maxframe.dataframe.DataFrame.prod.md#maxframe.dataframe.DataFrame.prod)([axis, skipna, level, ...]) | |\n| [`DataFrame.product`](generated/maxframe.dataframe.DataFrame.product.md#maxframe.dataframe.DataFrame.product)([axis, skipna, level, ...]) | |\n| [`DataFrame.quantile`](generated/maxframe.dataframe.DataFrame.quantile.md#maxframe.dataframe.DataFrame.quantile)([q, axis, numeric_only, ...]) | Return values at the given quantile over requested axis. |\n| [`DataFrame.rank`](generated/maxframe.dataframe.DataFrame.rank.md#maxframe.dataframe.DataFrame.rank)([axis, method, numeric_only, ...]) | Compute numerical data ranks (1 through n) along axis. |\n| [`DataFrame.round`](generated/maxframe.dataframe.DataFrame.round.md#maxframe.dataframe.DataFrame.round)([decimals]) | Round a DataFrame to a variable number of decimal places. |\n| [`DataFrame.sem`](generated/maxframe.dataframe.DataFrame.sem.md#maxframe.dataframe.DataFrame.sem)([axis, skipna, level, ddof, ...]) | |\n| [`DataFrame.std`](generated/maxframe.dataframe.DataFrame.std.md#maxframe.dataframe.DataFrame.std)([axis, skipna, level, ddof, ...]) | |\n| [`DataFrame.sum`](generated/maxframe.dataframe.DataFrame.sum.md#maxframe.dataframe.DataFrame.sum)([axis, skipna, level, ...]) | |\n| [`DataFrame.value_counts`](generated/maxframe.dataframe.DataFrame.value_counts.md#maxframe.dataframe.DataFrame.value_counts)([subset, normalize, ...]) | |\n| [`DataFrame.var`](generated/maxframe.dataframe.DataFrame.var.md#maxframe.dataframe.DataFrame.var)([axis, skipna, level, ddof, ...]) | |\n\n## Reindexing / selection / label manipulation\n\n| [`DataFrame.add_prefix`](generated/maxframe.dataframe.DataFrame.add_prefix.md#maxframe.dataframe.DataFrame.add_prefix)(prefix) | Prefix labels with string prefix. |\n|------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------|\n| [`DataFrame.add_suffix`](generated/maxframe.dataframe.DataFrame.add_suffix.md#maxframe.dataframe.DataFrame.add_suffix)(suffix) | Suffix labels with string suffix. |\n| [`DataFrame.align`](generated/maxframe.dataframe.DataFrame.align.md#maxframe.dataframe.DataFrame.align)(other[, join, axis, level, ...]) | Align two objects on their axes with the specified join method. |\n| [`DataFrame.at_time`](generated/maxframe.dataframe.DataFrame.at_time.md#maxframe.dataframe.DataFrame.at_time)(time[, axis]) | Select values at particular time of day (e.g., 9:30AM). |\n| [`DataFrame.between_time`](generated/maxframe.dataframe.DataFrame.between_time.md#maxframe.dataframe.DataFrame.between_time)(start_time, end_time) | Select values between particular times of the day (e.g., 9:00-9:30 AM). |\n| [`DataFrame.drop`](generated/maxframe.dataframe.DataFrame.drop.md#maxframe.dataframe.DataFrame.drop)([labels, axis, index, ...]) | Drop specified labels from rows or columns. |\n| [`DataFrame.drop_duplicates`](generated/maxframe.dataframe.DataFrame.drop_duplicates.md#maxframe.dataframe.DataFrame.drop_duplicates)([subset, keep, ...]) | Return DataFrame with duplicate rows removed. |\n| [`DataFrame.droplevel`](generated/maxframe.dataframe.DataFrame.droplevel.md#maxframe.dataframe.DataFrame.droplevel)(level[, axis]) | Return Series/DataFrame with requested index / column level(s) removed. |\n| [`DataFrame.duplicated`](generated/maxframe.dataframe.DataFrame.duplicated.md#maxframe.dataframe.DataFrame.duplicated)([subset, keep, method]) | Return boolean Series denoting duplicate rows. |\n| [`DataFrame.filter`](generated/maxframe.dataframe.DataFrame.filter.md#maxframe.dataframe.DataFrame.filter)([items, like, regex, axis]) | Subset the dataframe rows or columns according to the specified index labels. |\n| [`DataFrame.head`](generated/maxframe.dataframe.DataFrame.head.md#maxframe.dataframe.DataFrame.head)([n]) | Return the first n rows. |\n| [`DataFrame.idxmax`](generated/maxframe.dataframe.DataFrame.idxmax.md#maxframe.dataframe.DataFrame.idxmax)([axis, skipna]) | Return index of first occurrence of maximum over requested axis. |\n| [`DataFrame.idxmin`](generated/maxframe.dataframe.DataFrame.idxmin.md#maxframe.dataframe.DataFrame.idxmin)([axis, skipna]) | Return index of first occurrence of minimum over requested axis. |\n| [`DataFrame.reindex`](generated/maxframe.dataframe.DataFrame.reindex.md#maxframe.dataframe.DataFrame.reindex)([labels, index, columns, ...]) | Conform Series/DataFrame to new index with optional filling logic. |\n| [`DataFrame.reindex_like`](generated/maxframe.dataframe.DataFrame.reindex_like.md#maxframe.dataframe.DataFrame.reindex_like)(other[, method, ...]) | Return an object with matching indices as other object. |\n| [`DataFrame.rename`](generated/maxframe.dataframe.DataFrame.rename.md#maxframe.dataframe.DataFrame.rename)([mapper, index, columns, ...]) | Alter axes labels. |\n| [`DataFrame.rename_axis`](generated/maxframe.dataframe.DataFrame.rename_axis.md#maxframe.dataframe.DataFrame.rename_axis)([mapper, index, ...]) | Set the name of the axis for the index or columns. |\n| [`DataFrame.reset_index`](generated/maxframe.dataframe.DataFrame.reset_index.md#maxframe.dataframe.DataFrame.reset_index)([level, drop, ...]) | Reset the index, or a level of it. |\n| [`DataFrame.sample`](generated/maxframe.dataframe.DataFrame.sample.md#maxframe.dataframe.DataFrame.sample)([n, frac, replace, ...]) | Return a random sample of items from an axis of object. |\n| [`DataFrame.set_axis`](generated/maxframe.dataframe.DataFrame.set_axis.md#maxframe.dataframe.DataFrame.set_axis)(labels[, axis, inplace]) | Assign desired index to given axis. |\n| [`DataFrame.set_index`](generated/maxframe.dataframe.DataFrame.set_index.md#maxframe.dataframe.DataFrame.set_index)(keys[, drop, append, ...]) | Set the DataFrame index using existing columns. |\n| [`DataFrame.take`](generated/maxframe.dataframe.DataFrame.take.md#maxframe.dataframe.DataFrame.take)(indices[, axis]) | Return the elements in the given *positional* indices along an axis. |\n| [`DataFrame.truncate`](generated/maxframe.dataframe.DataFrame.truncate.md#maxframe.dataframe.DataFrame.truncate)([before, after, axis, copy]) | Truncate a Series or DataFrame before and after some index value. |\n\n\n\n## Missing data handling\n\n| [`DataFrame.dropna`](generated/maxframe.dataframe.DataFrame.dropna.md#maxframe.dataframe.DataFrame.dropna)([axis, how, thresh, ...]) | Remove missing values. |\n|----------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------|\n| [`DataFrame.fillna`](generated/maxframe.dataframe.DataFrame.fillna.md#maxframe.dataframe.DataFrame.fillna)([value, method, axis, ...]) | Fill NA/NaN values using the specified method. |\n| [`DataFrame.isna`](generated/maxframe.dataframe.DataFrame.isna.md#maxframe.dataframe.DataFrame.isna)() | Detect missing values. |\n| [`DataFrame.isnull`](generated/maxframe.dataframe.DataFrame.isnull.md#maxframe.dataframe.DataFrame.isnull)() | Detect missing values. |\n| [`DataFrame.notna`](generated/maxframe.dataframe.DataFrame.notna.md#maxframe.dataframe.DataFrame.notna)() | Detect existing (non-missing) values. |\n| [`DataFrame.notnull`](generated/maxframe.dataframe.DataFrame.notnull.md#maxframe.dataframe.DataFrame.notnull)() | Detect existing (non-missing) values. |\n\n## Reshaping, sorting, transposing\n\n| [`DataFrame.melt`](generated/maxframe.dataframe.DataFrame.melt.md#maxframe.dataframe.DataFrame.melt)([id_vars, value_vars, ...]) | Unpivot a DataFrame from wide to long format, optionally leaving identifiers set. |\n|-------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------|\n| [`DataFrame.nlargest`](generated/maxframe.dataframe.DataFrame.nlargest.md#maxframe.dataframe.DataFrame.nlargest)(n, columns[, keep]) | Return the first n rows ordered by columns in descending order. |\n| [`DataFrame.nsmallest`](generated/maxframe.dataframe.DataFrame.nsmallest.md#maxframe.dataframe.DataFrame.nsmallest)(n, columns[, keep]) | Return the first n rows ordered by columns in ascending order. |\n| [`DataFrame.pivot`](generated/maxframe.dataframe.DataFrame.pivot.md#maxframe.dataframe.DataFrame.pivot)(columns[, index, values]) | Return reshaped DataFrame organized by given index / column values. |\n| [`DataFrame.pivot_table`](generated/maxframe.dataframe.DataFrame.pivot_table.md#maxframe.dataframe.DataFrame.pivot_table)([values, index, ...]) | Create a spreadsheet-style pivot table as a DataFrame. |\n| [`DataFrame.reorder_levels`](generated/maxframe.dataframe.DataFrame.reorder_levels.md#maxframe.dataframe.DataFrame.reorder_levels)(order[, axis]) | Rearrange index levels using input order. |\n| [`DataFrame.sort_values`](generated/maxframe.dataframe.DataFrame.sort_values.md#maxframe.dataframe.DataFrame.sort_values)(by[, axis, ascending, ...]) | Sort by the values along either axis. |\n| [`DataFrame.sort_index`](generated/maxframe.dataframe.DataFrame.sort_index.md#maxframe.dataframe.DataFrame.sort_index)([axis, level, ...]) | Sort object by labels (along an axis). |\n| [`DataFrame.swaplevel`](generated/maxframe.dataframe.DataFrame.swaplevel.md#maxframe.dataframe.DataFrame.swaplevel)([i, j, axis]) | Swap levels i and j in a `MultiIndex`. |\n| [`DataFrame.stack`](generated/maxframe.dataframe.DataFrame.stack.md#maxframe.dataframe.DataFrame.stack)([level, dropna]) | Stack the prescribed level(s) from columns to index. |\n| [`DataFrame.unstack`](generated/maxframe.dataframe.DataFrame.unstack.md#maxframe.dataframe.DataFrame.unstack)([level, fill_value]) | Unstack, also known as pivot, Series with MultiIndex to produce DataFrame. |\n\n## Combining / comparing / joining / merging\n\n| [`DataFrame.append`](generated/maxframe.dataframe.DataFrame.append.md#maxframe.dataframe.DataFrame.append)(other[, ignore_index, ...]) | Append rows of other to the end of caller, returning a new object. |\n|-------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------|\n| [`DataFrame.assign`](generated/maxframe.dataframe.DataFrame.assign.md#maxframe.dataframe.DataFrame.assign)(\\*\\*kwargs) | Assign new columns to a DataFrame. |\n| [`DataFrame.compare`](generated/maxframe.dataframe.DataFrame.compare.md#maxframe.dataframe.DataFrame.compare)(other[, align_axis, ...]) | Compare to another DataFrame and show the differences. |\n| [`DataFrame.join`](generated/maxframe.dataframe.DataFrame.join.md#maxframe.dataframe.DataFrame.join)(other[, on, how, lsuffix, ...]) | Join columns of another DataFrame. |\n| [`DataFrame.merge`](generated/maxframe.dataframe.DataFrame.merge.md#maxframe.dataframe.DataFrame.merge)(right[, how, on, left_on, ...]) | Merge DataFrame or named Series objects with a database-style join. |\n| [`DataFrame.update`](generated/maxframe.dataframe.DataFrame.update.md#maxframe.dataframe.DataFrame.update)(other[, join, overwrite, ...]) | Modify in place using non-NA values from another DataFrame. |\n\n### Time series-related\n\n| [`DataFrame.first_valid_index`](generated/maxframe.dataframe.DataFrame.first_valid_index.md#maxframe.dataframe.DataFrame.first_valid_index)() | Return index for first non-NA value or None, if no non-NA value is found. |\n|-------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------|\n| [`DataFrame.last_valid_index`](generated/maxframe.dataframe.DataFrame.last_valid_index.md#maxframe.dataframe.DataFrame.last_valid_index)() | Return index for last non-NA value or None, if no non-NA value is found. |\n| [`DataFrame.shift`](generated/maxframe.dataframe.DataFrame.shift.md#maxframe.dataframe.DataFrame.shift)([periods, freq, axis, ...]) | Shift index by desired number of periods with an optional time freq. |\n| [`DataFrame.tshift`](generated/maxframe.dataframe.DataFrame.tshift.md#maxframe.dataframe.DataFrame.tshift)([periods, freq, axis]) | Shift the time index, using the index's frequency if available. |\n\n\n\n## Plotting\n\n`DataFrame.plot` is both a callable method and a namespace attribute for\nspecific plotting methods of the form `DataFrame.plot.`.\n\n| [`DataFrame.plot`](generated/maxframe.dataframe.DataFrame.plot.md#maxframe.dataframe.DataFrame.plot) | alias of `DataFramePlotAccessor` |\n|--------------------------------------------------------------------------------------------------------|------------------------------------|\n\n| [`DataFrame.plot.area`](generated/maxframe.dataframe.DataFrame.plot.area.md#maxframe.dataframe.DataFrame.plot.area)(\\*args, \\*\\*kwargs) | Draw a stacked area plot. |\n|--------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------|\n| [`DataFrame.plot.bar`](generated/maxframe.dataframe.DataFrame.plot.bar.md#maxframe.dataframe.DataFrame.plot.bar)(\\*args, \\*\\*kwargs) | Vertical bar plot. |\n| [`DataFrame.plot.barh`](generated/maxframe.dataframe.DataFrame.plot.barh.md#maxframe.dataframe.DataFrame.plot.barh)(\\*args, \\*\\*kwargs) | Make a horizontal bar plot. |\n| [`DataFrame.plot.box`](generated/maxframe.dataframe.DataFrame.plot.box.md#maxframe.dataframe.DataFrame.plot.box)(\\*args, \\*\\*kwargs) | Make a box plot of the DataFrame columns. |\n| [`DataFrame.plot.density`](generated/maxframe.dataframe.DataFrame.plot.density.md#maxframe.dataframe.DataFrame.plot.density)(\\*args, \\*\\*kwargs) | Generate Kernel Density Estimate plot using Gaussian kernels. |\n| [`DataFrame.plot.hexbin`](generated/maxframe.dataframe.DataFrame.plot.hexbin.md#maxframe.dataframe.DataFrame.plot.hexbin)(\\*args, \\*\\*kwargs) | Generate a hexagonal binning plot. |\n| [`DataFrame.plot.hist`](generated/maxframe.dataframe.DataFrame.plot.hist.md#maxframe.dataframe.DataFrame.plot.hist)(\\*args, \\*\\*kwargs) | Draw one histogram of the DataFrame's columns. |\n| [`DataFrame.plot.kde`](generated/maxframe.dataframe.DataFrame.plot.kde.md#maxframe.dataframe.DataFrame.plot.kde)(\\*args, \\*\\*kwargs) | Generate Kernel Density Estimate plot using Gaussian kernels. |\n| [`DataFrame.plot.line`](generated/maxframe.dataframe.DataFrame.plot.line.md#maxframe.dataframe.DataFrame.plot.line)(\\*args, \\*\\*kwargs) | Plot Series or DataFrame as lines. |\n| [`DataFrame.plot.pie`](generated/maxframe.dataframe.DataFrame.plot.pie.md#maxframe.dataframe.DataFrame.plot.pie)(\\*args, \\*\\*kwargs) | Generate a pie plot. |\n| [`DataFrame.plot.scatter`](generated/maxframe.dataframe.DataFrame.plot.scatter.md#maxframe.dataframe.DataFrame.plot.scatter)(\\*args, \\*\\*kwargs) | Create a scatter plot with varying marker point size and color. |\n\n\n\n## Serialization / IO / conversion\n\n| [`DataFrame.from_dict`](generated/maxframe.dataframe.DataFrame.from_dict.md#maxframe.dataframe.DataFrame.from_dict)(data[, orient, dtype, ...]) | Construct DataFrame from dict of array-like or dicts. |\n|----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|\n| [`DataFrame.from_records`](generated/maxframe.dataframe.DataFrame.from_records.md#maxframe.dataframe.DataFrame.from_records)(data[, index, ...]) | Convert structured or record ndarray to DataFrame. |\n| [`DataFrame.to_clipboard`](generated/maxframe.dataframe.DataFrame.to_clipboard.md#maxframe.dataframe.DataFrame.to_clipboard)(\\*[, excel, sep, ...]) | Copy object to the system clipboard. |\n| [`DataFrame.to_csv`](generated/maxframe.dataframe.DataFrame.to_csv.md#maxframe.dataframe.DataFrame.to_csv)(path[, sep, na_rep, ...]) | Write object to a comma-separated values (csv) file. |\n| [`DataFrame.to_dict`](generated/maxframe.dataframe.DataFrame.to_dict.md#maxframe.dataframe.DataFrame.to_dict)([orient, into, index, ...]) | Convert the DataFrame to a dictionary. |\n| [`DataFrame.to_json`](generated/maxframe.dataframe.DataFrame.to_json.md#maxframe.dataframe.DataFrame.to_json)([path, orient, ...]) | Convert the object to a JSON string. |\n| [`DataFrame.to_odps_table`](generated/maxframe.dataframe.DataFrame.to_odps_table.md#maxframe.dataframe.DataFrame.to_odps_table)(table[, partition, ...]) | Write DataFrame object into a MaxCompute (ODPS) table. |\n| [`DataFrame.to_pandas`](generated/maxframe.dataframe.DataFrame.to_pandas.md#maxframe.dataframe.DataFrame.to_pandas)([session]) | |\n| [`DataFrame.to_parquet`](generated/maxframe.dataframe.DataFrame.to_parquet.md#maxframe.dataframe.DataFrame.to_parquet)(path[, engine, ...]) | Write a DataFrame to the binary parquet format, each chunk will be written to a Parquet file. |\n\n\n\n## MaxFrame Extensions\n\n| [`DataFrame.mf.apply_chunk`](generated/maxframe.dataframe.DataFrame.mf.apply_chunk.md#maxframe.dataframe.DataFrame.mf.apply_chunk)(func[, batch_rows, ...]) | Apply a function that takes pandas DataFrame and outputs pandas DataFrame/Series. |\n|---------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------|\n| [`DataFrame.mf.collect_kv`](generated/maxframe.dataframe.DataFrame.mf.collect_kv.md#maxframe.dataframe.DataFrame.mf.collect_kv)([columns, kv_delim, ...]) | Merge values in specified columns into a key-value represented column. |\n| [`DataFrame.mf.extract_kv`](generated/maxframe.dataframe.DataFrame.mf.extract_kv.md#maxframe.dataframe.DataFrame.mf.extract_kv)([columns, kv_delim, ...]) | Extract values in key-value represented columns into standalone columns. |\n| [`DataFrame.mf.flatmap`](generated/maxframe.dataframe.DataFrame.mf.flatmap.md#maxframe.dataframe.DataFrame.mf.flatmap)(func[, dtypes, raw, args]) | Apply the given function to each row and then flatten results. |\n| [`DataFrame.mf.map_reduce`](generated/maxframe.dataframe.DataFrame.mf.map_reduce.md#maxframe.dataframe.DataFrame.mf.map_reduce)([mapper, reducer, ...]) | Map-reduce API over certain DataFrames. |\n| [`DataFrame.mf.rebalance`](generated/maxframe.dataframe.DataFrame.mf.rebalance.md#maxframe.dataframe.DataFrame.mf.rebalance)([axis, factor, ...]) | Make data more balanced across entire cluster. |\n| [`DataFrame.mf.reshuffle`](generated/maxframe.dataframe.DataFrame.mf.reshuffle.md#maxframe.dataframe.DataFrame.mf.reshuffle)([group_by, sort_by, ...]) | Shuffle data in DataFrame or Series to make data distribution more randomized. |\n\n`DataFrame.mf` provides methods unique to MaxFrame. These methods are collated from application\nscenarios in MaxCompute and these can be accessed like `DataFrame.mf.`.\n\nArchive v0.0.1: 984 files, 1258674 bytes\n\nFiles: assets/examples/ai_function_basic.py (2263b), assets/examples/complex_struct_arrow.py (3120b), assets/examples/complex_struct.py (2339b), assets/examples/dlf_table_write_basic.py (1788b), assets/examples/dlf_table_write_with_pk.py (2438b), assets/examples/fs_mount_example.py (7144b), assets/examples/gpu_unit_dpe_processing.py (2819b), assets/examples/groupby_batch_processing.py (2577b), assets/examples/oss_multi_mount.py (3714b), references/common-workflow.md (7542b), references/installation.md (6623b), references/local-debug-guide.md (10586b), references/maxframe-client-docs/getting_started/comparison/index.md (220b), references/maxframe-client-docs/getting_started/comparison/pyodps_df.md (11129b), references/maxframe-client-docs/getting_started/index.md (730b), references/maxframe-client-docs/getting_started/installation.md (3228b), references/maxframe-client-docs/getting_started/overview.md (307b), references/maxframe-client-docs/getting_started/tutorials/10min.md (8169b), references/maxframe-client-docs/getting_started/tutorials/index.md (66b), references/maxframe-client-docs/index.md (341b), references/maxframe-client-docs/reference/dataframe/frame.md (41870b), references/maxframe-client-docs/reference/dataframe/general_functions.md (3246b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.concat.md (6928b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.abs.md (57b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.add_prefix.md (1407b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.add_suffix.md (1406b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.add.md (4741b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.agg.md (2157b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.aggregate.md (2169b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.align.md (5363b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.all.md (117b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.any.md (117b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.append.md (2730b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.apply.md (7662b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.applymap.md (2629b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.assign.md (2176b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.astype.md (2930b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.at_time.md (1625b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.at.md (1345b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.between_time.md (2565b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.clip.md (2882b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.columns.md (74b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.combine_first.md (1675b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.combine.md (3466b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.compare.md (4483b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.convert_dtypes.md (4784b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.copy.md (76b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.corr.md (1753b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.corrwith.md (1589b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.count.md (107b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.cov.md (4159b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.describe.md (6057b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.diff.md (2292b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.div.md (4758b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.dot.md (2302b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.drop_duplicates.md (1372b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.drop.md (4449b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.droplevel.md (1575b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.dropna.md (3780b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.dtypes.md (932b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.duplicated.md (2606b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.eq.md (4809b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.eval.md (2885b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.ewm.md (3931b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.expanding.md (1480b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.fillna.md (3701b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.filter.md (2200b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.first_valid_index.md (1587b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.floordiv.md (4765b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.from_dict.md (3039b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.from_records.md (3119b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.ge.md (4825b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.groupby.md (2662b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.gt.md (4812b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.head.md (1512b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.iat.md (1370b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.idxmax.md (1985b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.idxmin.md (1988b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.iloc.md (3743b), references/maxframe-client-docs/reference/dataframe/generated/maxframe.dataframe.DataFrame.index.md (70b) (+584 more)\n\nFile v0.0.1:references/common-workflow.md\n\n# Common Workflow Complete Guide\n\nDetailed guide for the complete MaxFrame development workflow with comprehensive examples.\n\n## Session Setup Patterns\n\n### Pattern 1: Auto-detect (DataWorks/MaxCompute Notebook)\n\n```python\nimport os\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\n# Auto-detect from environment (preferred in DataWorks/MaxCompute Notebook)\nsession = new_session()\n```\n\n### Pattern 2: Explicit ODPS Connection\n\n```python\nimport os\nimport dotenv\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\ndotenv.load_dotenv()\n\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOINT\"),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\nsession = new_session(o)\n```\n\n### Pattern 3: Production-ready Session\n\n```python\nimport logging\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\n\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\nsession = new_session()\ntry:\n logger.info(f\"Session created. Logview: {session.get_logview_address()}\")\n # Your operations\n ...\nfinally:\n session.destroy()\n logger.info(\"Session destroyed\")\n```\n\n## Reading Data Patterns\n\n### Pattern 1: Basic Table Read\n\n```python\n# Read from MaxCompute table\ndf = md.read_odps_table(\"table_name\")\n\n# Read with index column\ndf = md.read_odps_table(\"table_name\", index_col=\"id\")\n\n# With column selection\ndf = md.read_odps_table(\"table_name\", columns=['id', 'value', 'timestamp'])\n\n# With partition filter\ndf = md.read_odps_table(\"table_name\", partition='ds=2024-01-01')\n```\n\n### Pattern 2: SQL Query Read\n\n```python\n# Read from SQL query with filters\ndf = md.read_odps_query(\n \"SELECT * FROM table WHERE date >= '2024-01-01' AND status = 'active'\"\n)\n\n# Complex SQL with joins\ndf = md.read_odps_query(\n \"SELECT a.*, b.value FROM table_a a JOIN table_b b ON a.id = b.id\"\n)\n```\n\n### Pattern 3: Sample Data Construction\n\nWhen user doesn't provide input table name, construct pandas DataFrame:\n\n```python\nimport pandas as pd\nimport numpy as np\n\n# Time series analysis example\nexample_pd_df = pd.DataFrame({\n 'timestamp': pd.date_range('2026-01-01', periods=1000, freq='H'),\n 'metric_name': np.random.choice(['cpu', 'memory', 'disk'], 1000),\n 'value': np.random.randn(1000) * 10 + 50,\n 'host_id': np.random.choice(['host1', 'host2', 'host3'], 1000)\n})\n\n# Load into MaxFrame\ndf = md.read_pandas(example_pd_df)\n```\n\n**Key guidelines for sample data:**\n- Match data types and structure to job requirements\n- Use realistic value ranges for the domain\n- Include 100-1000 rows to demonstrate logic\n- Use descriptive column names matching operations\n\n## Operator Selection Workflow\n\n### Step 1: Identify Required Operations\n\nBreak down the task into specific operations needed:\n- Filtering\n- Grouping\n- Aggregation\n- Transformation\n- Merging\n- Sorting\n\n### Step 2: Find MaxFrame Operators\n\nUse operator-selector agent or script:\n\n```bash\n# Search for operators by task description\npython scripts/lookup_operator.py search \"time series resampling\"\n\n# Check if a specific operator exists\npython scripts/lookup_operator.py info apply_chunk\n\n# Get detailed operator information\npython scripts/lookup_operator.py info groupby\n```\n\n### Step 3: Present Options to User\n\n```\nFor your data aggregation task, I've identified these options:\n\n1. `groupby().agg()` - Standard pandas-compatible approach\n - Pros: Familiar API, good for standard aggregations\n - Cons: May be slow for large datasets with custom logic\n\n2. `mf.apply_chunk()` - For custom aggregation with large datasets\n - Pros: Efficient batch processing, custom logic support\n - Cons: More complex, requires batch size tuning\n\nWhich approach do you prefer, or would you like me to explore other options?\n```\n\n### Step 4: Get User Confirmation\n\n**MANDATORY:** Do not proceed without user confirmation.\n\n## Processing Patterns\n\n### Pattern 1: Standard pandas Operations\n\n```python\n# Filter\nfiltered = df[df['column'] > 10]\n\n# GroupBy and aggregate\nresult = df.groupby('category').agg({'value': 'sum'})\n\n# Add columns\ndf['new_col'] = df['col1'] + df['col2']\n\n# Sort\ndf_sorted = df.sort_values('column')\n\n# Merge\ndf_merged = df1.merge(df2, on='key')\n\n# Multiple aggregations\nresult = df.groupby('category').agg({\n 'value': ['sum', 'mean', 'count'],\n 'price': 'max'\n})\n```\n\n### Pattern 2: Batch Processing (Large Datasets)\n\n```python\ndef process_batch(chunk):\n # Custom processing logic\n return chunk * 2\n\nresult = df.mf.apply_chunk(\n process_batch,\n batch_rows=1024, # Tune batch size for performance\n output_type='dataframe'\n)\n```\n\n### Pattern 3: UDF with Resource Allocation\n\n```python\nfrom maxframe.udf import with_running_options\n\n@with_running_options(engine=\"dpe\", cpu=2, memory=4)\ndef process_batch(batch):\n # CRITICAL: memory=4 means 4 GB, NOT 4 MB\n return batch * 2\n\nresult = df.mf.apply_chunk(process_batch)\n```\n\n## Writing Data Patterns\n\n### Pattern 1: Write to MaxCompute Table\n\n```python\n# Write to MaxCompute table\nmd.to_odps_table(df, \"output_table\", overwrite=True).execute()\n```\n\n### Pattern 2: Write to DLF External Table\n\n```python\nfrom maxframe import options\n\n# Enable DLF support\noptions.sql.settings = {\n \"odps.maxframe.resolve_dlf_tables\": \"true\"\n}\n\nmd.to_odps_table(df, \"dlf_table\").execute()\n```\n\n### Pattern 3: Multiple Output Tables\n\n```python\ntry:\n md.to_odps_table(df1, \"output_table1\").execute()\n md.to_odps_table(df2, \"output_table2\").execute()\nfinally:\n session.destroy()\n```\n\n## Execution and Cleanup Patterns\n\n### Pattern 1: Basic Execution\n\n```python\n# Execute operations (required for lazy execution)\nresult.execute()\n\n# Destroy session when done\nsession.destroy()\n```\n\n### Pattern 2: Safe Cleanup (Production)\n\n```python\ntry:\n # Execute operations\n result.execute()\nfinally:\n # Destroy session (always runs, even on error)\n session.destroy()\n```\n\n### Pattern 3: Comprehensive Cleanup\n\n```python\nimport logging\n\nlogger = logging.getLogger(__name__)\n\ntry:\n result.execute()\n logger.info(\"Execution successful\")\nexcept Exception as e:\n logger.error(f\"Execution failed: {e}\")\n raise\nfinally:\n try:\n session.destroy()\n logger.info(\"Session destroyed\")\n except Exception as cleanup_error:\n logger.warning(f\"Cleanup error: {cleanup_error}\")\n```\n\n## Verification Pattern\n\nUse `py_compile` to test generated job script:\n\n```bash\npython -m py_compile your_script.py\n```\n\n## Complete Example Pipeline\n\n```python\nimport os\nimport logging\nimport dotenv\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\n\ndotenv.load_dotenv()\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\n# Setup session\nsession = new_session()\ntry:\n logger.info(f\"Session created. Logview: {session.get_logview_address()}\")\n\n # Read data\n df = md.read_odps_table(\"source_table\", columns=['id', 'value', 'category'])\n\n # Process (after confirming operators with user)\n filtered = df[df['value'] > 100]\n result = filtered.groupby('category').agg({'value': 'sum'})\n\n # Write output\n md.to_odps_table(result, \"output_table\", overwrite=True).execute()\n\n logger.info(\"Job completed successfully\")\n logger.info(f\"Final Logview: {session.get_logview_address()}\")\n\nfinally:\n session.destroy()\n logger.info(\"Session destroyed\")\n```\n\nFile v0.0.1:references/installation.md\n\n# MaxFrame Installation Guide\n\nThis guide provides step-by-step instructions for installing and configuring MaxFrame for distributed data processing on MaxCompute.\n\n## Table of Contents\n\n- [Prerequisites](#prerequisites)\n- [Dependencies](#dependencies)\n- [Environment Configuration](#environment-config)\n - [Required Environment Variables](#required-environment-variables)\n - [Setting Environment Variables](#setting-environment-variables)\n - [Find Your MaxCompute Endpoint](#find-your-maxcompute-endpoint)\n- [Installation Verification](#installation-verification)\n- [Session Setup](#session-setup)\n - [Manual Session Creation](#manual-session-creation)\n - [Auto-Detect from Environment](#auto-detect-from-environment)\n- [Troubleshooting](#troubleshooting)\n - [Common Issues](#common-issues)\n - [Getting Help](#getting-help)\n- [Next Steps](#next-steps)\n- [Cleanup](#cleanup)\n\n## Prerequisites\n\n- Python 3.7 or higher\n- MaxCompute (ODPS) account with valid credentials\n- Access to a MaxCompute project\n\n## Dependencies\n\nInstall the required Python packages:\n\n```bash\npip install maxframe -U\n```\n\nThe required packages are:\n\n- **maxframe** - MaxFrame SDK for distributed data processing\n- **pyodps** - ODPS Python SDK for MaxCompute access\n- **pandas** - Data manipulation library (for pandas-compatible APIs)\n\n## Environment Configuration\n\n### Required Environment Variables\n\nConfigure the following environment variables to authenticate with MaxCompute:\n\n| Variable | Description |\n|----------|-------------|\n| `ODPS_ACCESS_ID` | MaxCompute access ID (username) |\n| `ODPS_ACCESS_KEY` | MaxCompute access key (password) |\n| `ODPS_PROJECT` | MaxCompute project name |\n| `ODPS_ENDPOINT` | MaxCompute endpoint URL |\n\n### Setting Environment Variables\n\n#### Option 1: Set in Shell\n\n```bash\nexport ODPS_ACCESS_ID=\"your_access_id\"\nexport ODPS_ACCESS_KEY=\"your_access_key\"\nexport ODPS_PROJECT=\"your_project_name\"\nexport ODPS_ENDPOINT=\"your_endpoint\"\n```\n\n#### Option 2: Use .env File\n\nCreate a `.env` file in your project directory:\n\n```env\nODPS_ACCESS_ID=your_access_id\nODPS_ACCESS_KEY=your_access_key\nODPS_PROJECT=your_project_name\nODPS_ENDPOINT=your_endpoint\n```\n\nThen load the environment variables in Python:\n\n```python\nfrom dotenv import load_dotenv\n\nload_dotenv()\n```\n\n### Find Your MaxCompute Endpoint\n\nMaxCompute endpoints vary by region, check the [MaxCompute documentation](https://www.alibabacloud.com/help/zh/maxcompute/user-guide/endpoints?spm=a2c63.p38356.help-menu-search-27797.d_0) for the correct endpoint for your region.\n\n## Installation Verification\n\nVerify your installation by running the following Python script:\n\n```python\nimport os\nfrom dotenv import load_dotenv\nfrom odps import ODPS\nfrom maxframe.session import new_session\n\n# Load environment variables\nload_dotenv()\n\n# Create ODPS connection\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOINT\"),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n\n# Create MaxFrame session\nsession = new_session(o)\n\nprint(\"MaxFrame installation verified successfully!\")\nprint(f\"Connected to project: {o.project}\")\n\n# Destroy session when done\nsession.destroy()\n```\n\n## Session Setup\n\n### Manual Session Creation\n\nCreate a session with explicit credentials:\n\n```python\nimport os\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\n# Create ODPS connection\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOINT\"),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n\n# Create MaxFrame session\nsession = new_session(o)\n```\n\n### Auto-Detect from Environment\n\nIn environments like DataWorks or MaxCompute Notebook, ODPS credentials are automatically available:\n\n```python\nfrom maxframe.session import new_session\n\n# Auto-detects ODPS from environment\nsession = new_session()\n```\n\n\n## Troubleshooting\n\n### Common Issues\n\n#### Issue: Connection Authentication Failed\n\n**Symptoms**: Error message indicating invalid credentials or authentication failure.\n\n**Solutions**:\n- Verify all environment variables are set correctly\n- Check that your access key has not expired\n- Ensure you have the correct endpoint for your region\n- Verify your project name is accurate\n\n```bash\n# Test environment variables\necho $ODPS_ACCESS_ID\necho $ODPS_PROJECT\necho $ODPS_ENDPOINT\n```\n\n#### Issue: Package Installation Fails\n\n**Symptoms**: `pip install` fails with dependency conflicts or permission errors.\n\n**Solutions**:\n- Use a virtual environment to isolate dependencies:\n\n```bash\npython -m venv maxframe_env\nsource maxframe_env/bin/activate # On Windows: maxframe_env\\Scripts\\activate\npip install maxframe pyodps pandas --prefer-binary\n```\n\n- Upgrade pip before installing:\n\n```bash\npip install --upgrade pip\npip install maxframe pyodps pandas --prefer-binary\n```\n\n#### Issue: Session Creation Fails\n\n**Symptoms**: `new_session()` raises an exception.\n\n**Solutions**:\n- Verify network connectivity to the MaxCompute endpoint\n- Check firewall rules allow outbound connections\n- Ensure your MaxCompute account has the necessary permissions\n- Try the auto-detect method if available in your environment\n- Use VPC endpoint if you are in vpc networking\n\n#### Issue: Lazy Execution Not Working\n\n**Symptoms**: Operations appear to do nothing until `.execute()` is called.\n\n**Note**: This is expected behavior. MaxFrame uses lazy execution. Always call `.execute()` to trigger computation:\n\n```python\n# This does not execute immediately\nresult = df.groupby('category').sum()\n\n# Execute the computation\nresult.execute()\n```\n\n### Getting Help\n\nIf you encounter issues not covered here:\n\n1. Check the [MaxFrame Documentation](https://maxframe.readthedocs.io/en/latest/)\n2. Review the [MaxFrame Client Repository](https://github.com/aliyun/alibabacloud-odps-maxframe-client.git)\n3. Consult the sample code in `assets/examples/` for working examples\n4. Contact your MaxCompute administrator for account-specific issues\n\n## Next Steps\n\nAfter successful installation:\n\n1. Review the [MaxFrame Context Guide](maxframe-context.md) for comprehensive feature documentation\n2. Explore the [sample code](../assets/examples/) for working examples\n3. Start building your first MaxFrame program using the [Common Workflow](../SKILL.md#common-workflow)\n\n## Cleanup\n\nDestroy your session when done to free resources:\n\n```python\nsession.destroy()\n```\n\nFile v0.0.1:references/local-debug-guide.md\n\n# MaxFrame Local Debug Mode Guide\n\nThis guide provides comprehensive instructions for using MaxFrame's local debug mode, which enables offline UDF development with full IDE debugging support.\n\n## Overview\n\nMaxFrame Local Debug Mode is designed for data development engineers to debug UDF (User-Defined Functions) locally without connecting to remote MaxCompute services. It provides a seamless development experience with IDE breakpoint support for functions like `apply()` and `apply_chunk()`.\n\n## Core Value\n\n| Feature | Traditional Approach | Local Debug Mode |\n|---------|---------------------|------------------|\n| Breakpoint Debugging | ❌ Not supported | ✅ Full IDE support |\n| Remote Dependency | ❌ Requires cluster connection | ✅ Completely offline |\n| Debug Cycle | ❌ Submit to remote each time | ✅ Local immediate execution |\n| Code Changes | ❌ Multiple code versions | ✅ Same code for dev/prod |\n\n### Key Benefits\n\n1. **Zero-Configuration Startup**: Simply use `debug=True` or `debug=\"local\"` - no additional tools or services required\n2. **Completely Offline**: No dependency on network or remote cluster resources\n3. **Native IDE Support**: Breakpoints, variable inspection, step-by-step execution - all debugging capabilities preserved\n4. **Flexible Data Sources**: Support for in-memory data, local files, or MaxCompute tables\n5. **Seamless Production Switch**: Remove `debug=True` parameter and code runs directly in production\n\n## When to Use Local Debug Mode\n\nUse local debug mode when:\n- Developing UDF functions (`apply`, `apply_chunk`)\n- Need IDE breakpoints and step-by-step debugging\n- Want to debug offline without network access\n- Working on complex logic that requires iterative testing\n- Need to verify data transformation logic quickly\n\n**Use remote debug mode instead when:**\n- Testing with production-scale data on MaxCompute\n- Need to verify execution on actual cluster\n- Investigating runtime issues that require logview URLs\n- Debugging distributed execution problems\n\n## Quick Start\n\n### Prerequisites\n\n```bash\npip install --upgrade maxframe # Requires MaxFrame SDK 2.5.0 or later\n```\n\n### Basic Example\n\n```python\nfrom odps import ODPS\nfrom maxframe import new_session\nimport maxframe.dataframe as md\nimport pandas as pd\n\n# Initialize ODPS object\n# Note: In local debug mode, ODPS object is only used for schema validation\n# Actual credentials are not used for execution\no = ODPS(\n access_id=os.getenv('ODPS_ACCESS_ID', 'dummy_access_id'),\n secret_access_key=os.getenv('ODPS_ACCESS_KEY', 'dummy_secret_key'),\n project=os.getenv('ODPS_PROJECT', 'dummy_project'),\n endpoint=os.getenv('ODPS_ENDPOINT', 'dummy_endpoint'),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n\n# Enable local debug mode\nsession = new_session(o, debug=True)\n\n# Prepare sample data\ndf = md.DataFrame(pd.DataFrame({\n \"sales\": [5000, 8000, 12000, 3000],\n \"region\": [\"A\", \"B\", \"C\", \"D\"]\n}))\n\ndef calculate_commission(row):\n sales = row['sales']\n if sales > 10000: # Set breakpoint here\n rate = 0.15\n print(rate)\n elif sales > 5000: # Set breakpoint here\n rate = 0.10\n print(rate)\n else:\n rate = 0.05\n return sales * rate\n\n# Execute and get results\nresult = df.apply(calculate_commission, axis=1).execute().fetch()\nprint(result)\n```\n\n## Key Features\n\n### 1. Zero-Configuration Startup\n\nSimply add `debug=True` or `debug=\"local\"` when creating a session:\n\n```python\n# Local debug mode\nsession = new_session(o, debug=True)\n# or\nsession = new_session(o, debug=\"local\")\n\n# Production mode (just remove debug parameter)\nsession = new_session(o)\n```\n\n### 2. IDE-Friendly Debugging\n\n- **Supported IDEs**: PyCharm, VSCode, and other mainstream IDEs, as well as DataWorks Notebook\n- **Breakpoints**: Set breakpoints anywhere in your UDF functions\n- **Step-by-Step Execution**: Use F5/F6/F7/F8 to navigate through code\n- **Variable Inspection**: View and modify variables during debugging\n- **Debugging Experience**: Identical to local Python development\n\n### 3. Multiple Data Sources\n\n| Data Source Type | Access Method | Use Case |\n|-----------------|---------------|----------|\n| In-Memory Data | `md.DataFrame(pd.DataFrame())` | Quick logic validation |\n| MaxCompute Table | `md.read_odps_table()` | Real data testing |\n| Local Files | `pd.read_csv()` and other native Pandas interfaces | Offline development |\n\n**Example with different data sources:**\n\n```python\n# 1. In-memory data (fastest for testing)\nimport pandas as pd\ndf = md.DataFrame(pd.DataFrame({\n \"col1\": [1, 2, 3],\n \"col2\": [\"a\", \"b\", \"c\"]\n}))\n\n# 2. MaxCompute table (real data)\ndf = md.read_odps_table(\"your_table_name\")\n\n# 3. Local file (offline development)\nlocal_df = pd.read_csv(\"local_data.csv\")\ndf = md.read_pandas(local_df)\n```\n\n### 4. Code Compatibility\n\nDebugging code is identical to production code. Simply remove the `debug` parameter when deploying:\n\n```python\n# Development environment\nsession = new_session(o, debug=True)\n# ... your code ...\n\n# Production environment\nsession = new_session(o)\n# ... same code ...\n```\n\n## Application Scenarios\n\n| Scenario | Description |\n|----------|-------------|\n| UDF Logic Development | Real-time debugging and verification when writing complex business logic |\n| Data Transformation Testing | Validate data cleaning and transformation rules |\n| Problem Investigation | Identify root causes of UDF execution exceptions |\n| Offline Development | Continue development work in environments without network access |\n\n## Important Considerations\n\n### 1. Performance Differences\n\nLocal debug mode is designed for development and verification. Performance characteristics differ from production environment:\n- Execution happens locally, not distributed\n- Performance is not representative of production cluster performance\n- Best suited for small-scale sample data\n\n### 2. Data Volume Limitations\n\nFor optimal debugging experience:\n- Use small-scale sample data (recommended: 100-1000 rows)\n- Large datasets may slow down local execution\n- Focus on logic correctness rather than performance\n\n### 3. Dependency Consistency\n\nEnsure local Python environment matches production:\n- Same Python version\n- Same package versions (maxframe, pandas, numpy, etc.)\n- Use `pip freeze > requirements.txt` to capture dependencies\n\n### 4. Sensitive Data Handling\n\nWhen debugging with MaxCompute tables:\n- Be aware of data permissions and access controls\n- Consider data masking for sensitive information\n- Use sample/partitioned data to limit exposure\n- Never commit sensitive credentials to version control\n\n## Common Debugging Patterns\n\n### Pattern 1: Breakpoint in Apply Function\n\n```python\ndef process_row(row):\n # Set breakpoint on this line\n value = row['column_name']\n\n if value > threshold:\n # Set breakpoint here to inspect condition\n result = transform(value)\n else:\n result = default_value\n\n return result\n\ndf = md.DataFrame(sample_data)\nresult = df.apply(process_row, axis=1).execute().fetch()\n```\n\n### Pattern 2: Debugging Apply_Chunk for Batch Processing\n\n```python\ndef process_batch(chunk):\n # Set breakpoint here to inspect entire chunk\n print(f\"Processing batch with {len(chunk)} rows\")\n\n # Debug data types\n print(f\"Chunk dtypes:\\n{chunk.dtypes}\")\n\n # Debug transformations\n chunk['new_col'] = chunk['col1'] * 2\n\n # Set breakpoint here to verify results\n return chunk\n\nresult = df.mf.apply_chunk(\n process_batch,\n batch_rows=100,\n output_type='dataframe'\n).execute().fetch()\n```\n\n### Pattern 3: Debugging with Print Statements\n\n```python\ndef debug_function(row):\n print(f\"Input row: {row.to_dict()}\")\n\n # Step 1\n intermediate = row['col1'] + row['col2']\n print(f\"After step 1: {intermediate}\")\n\n # Step 2\n result = intermediate * 2\n print(f\"Final result: {result}\")\n\n return result\n\n# Execute with debug output\nresult = df.apply(debug_function, axis=1).execute().fetch()\n```\n\n## Transitioning to Production\n\n### Steps to Deploy\n\n1. **Test Locally**: Develop and debug with local debug mode\n2. **Verify Logic**: Ensure all transformations work correctly\n3. **Remove Debug Parameter**: Change `new_session(o, debug=True)` to `new_session(o)`\n4. **Test on Cluster**: Run on MaxCompute with small dataset\n5. **Production Deploy**: Deploy to production environment\n\n### Code Checklist\n\nBefore deploying to production:\n- [ ] Remove `debug=True` parameter from session creation\n- [ ] Verify all data source paths are correct for production\n- [ ] Test with production-scale data on MaxCompute\n- [ ] Remove or reduce print statements used for debugging\n- [ ] Add proper error handling and logging\n- [ ] Verify resource quotas and permissions\n\n## Troubleshooting\n\n### Issue: IDE Breakpoints Not Triggering\n\n**Possible Causes:**\n- Session created without `debug=True`\n- Using incompatible IDE or debugger\n- Code not actually executing through apply/apply_chunk\n\n**Solutions:**\n- Verify `debug=True` in `new_session()`\n- Ensure you're using a supported IDE (PyCharm, VSCode)\n- Check that `.execute()` is called to trigger execution\n\n### Issue: Local Execution Too Slow\n\n**Possible Causes:**\n- Dataset too large for local debugging\n- Complex operations not optimized for local execution\n\n**Solutions:**\n- Reduce sample data size (use `df.head(100)` or sample)\n- Simplify operations for debugging purposes\n- Focus on specific problematic code sections\n\n### Issue: Results Differ from Production\n\n**Possible Causes:**\n- Data differences between sample and production data\n- Environmental differences (Python version, package versions)\n- Distributed vs. local execution semantics\n\n**Solutions:**\n- Verify data consistency between environments\n- Check Python and package versions match\n- Test on MaxCompute with `debug=False` to verify\n\n## Summary\n\nLocal debug mode provides a powerful development experience for MaxFrame UDF development:\n- Zero-configuration startup with `debug=True`\n- Full IDE debugging support with breakpoints\n- Flexible data source options\n- Seamless transition to production\n- Perfect for iterative UDF development\n\nUse local debug mode during development for rapid iteration, then switch to remote debug mode for cluster-based testing and validation.\n\n## Resources\n\n- **MaxFrame Context Guide**: `./maxframe-context.md` - Comprehensive MaxFrame features and workflows\n- **Interactive Coding Guide**: `./remote-debug-guide.md` - Remote debug mode with logview support\n- **Key Modules Reference**: `./key-modules.md` - DataFrame, Tensor, and ML operations\n\nFile v0.0.1:references/maxframe-client-docs/getting_started/comparison/index.md\n\n# Comparison with other tools\n\n* [Comparison with PyODPS DataFrame](pyodps_df.md)\n * [Object abstraction](pyodps_df.md#object-abstraction)\n * [Functions](pyodps_df.md#functions)\n * [Execution](pyodps_df.md#execution)\n\nFile v0.0.1:references/maxframe-client-docs/getting_started/comparison/pyodps_df.md\n\n# Comparison with PyODPS DataFrame\n\n[PyODPS DataFrame](https://pyodps.readthedocs.io/en/stable/df.html) is\na DataFrame-like package provided by MaxCompute as a part of PyODPS package.\nIt provides capability for Python data analyzers to query MaxCompute data\nwith a set of operators similar to pandas. Despite the similarity in operators,\nthe usage between two sets of APIs are quite different. It might not be easy\nfor a developer to dive deep into PyODPS DataFrame with knowledge about\npandas only.\n\nThough PyODPS DataFrame is still part of PyODPS, it is recommended to create\nnew applications with MaxFrame to enjoy its compatibility with pandas.\n\n## Object abstraction\n\nPyODPS DataFrame does not have indexes. This means that a majority of pandas\nAPIs with indexes cannot be used or not fully supported.\n\nFor instance, arithmetic operations in pandas relies on index alignment. That\nis, two DataFrames are aligned first, and then arithmetic operation is performed.\n\n```python\n>>> series1 = pd.Series([2, 1, 3], index=[1, 2, 4])\n>>> series2 = pd.Series([1, 5, 6], index=[1, 3, 4])\n>>> series1 + series2\n1 3.0\n2 NaN\n3 NaN\n4 9.0\ndtype: float64\n```\n\nHowever, when indexes are absent, this kind of operation is not supported.\n\nTo support this kind of operation, in MaxFrame, it is required to add an index\ncolumn to DataFrame or Series. If the index is absent, a default RangeIndex\nis added. Therefore the statement above can be supported.\n\nAnother huge difference between PyODPS DataFrame and MaxFrame is that in PyODPS\nDataFrame, representation of data objects and operators are mixed, and this\nmay confuse newcomers. For instance,\n\n```python\ndf = o.get_table('table_name').to_df() # df is a DataFrame instance\ndf2 = df[\"col1\", \"col2\"] # df2 is a CollectionExpr instance\n```\n\nIn the second line, `df2` is an instance of `CollectionExpr` which means\nit is an expression and different from a `DataFrame` instance. However, all\nDataFrame functions can be applied directly onto `df2` and there is nothing\ndifferent from `DataFrame` instance.\n\nIn MaxFrame, however, data objects and operators are defined separately. Data\nobjects users interact with are all instances of a few data classes, namely\n`DataFrame`, `Series` or `Index`. For the example above, now all\ninstances are DataFrame now.\n\n```python\ndf = md.read_odps_table('table_name') # df is a DataFrame instance\ndf2 = df[[\"col1\", \"col2\"]] # df2 is also a DataFrame instance\n```\n\n## Functions\n\nFunctions in PyODPS DataFrame are not fully compatible with pandas. Therefore\nto write code with PyODPS DataFrame, users need to read the documents first\nbefore start coding. However, the target of MaxFrame is to create a pandas-compatible\nAPI. Hence there are API differences between PyODPS DataFrame and MaxFrame.\nThese differences are listed below. Methods starts with `mf.` mean that these non-pandas\nmethods are added in MaxFrame to facilitate migrating from PyODPS DataFrame to MaxFrame.\nNote that you need to read API documents of these functions before rewriting your code.\n\n| PyODPS DataFrame API | MaxFrame API |\n|-------------------------------------|-------------------------------------------------|\n| DataFrame.append_id | Not needed. DataFrame index is added by default |\n| DataFrame.bloom_filter | Not implemented yet |\n| DataFrame.boxplot | DataFrame.plot.boxplot |\n| DataFrame.concat | maxframe.dataframe.concat |\n| DataFrame.describe | DataFrame.describe |\n| DataFrame.distinct | DataFrame.drop_duplicates |\n| DataFrame.except_ | DataFrame.merge with filter |\n| DataFrame.exclude | DataFrame.drop |\n| DataFrame.extract_kv | Not implemented yet |\n| DataFrame.hist | DataFrame.plot.hist |\n| DataFrame.inner_join | DataFrame.merge |\n| DataFrame.intersect | DataFrame.merge |\n| DataFrame.left_join | DataFrame.merge |\n| DataFrame.limit | DataFrame.head |\n| DataFrame.map_reduce | DataFrame.mf.map_reduce |\n| DataFrame.minmax_scale | Not implemented yet |\n| DataFrame.outer_join | DataFrame.merge |\n| DataFrame.persist | DataFrame.to_odps_table |\n| DataFrame.reshuffle | DataFrame.mf.reshuffle |\n| DataFrame.right_join | DataFrame.merge |\n| DataFrame.setdiff | DataFrame.merge |\n| DataFrame.split | Not implemented yet |\n| DataFrame.std_scale | Not implemented yet |\n| DataFrame.sort | DataFrame.sort_values |\n| DataFrame.switch | maxframe.dataframe.case_when |\n| DataFrame.to_kv | Not implemented yet |\n| DataFrame.union | maxframe.dataframe.concat |\n| DatetimeSequenceExpr.date | Series.dt.date |\n| DatetimeSequenceExpr.day | Series.dt.day |\n| DatetimeSequenceExpr.dayofweek | Series.dt.dayofweek |\n| DatetimeSequenceExpr.dayofyear | Series.dt.dayofyear |\n| DatetimeSequenceExpr.hour | Series.dt.hour |\n| DatetimeSequenceExpr.is_month_end | Series.dt.is_month_end |\n| DatetimeSequenceExpr.is_month_start | Series.dt.is_month_start |\n| DatetimeSequenceExpr.is_year_end | Series.dt.is_year_end |\n| DatetimeSequenceExpr.is_year_start | Series.dt.is_year_start |\n| DatetimeSequenceExpr.microsecond | Series.dt.microsecond |\n| DatetimeSequenceExpr.min | Series.dt.min |\n| DatetimeSequenceExpr.minute | Series.dt.minute |\n| DatetimeSequenceExpr.month | Series.dt.month |\n| DatetimeSequenceExpr.second | Series.dt.second |\n| DatetimeSequenceExpr.strftime | Series.dt.strftime |\n| DatetimeSequenceExpr.unix_timestamp | Not implemented yet |\n| DatetimeSequenceExpr.week | Series.dt.week |\n| DatetimeSequenceExpr.weekday | Series.dt.weekday |\n| DatetimeSequenceExpr.weekofyear | Series.dt.weekofyear |\n| DatetimeSequenceExpr.year | Series.dt.year |\n| SequenceExpr.degrees | np.degrees(Series) |\n| SequenceExpr.radians | np.radians(Series) |\n| SequenceExpr.tolist | Series.to_numpy |\n| SequenceExpr.to_datetime | maxframe.dataframe.to_datetime |\n| SequenceExpr.topk | Not implemented yet |\n| SequenceExpr.trunc | np.trunc(Series) |\n| SequenceExpr.hll_count | Not implemented yet |\n| StringSequenceExpr.capitalize | Series.str.capitalize |\n| StringSequenceExpr.contains | Series.str.contains |\n| StringSequenceExpr.count | Series.str.count |\n| StringSequenceExpr.endswith | Series.str.endswith |\n| StringSequenceExpr.find | Series.str.find |\n| StringSequenceExpr.len | Series.str.len |\n| StringSequenceExpr.ljust | Series.str.ljust |\n| StringSequenceExpr.lower | Series.str.lower |\n| StringSequenceExpr.lstrip | Series.str.lstrip |\n| StringSequenceExpr.pad | Series.str.pad |\n| StringSequenceExpr.repeat | Series.str.repeat |\n| StringSequenceExpr.replace | Series.str.replace |\n| StringSequenceExpr.rfind | Series.str.rfind |\n| StringSequenceExpr.rjust | Series.str.rjust |\n| StringSequenceExpr.rstrip | Series.str.rstrip |\n| StringSequenceExpr.slice | Series.str.slice |\n| StringSequenceExpr.startswith | Series.str.startswith |\n| StringSequenceExpr.strip | Series.str.strip |\n| StringSequenceExpr.swapcase | Series.str.swapcase |\n| StringSequenceExpr.title | Series.str.title |\n| StringSequenceExpr.translate | Series.str.translate |\n| StringSequenceExpr.upper | Series.str.upper |\n| StringSequenceExpr.zfill | Series.str.zfill |\n| StringSequenceExpr.isalnum | Series.str.isalnum |\n| StringSequenceExpr.isalpha | Series.str.isalpha |\n| StringSequenceExpr.isdigit | Series.str.isdigit |\n| StringSequenceExpr.isspace | Series.str.isspace |\n| StringSequenceExpr.islower | Series.str.islower |\n| StringSequenceExpr.isupper | Series.str.isupper |\n| StringSequenceExpr.istitle | Series.str.istitle |\n| StringSequenceExpr.isnumeric | Series.str.isnumeric |\n| StringSequenceExpr.isdecimal | Series.str.isdecimal |\n\n## Execution\n\nPyODPS DataFrame and MaxFrame both use lazy execution to leverage efficiency\nof code optimization. However, the way to invoke these jobs is changed.\n\nFile v0.0.1:references/maxframe-client-docs/getting_started/index.md\n\n\n\n# Getting Started\n\n* [Access and installation](installation.md)\n * [Enable MaxFrame for your MaxCompute project](installation.md#enable-maxframe-for-your-maxcompute-project)\n * [Install MaxFrame client locally](installation.md#install-maxframe-client-locally)\n * [Access MaxFrame with DataWorks](installation.md#access-maxframe-with-dataworks)\n * [Access MaxFrame with MaxCompute Notebook](installation.md#access-maxframe-with-maxcompute-notebook)\n* [Overview](overview.md)\n* [Getting started tutorials](tutorials/index.md)\n * [10 minutes to MaxFrame](tutorials/10min.md)\n* [Comparison with other tools](comparison/index.md)\n * [Comparison with PyODPS DataFrame](comparison/pyodps_df.md)\n\nFile v0.0.1:references/maxframe-client-docs/getting_started/installation.md\n\n# Access and installation\n\n## Enable MaxFrame for your MaxCompute project\n\nYou need to setup a MaxCompute project Before using MaxFrame. Please take a look at\n[here](https://www.alibabacloud.com/zh/product/maxcompute) for more information.\n\n#### NOTE\nCurrently MaxFrame is under trial. If you need to enable MaxFrame for your MaxCompute\nproject, please [fill the form to apply for trial](https://survey.aliyun.com/apps/zhiliao/m40AIrxhA?spm=a2c4g.11186623.0.0.a69340f2mJENKJ) here.\n\n## Install MaxFrame client locally\n\nAfter created your own MaxCompute project and enabled MaxFrame, you may install\nMaxFrame client with pip command:\n\n```bash\npip install maxframe\n```\n\nThen you can create a MaxCompute table, perform some transformation with MaxFrame\nand then store the result into another MaxCompute table.\n\n```python\nimport maxframe.dataframe as md\nfrom odps import ODPS\nfrom maxframe import new_session\n\n# create MaxCompute entrance object and test table\no = ODPS(\n access_id=os.getenv('ODPS_ACCESS_ID'),\n secret_access_key=os.getenv('ODPS_ACCESS_KEY'),\n project='your-default-project',\n endpoint='your-end-point',\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\ntable = o.create_table(\"test_source_table\", \"a string, b bigint\")\nwith table.open_writer() as writer:\n writer.write([\n [\"value1\", 0],\n [\"value2\", 1],\n ])\n\n# create maxframe session\nsession = new_session(o)\n\n# perform data transformation\ndf = md.read_odps_table(\"test_source_table\")\ndf[\"a\"] = \"prefix_\" + df[\"a\"]\nmd.to_odps_table(df, \"test_prefix_source_table\").execute()\n\n# destroy maxframe session\nsession.destroy()\n```\n\n## Access MaxFrame with DataWorks\n\nDataWorks provides task scheduling capability for MaxCompute projects. You can schedule\nand run MaxFrame job with DataWorks.\n\nTo run MaxFrame job with DataWorks, you need to create a PyODPS 3 node and write your code\ninside it. PyODPS nodes are executed with embedded MaxCompute accounts and project information,\nthus you may create your MaxFrame session directly.\n\n```python\nimport maxframe.dataframe as md\nfrom maxframe import new_session\n\n# create maxframe session\nsession = new_session(o)\n\n# perform data transformation\ndf = md.read_odps_table(\"test_source_table\")\ndf[\"a\"] = \"prefix_\" + df[\"a\"]\nmd.to_odps_table(df, \"test_prefix_source_table\").execute()\n\n# destroy maxframe session\nsession.destroy()\n```\n\n## Access MaxFrame with MaxCompute Notebook\n\n[MaxCompute Notebook](https://help.aliyun.com/zh/maxcompute/user-guide/maxcompute-notebook-instruction)\nalso provides MaxFrame package. It also provides MaxCompute account in environment variables\nin the notebook, thus account information is not needed.\n\n```python\nimport maxframe.dataframe as md\nfrom maxframe import new_session\n\n# create MaxCompute entrance object\no = ODPS(\n project='your-default-project',\n endpoint='your-end-point',\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n# create maxframe session\nsession = new_session(o)\n\n# perform data transformation\ndf = md.read_odps_table(\"test_source_table\")\ndf[\"a\"] = \"prefix_\" + df[\"a\"]\nmd.to_odps_table(df, \"test_prefix_source_table\").execute()\n\n# destroy maxframe session\nsession.destroy()\n```\n\nFile v0.0.1:references/maxframe-client-docs/getting_started/overview.md\n\n# Overview\n\nMaxFrame is a framework for large-scale data computation built on MaxCompute\nby Alibaba Cloud with API-compatibility for pandas. It intends to become\nan inplace replacement for Python users familiar with Numpy or Pandas APIs\nto utilize MaxCompute to run their code in a distributed environment.\n\nFile v0.0.1:references/maxframe-client-docs/getting_started/tutorials/10min.md\n\n# 10 minutes to MaxFrame\n\nHere, [movielens 100K](https://grouplens.org/datasets/movielens/100k/) is used\nas an example. Assume that three tables already exist, which are `maxframe_ml_100k_movies`\n(movie-related data), `maxframe_ml_100k_users` (user-related data), and\n`maxframe_ml_100k_ratings` (rating-related data).\n\nCreate a MaxFrame session object before starting the following steps:\n\n```python\nimport os\nfrom odps import ODPS\nfrom maxframe import new_session\n\n# Make sure environment variable ODPS_ACCESS_ID already set to Access Key ID of user\n# while environment variable ODPS_ACCESS_KEY set to Access Key Secret of user.\n# Not recommended to hardcode Access Key ID or Access Key Secret in your code.\no = ODPS(\n access_id=os.getenv('ODPS_ACCESS_ID'),\n secret_access_key=os.getenv('ODPS_ACCESS_KEY'),\n project='**your-project**',\n endpoint='**your-endpoint**',\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\nsession = new_session(o)\n```\n\nYou only need to use `read_odps_table` API to create a DataFrame object. For instance,\n\n```python\nimport maxframe.dataframe as md\n\nusers = md.read_odps_table('pyodps_ml_100k_users')\n```\n\nView columns of DataFrame and the types of the columns through the `dtypes` attribute,\nas shown in the following code:\n\n```python\n>>> users.dtypes\nuser_id int64\nage int64\nsex object\noccupation object\nzip_code object\ndtype: object\n```\n\nSimply view the representation of the object will automatically show the first and last\nrows of the DataFrame.\n\n```python\n>>> users\n user_id age sex occupation zip_code\n0 1 24 M technician 85711\n1 2 53 F other 94043\n2 3 23 M writer 32067\n3 4 24 M technician 43537\n4 5 33 F other 15213\n...\n5 6 42 M executive 98101\n6 7 57 M administrator 91344\n7 8 36 M administrator 05201\n8 9 29 M student 01002\n9 10 53 M lawyer 90703\n```\n\nYou can use the head method to obtain the first N data records for easy and quick data\npreview. For example:\n\n```python\n>>> users.head(10).execute().fetch()\n user_id age sex occupation zip_code\n0 1 24 M technician 85711\n1 2 53 F other 94043\n2 3 23 M writer 32067\n3 4 24 M technician 43537\n4 5 33 F other 15213\n5 6 42 M executive 98101\n6 7 57 M administrator 91344\n7 8 36 M administrator 05201\n8 9 29 M student 01002\n9 10 53 M lawyer 90703\n```\n\nYou can add a filter on the columns if you do not want to view all of them. For example:\n\n```python\n>>> users[['user_id', 'age']].head(5).execute().fetch()\n user_id age\n0 1 24\n1 2 53\n2 3 23\n3 4 24\n4 5 33\n```\n\nYou can also drop several columns. For example:\n\n```python\n>>> users.drop(columns=['zip_code', 'age']).head(5)\n user_id sex occupation\n0 1 M technician\n1 2 F other\n2 3 M writer\n3 4 M technician\n4 5 F other\n```\n\nWhen excluding some columns, you may want to obtain new columns through computation.\nFor example, add the sex_bool attribute and set it to True if sex is Male. Otherwise,\nset it to False. For example:\n\n```python\n>>> users = users.drop(['zip_code', 'sex'])\n>>> users[\"sex_bool\"] = users.sex == \"M\"\n>>> users.head(5).execute().fetch()\n user_id age occupation sex_bool\n0 1 24 technician True\n1 2 53 other False\n2 3 23 writer True\n3 4 24 technician True\n4 5 33 other False\n```\n\nObtain the number of persons at age of 20 to 25, as shown in the following code:\n\n```python\n>>> users[users.age.between(20, 25)].count().execute().fetch()\n195\n```\n\nObtain the numbers of male and female users, as shown in the following code:\n\n```python\n>>> users.groupby(users.sex).user_id.size()\nF 273\nM 670\ndtype: int64\n```\n\nTo divide users by job, obtain the first 10 jobs that have the largest population,\nand sort the jobs in the descending order of population. See the following:\n\n```python\n>>> df = users.groupby(\"occupation\").agg({\"user_id\": \"count\"})\n>>> df.sort_values(\"user_id\", ascending=False)[:10]\n user_id\noccupation\nstudent 196\nother 105\neducator 95\nadministrator 79\nengineer 67\nprogrammer 66\nlibrarian 51\nwriter 45\nexecutive 32\nscientist 31\n```\n\nDataFrame APIs provide the `value_counts` method to quickly achieve the same\nresult. An example is shown below.\n\n```python\n>>> uses.occupation.value_counts()[:10]\nstudent 196\nother 105\neducator 95\nadministrator 79\nengineer 67\nprogrammer 66\nlibrarian 51\nwriter 45\nexecutive 32\nscientist 31\ndtype: int64\n```\n\nShow data in a more intuitive graph, as shown in the following code:\n\n```python\n%matplotlib inline\n```\n\nUse a horizontal bar chart to visualize data, as shown in the following code:\n\n```python\n>>> users['occupation'].value_counts().plot(kind='barh', x='occupation', ylabel='prefession')\n\n```\n\n\\_images/df-value-count-plot.png\n\nDivide ages into 30 groups and view the histogram of age distribution,\nas shown in the following code:\n\n```python\n>>> users.age.hist(bins=30, title=\"Distribution of users' ages\", xlabel='age', ylabel='count of users')\n\n```\n\n\\_images/df-age-hist.png\n\nUse join to join the three tables and save the joined tables as a new table. For example:\n\n```python\n>>> movies = md.read_odps_table('pyodps_ml_100k_movies')\n>>> ratings = md.read_odps_table('pyodps_ml_100k_ratings')\n>>>\n>>> o.delete_table('pyodps_ml_100k_lens', if_exists=True)\n>>> lens = movies.join(ratings).join(users).persist('pyodps_ml_100k_lens')\n>>>\n>>> lens.dtypes\nodps.Schema {\nmovie_id int64\ntitle string\nrelease_date string\nvideo_release_date string\nimdb_url string\nuser_id int64\nrating int64\nunix_timestamp int64\nage int64\nsex string\noccupation string\nzip_code string\n}\n```\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nFile v0.0.1:references/maxframe-client-docs/getting_started/tutorials/index.md\n\n# Getting started tutorials\n\n* [10 minutes to MaxFrame](10min.md)\n\nFile v0.0.1:references/maxframe-client-docs/index.md\n\n\n\n# MaxFrame Documentation\n\nMaxFrame is a framework for large-scale data computation built on MaxCompute\nby Alibaba Cloud with API-compatibility for pandas. It intends to become\nan inplace replacement for Python users familiar with Numpy or Pandas APIs\nto utilize MaxCompute to run their code in a distributed environment.\n\nFile v0.0.1:references/maxframe-client-docs/reference/dataframe/frame.md\n\n\n\n# DataFrame\n\n## Constructor\n\n| [`DataFrame`](generated/maxframe.dataframe.DataFrame.md#maxframe.dataframe.DataFrame)([data, index, columns, dtype, ...]) | |\n|--------------------------------------------------------------------------------------------------------","readmeExcerpt":"Skill: Alibabacloud Odps Maxframe Coding Owner: sdk-team Summary: Use this skill for MaxFrame SDK development and documentation navigation on Alibaba Cloud MaxCompute (ODPS). Helps answer MaxFrame API, concept, official exa... Tags: latest:0.0.2 Version history: v0.0.2 | 2026-06-02T09:40:39.558Z | auto - Added support for MaxFrame documentation and API navigation—users can now ask questions about MaxFrame APIs, conce","codeSnippets":[],"executableExamples":[{"language":"python","snippet":"import os\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\n# Auto-detect from environment (preferred in DataWorks/MaxCompute Notebook)\nsession = new_session()"},{"language":"python","snippet":"import os\nimport dotenv\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\ndotenv.load_dotenv()\n\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOINT\"),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\nsession = new_session(o)"},{"language":"python","snippet":"import logging\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\n\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\nsession = new_session()\ntry:\n logger.info(f\"Session created. Logview: {session.get_logview_address()}\")\n # Your operations\n ...\nfinally:\n session.destroy()\n logger.info(\"Session destroyed\")"},{"language":"python","snippet":"# Read from MaxCompute table\ndf = md.read_odps_table(\"table_name\")\n\n# Read with index column\ndf = md.read_odps_table(\"table_name\", index_col=\"id\")\n\n# With column selection\ndf = md.read_odps_table(\"table_name\", columns=['id', 'value', 'timestamp'])\n\n# With partition filter\ndf = md.read_odps_table(\"table_name\", partition='ds=2024-01-01')"},{"language":"python","snippet":"# Read from SQL query with filters\ndf = md.read_odps_query(\n \"SELECT * FROM table WHERE date >= '2024-01-01' AND status = 'active'\"\n)\n\n# Complex SQL with joins\ndf = md.read_odps_query(\n \"SELECT a.*, b.value FROM table_a a JOIN table_b b ON a.id = b.id\"\n)"},{"language":"python","snippet":"import pandas as pd\nimport numpy as np\n\n# Time series analysis example\nexample_pd_df = pd.DataFrame({\n 'timestamp': pd.date_range('2026-01-01', periods=1000, freq='H'),\n 'metric_name': np.random.choice(['cpu', 'memory', 'disk'], 1000),\n 'value': np.random.randn(1000) * 10 + 50,\n 'host_id': np.random.choice(['host1', 'host2', 'host3'], 1000)\n})\n\n# Load into MaxFrame\ndf = md.read_pandas(example_pd_df)"}],"parameters":null,"dependencies":[],"permissions":[],"extractedFiles":[{"path":"references/common-workflow.md","content":"# Common Workflow Complete Guide\n\nDetailed guide for the complete MaxFrame development workflow with comprehensive examples.\n\n## Session Setup Patterns\n\n### Pattern 1: Auto-detect (DataWorks/MaxCompute Notebook)\n\n```python\nimport os\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\n# Auto-detect from environment (preferred in DataWorks/MaxCompute Notebook)\nsession = new_session()\n```\n\n### Pattern 2: Explicit ODPS Connection\n\n```python\nimport os\nimport dotenv\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\nfrom odps import ODPS\n\ndotenv.load_dotenv()\n\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOINT\"),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\nsession = new_session(o)\n```\n\n### Pattern 3: Production-ready Session\n\n```python\nimport logging\nimport maxframe.dataframe as md\nfrom maxframe.session import new_session\n\nlogging.basicConfig(level=logging.INFO)\nlogger = logging.getLogger(__name__)\n\nsession = new_session()\ntry:\n logger.info(f\"Session created. Logview: {session.get_logview_address()}\")\n # Your operations\n ...\nfinally:\n session.destroy()\n logger.info(\"Session destroyed\")\n```\n\n## Reading Data Patterns\n\n### Pattern 1: Basic Table Read\n\n```python\n# Read from MaxCompute table\ndf = md.read_odps_table(\"table_name\")\n\n# Read with index column\ndf = md.read_odps_table(\"table_name\", index_col=\"id\")\n\n# With column selection\ndf = md.read_odps_table(\"table_name\", columns=['id', 'value', 'timestamp'])\n\n# With partition filter\ndf = md.read_odps_table(\"table_name\", partition='ds=2024-01-01')\n```\n\n### Pattern 2: SQL Query Read\n\n```python\n# Read from SQL query with filters\ndf = md.read_odps_query(\n \"SELECT * FROM table WHERE date >= '2024-01-01' AND status = 'active'\"\n)\n\n# Complex SQL with joins\ndf = md.read_odps_query(\n \"SELECT a.*, b.value FROM table_a a JOIN table_b b ON a.id = b.id\"\n)\n```\n\n### Pattern 3: Sample Data Construction\n\nWhen user doesn't provide input table name, construct pandas DataFrame:\n\n```python\nimport pandas as pd\nimport numpy as np\n\n# Time series analysis example\nexample_pd_df = pd.DataFrame({\n 'timestamp': pd.date_range('2026-01-01', periods=1000, freq='H'),\n 'metric_name': np.random.choice(['cpu', 'memory', 'disk'], 1000),\n 'value': np.random.randn(1000) * 10 + 50,\n 'host_id': np.random.choice(['host1', 'host2', 'host3'], 1000)\n})\n\n# Load into MaxFrame\ndf = md.read_pandas(example_pd_df)\n```\n\n**Key guidelines for sample data:**\n- Match data types and structure to job requirements\n- Use realistic value ranges for the domain\n- Include 100-1000 rows to demonstrate logic\n- Use descriptive column names matching operations\n\n## Operator Selection Workflow\n\n### Step 1: Identify Required Operations\n\nBreak down the task into specific operations needed:\n- Filtering\n- Grouping\n- Aggreg"},{"path":"references/installation.md","content":"# MaxFrame Installation Guide\n\nThis guide provides step-by-step instructions for installing and configuring MaxFrame for distributed data processing on MaxCompute.\n\n## Table of Contents\n\n- [Prerequisites](#prerequisites)\n- [Dependencies](#dependencies)\n- [Environment Configuration](#environment-config)\n - [Required Environment Variables](#required-environment-variables)\n - [Setting Environment Variables](#setting-environment-variables)\n - [Find Your MaxCompute Endpoint](#find-your-maxcompute-endpoint)\n- [Installation Verification](#installation-verification)\n- [Session Setup](#session-setup)\n - [Manual Session Creation](#manual-session-creation)\n - [Auto-Detect from Environment](#auto-detect-from-environment)\n- [Troubleshooting](#troubleshooting)\n - [Common Issues](#common-issues)\n - [Getting Help](#getting-help)\n- [Next Steps](#next-steps)\n- [Cleanup](#cleanup)\n\n## Prerequisites\n\n- Python 3.7 or higher\n- MaxCompute (ODPS) account with valid credentials\n- Access to a MaxCompute project\n\n## Dependencies\n\nInstall the required Python packages:\n\n```bash\npip install maxframe -U\n```\n\nThe required packages are:\n\n- **maxframe** - MaxFrame SDK for distributed data processing\n- **pyodps** - ODPS Python SDK for MaxCompute access\n- **pandas** - Data manipulation library (for pandas-compatible APIs)\n\n## Environment Configuration\n\n### Required Environment Variables\n\nConfigure the following environment variables to authenticate with MaxCompute:\n\n| Variable | Description |\n|----------|-------------|\n| `ODPS_ACCESS_ID` | MaxCompute access ID (username) |\n| `ODPS_ACCESS_KEY` | MaxCompute access key (password) |\n| `ODPS_PROJECT` | MaxCompute project name |\n| `ODPS_ENDPOINT` | MaxCompute endpoint URL |\n\n### Setting Environment Variables\n\n#### Option 1: Set in Shell\n\n```bash\nexport ODPS_ACCESS_ID=\"your_access_id\"\nexport ODPS_ACCESS_KEY=\"your_access_key\"\nexport ODPS_PROJECT=\"your_project_name\"\nexport ODPS_ENDPOINT=\"your_endpoint\"\n```\n\n#### Option 2: Use .env File\n\nCreate a `.env` file in your project directory:\n\n```env\nODPS_ACCESS_ID=your_access_id\nODPS_ACCESS_KEY=your_access_key\nODPS_PROJECT=your_project_name\nODPS_ENDPOINT=your_endpoint\n```\n\nThen load the environment variables in Python:\n\n```python\nfrom dotenv import load_dotenv\n\nload_dotenv()\n```\n\n### Find Your MaxCompute Endpoint\n\nMaxCompute endpoints vary by region, check the [MaxCompute documentation](https://www.alibabacloud.com/help/zh/maxcompute/user-guide/endpoints?spm=a2c63.p38356.help-menu-search-27797.d_0) for the correct endpoint for your region.\n\n## Installation Verification\n\nVerify your installation by running the following Python script:\n\n```python\nimport os\nfrom dotenv import load_dotenv\nfrom odps import ODPS\nfrom maxframe.session import new_session\n\n# Load environment variables\nload_dotenv()\n\n# Create ODPS connection\no = ODPS(\n access_id=os.getenv(\"ODPS_ACCESS_ID\"),\n secret_access_key=os.getenv(\"ODPS_ACCESS_KEY\"),\n project=os.getenv(\"ODPS_PROJECT\"),\n endpoint=os.getenv(\"ODPS_ENDPOI"},{"path":"references/local-debug-guide.md","content":"# MaxFrame Local Debug Mode Guide\n\nThis guide provides comprehensive instructions for using MaxFrame's local debug mode, which enables offline UDF development with full IDE debugging support.\n\n## Overview\n\nMaxFrame Local Debug Mode is designed for data development engineers to debug UDF (User-Defined Functions) locally without connecting to remote MaxCompute services. It provides a seamless development experience with IDE breakpoint support for functions like `apply()` and `apply_chunk()`.\n\n## Core Value\n\n| Feature | Traditional Approach | Local Debug Mode |\n|---------|---------------------|------------------|\n| Breakpoint Debugging | ❌ Not supported | ✅ Full IDE support |\n| Remote Dependency | ❌ Requires cluster connection | ✅ Completely offline |\n| Debug Cycle | ❌ Submit to remote each time | ✅ Local immediate execution |\n| Code Changes | ❌ Multiple code versions | ✅ Same code for dev/prod |\n\n### Key Benefits\n\n1. **Zero-Configuration Startup**: Simply use `debug=True` or `debug=\"local\"` - no additional tools or services required\n2. **Completely Offline**: No dependency on network or remote cluster resources\n3. **Native IDE Support**: Breakpoints, variable inspection, step-by-step execution - all debugging capabilities preserved\n4. **Flexible Data Sources**: Support for in-memory data, local files, or MaxCompute tables\n5. **Seamless Production Switch**: Remove `debug=True` parameter and code runs directly in production\n\n## When to Use Local Debug Mode\n\nUse local debug mode when:\n- Developing UDF functions (`apply`, `apply_chunk`)\n- Need IDE breakpoints and step-by-step debugging\n- Want to debug offline without network access\n- Working on complex logic that requires iterative testing\n- Need to verify data transformation logic quickly\n\n**Use remote debug mode instead when:**\n- Testing with production-scale data on MaxCompute\n- Need to verify execution on actual cluster\n- Investigating runtime issues that require logview URLs\n- Debugging distributed execution problems\n\n## Quick Start\n\n### Prerequisites\n\n```bash\npip install --upgrade maxframe # Requires MaxFrame SDK 2.5.0 or later\n```\n\n### Basic Example\n\n```python\nfrom odps import ODPS\nfrom maxframe import new_session\nimport maxframe.dataframe as md\nimport pandas as pd\n\n# Initialize ODPS object\n# Note: In local debug mode, ODPS object is only used for schema validation\n# Actual credentials are not used for execution\no = ODPS(\n access_id=os.getenv('ODPS_ACCESS_ID', 'dummy_access_id'),\n secret_access_key=os.getenv('ODPS_ACCESS_KEY', 'dummy_secret_key'),\n project=os.getenv('ODPS_PROJECT', 'dummy_project'),\n endpoint=os.getenv('ODPS_ENDPOINT', 'dummy_endpoint'),\n user_agent='AlibabaCloud-Agent-Skills/alibabacloud-odps-maxframe-coding'\n)\n\n# Enable local debug mode\nsession = new_session(o, debug=True)\n\n# Prepare sample data\ndf = md.DataFrame(pd.DataFrame({\n \"sales\": [5000, 8000, 12000, 3000],\n \"region\": [\"A\", \"B\", \"C\", \"D\"]\n}))\n\ndef calculate_commission(row):\n sales = row['sales']"},{"path":"references/maxframe-client-docs/getting_started/comparison/index.md","content":"# Comparison with other tools\n\n* [Comparison with PyODPS DataFrame](pyodps_df.md)\n * [Object abstraction](pyodps_df.md#object-abstraction)\n * [Functions](pyodps_df.md#functions)\n * [Execution](pyodps_df.md#execution)"},{"path":"references/maxframe-client-docs/getting_started/comparison/pyodps_df.md","content":"# Comparison with PyODPS DataFrame\n\n[PyODPS DataFrame](https://pyodps.readthedocs.io/en/stable/df.html) is\na DataFrame-like package provided by MaxCompute as a part of PyODPS package.\nIt provides capability for Python data analyzers to query MaxCompute data\nwith a set of operators similar to pandas. Despite the similarity in operators,\nthe usage between two sets of APIs are quite different. It might not be easy\nfor a developer to dive deep into PyODPS DataFrame with knowledge about\npandas only.\n\nThough PyODPS DataFrame is still part of PyODPS, it is recommended to create\nnew applications with MaxFrame to enjoy its compatibility with pandas.\n\n## Object abstraction\n\nPyODPS DataFrame does not have indexes. This means that a majority of pandas\nAPIs with indexes cannot be used or not fully supported.\n\nFor instance, arithmetic operations in pandas relies on index alignment. That\nis, two DataFrames are aligned first, and then arithmetic operation is performed.\n\n```python\n>>> series1 = pd.Series([2, 1, 3], index=[1, 2, 4])\n>>> series2 = pd.Series([1, 5, 6], index=[1, 3, 4])\n>>> series1 + series2\n1 3.0\n2 NaN\n3 NaN\n4 9.0\ndtype: float64\n```\n\nHowever, when indexes are absent, this kind of operation is not supported.\n\nTo support this kind of operation, in MaxFrame, it is required to add an index\ncolumn to DataFrame or Series. If the index is absent, a default RangeIndex\nis added. Therefore the statement above can be supported.\n\nAnother huge difference between PyODPS DataFrame and MaxFrame is that in PyODPS\nDataFrame, representation of data objects and operators are mixed, and this\nmay confuse newcomers. For instance,\n\n```python\ndf = o.get_table('table_name').to_df() # df is a DataFrame instance\ndf2 = df[\"col1\", \"col2\"] # df2 is a CollectionExpr instance\n```\n\nIn the second line, `df2` is an instance of `CollectionExpr` which means\nit is an expression and different from a `DataFrame` instance. However, all\nDataFrame functions can be applied directly onto `df2` and there is nothing\ndifferent from `DataFrame` instance.\n\nIn MaxFrame, however, data objects and operators are defined separately. Data\nobjects users interact with are all instances of a few data classes, namely\n`DataFrame`, `Series` or `Index`. For the example above, now all\ninstances are DataFrame now.\n\n```python\ndf = md.read_odps_table('table_name') # df is a DataFrame instance\ndf2 = df[[\"col1\", \"col2\"]] # df2 is also a DataFrame instance\n```\n\n## Functions\n\nFunctions in PyODPS DataFrame are not fully compatible with pandas. Therefore\nto write code with PyODPS DataFrame, users need to read the documents first\nbefore start coding. However, the target of MaxFrame is to create a pandas-compatible\nAPI. Hence there are API differences between PyODPS DataFrame and MaxFrame.\nThese differences are listed below. Methods starts with `mf.` mean that these non-pandas\nmethods are added in MaxFrame to facilitate migrating from PyODPS DataFrame to MaxFrame.\nNote that you need to read API documents of "}],"languages":[],"docsSourceLabel":"CLAWHUB","editorialOverview":"Use this skill for MaxFrame SDK development and documentation navigation on Alibaba Cloud MaxCompute (ODPS). Helps answer MaxFrame API, concept, official exa... Skill: Alibabacloud Odps Maxframe Coding Owner: sdk-team Summary: Use this skill for MaxFrame SDK development and documentation navigation on Alibaba Cloud MaxCompute (ODPS). Helps answer MaxFrame API, concept, official exa... Tags: latest:0.0.2 Version history: v0.0.2 | 2026-06-02T09:40:39.558Z | auto - Added support for MaxFrame documentation and API navigation—users can now ask questions about MaxFrame APIs, conce","editorialQuality":{"score":100,"threshold":65,"status":"ready","wordCount":1373,"uniquenessScore":46,"reasons":[]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-10-09T05:30:50.389Z","emptyReason":"No screenshots, media assets, or demo links are available."},"primaryImageUrl":null,"mediaAssetCount":0,"assets":[],"demoUrl":null},"ownerResources":{"evidence":{"source":"unclaimed","verified":false,"confidence":"low","updatedAt":"2026-10-09T05:30:50.389Z","emptyReason":"This page has not been claimed by the agent owner."},"hasCustomPage":false,"customPageUpdatedAt":null,"customLinks":[],"structuredLinks":{"docsUrl":null,"demoUrl":null,"supportUrl":null,"pricingUrl":null,"statusUrl":null},"customPage":null},"relatedAgents":{"evidence":{"source":"protocol-neighbors","verified":false,"confidence":"medium","updatedAt":"2026-10-09T12:57:01.843Z","emptyReason":null},"items":[{"id":"b917f68a-ebff-438e-84f8-3f4b2494c0bc","entityType":"agent","canonicalPath":"/agent/activepieces-activepieces","slug":"activepieces-activepieces","name":"activepieces","description":"AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents","url":"https://github.com/activepieces/activepieces","homepage":"https://www.activepieces.com","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-15T02:22:12.426Z","createdAt":"2026-02-25T03:38:12.412Z","downloads":null},{"id":"5cb26759-3a39-483f-94cf-276a98c13bb8","entityType":"agent","canonicalPath":"/agent/cherryhq-cherry-studio","slug":"cherryhq-cherry-studio","name":"cherry-studio","description":"AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs","url":"https://github.com/CherryHQ/cherry-studio","homepage":"https://cherry-ai.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-11T14:38:40.986Z","createdAt":"2026-02-25T03:38:19.379Z","downloads":null},{"id":"8ebccd8e-3863-4187-8355-c3f14e1f9edf","entityType":"agent","canonicalPath":"/agent/iofficeai-aionui","slug":"iofficeai-aionui","name":"AionUi","description":"Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!","url":"https://github.com/iOfficeAI/AionUi","homepage":"https://www.aionui.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-10T18:48:31.762Z","createdAt":"2026-02-25T03:38:16.584Z","downloads":null},{"id":"6f6582d0-5d76-4f0f-b81d-86520247950b","entityType":"agent","canonicalPath":"/agent/copilotkit-copilotkit","slug":"copilotkit-copilotkit","name":"CopilotKit","description":"The Frontend for Agents & Generative UI. React + Angular","url":"https://github.com/CopilotKit/CopilotKit","homepage":"https://docs.copilotkit.ai","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-03-25T09:50:57.846Z","createdAt":"2026-02-25T03:39:14.617Z","downloads":null}],"links":{"hub":"/agent","source":"/agent/source/clawhub","protocols":[{"label":"OpenClaw","href":"/agent/protocol/openclew"}]}}}