[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7C2KXEZ35VN758NEFNRS3VV":3,"skill-same:01M7C2KXEZ35VN758NEFNRS3VV":45},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":6,"ownerHtmlUrl":29,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":30,"install":31,"resources":44},"01M7C2KXEZ35VN758NEFNRS3VV","python-scala-syntax-mapping",null,"Reference guide for translating Python syntax constructs to Scala equivalents. Use when converting Python code to Scala and need mappings for basic syntax elements like variable declarations, control flow, comprehensions, string formatting, and common operators.","linyouxue\u002Fskill-repair-benchmark","linyouxue","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F216151464?v=4","01M7BJEVCXKD74KH6FG9CBVSQB","林宥学","01M7BJEVE02NP217V93BKZFC0J",0,"Apache-2.0","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fevaluation\u002Fresults\u002FWML-Opus47-15Tasks-20260923\u002Ftasks\u002Fpython-scala-translation\u002Frepaired_run\u002Finputs\u002Fskills\u002Fpython-scala-syntax-mapping\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: python-scala-syntax-mapping\ndescription: Reference guide for translating Python syntax constructs to Scala equivalents. Use when converting Python code to Scala and need mappings for basic syntax elements like variable declarations, control flow, comprehensions, string formatting, and common operators.\n---\n\n# Python to Scala Syntax Mapping\n\n## Variable Declarations\n\n| Python | Scala |\n|--------|-------|\n| `x = 5` | `val x = 5` (immutable) or `var x = 5` (mutable) |\n| `x: int = 5` | `val x: Int = 5` |\n| `x, y = 1, 2` | `val (x, y) = (1, 2)` |\n\nPrefer `val` over `var` unless mutation is required.\n\n## Type Mappings\n\n| Python | Scala |\n|--------|-------|\n| `int` | `Int` |\n| `float` | `Double` |\n| `str` | `String` |\n| `bool` | `Boolean` |\n| `None` | `None` (of type `Option`) or `null` |\n| `list[T]` | `List[T]` or `Seq[T]` |\n| `dict[K, V]` | `Map[K, V]` |\n| `set[T]` | `Set[T]` |\n| `tuple[A, B]` | `(A, B)` or `Tuple2[A, B]` |\n| `Optional[T]` | `Option[T]` |\n\n## Control Flow\n\n### Conditionals\n\n```python\n# Python\nif x > 0:\n    result = \"positive\"\nelif x \u003C 0:\n    result = \"negative\"\nelse:\n    result = \"zero\"\n```\n\n```scala\n\u002F\u002F Scala - if is an expression\nval result = if (x > 0) \"positive\"\n             else if (x \u003C 0) \"negative\"\n             else \"zero\"\n```\n\n### Loops\n\n```python\n# Python for loop\nfor i in range(10):\n    print(i)\n\nfor item in items:\n    process(item)\n\nfor i, item in enumerate(items):\n    print(f\"{i}: {item}\")\n```\n\n```scala\n\u002F\u002F Scala equivalents\nfor (i \u003C- 0 until 10) println(i)\n\nfor (item \u003C- items) process(item)\n\nfor ((item, i) \u003C- items.zipWithIndex) println(s\"$i: $item\")\n```\n\n### While loops\n\n```python\n# Python\nwhile condition:\n    do_something()\n```\n\n```scala\n\u002F\u002F Scala\nwhile (condition) {\n  doSomething()\n}\n```\n\n## Comprehensions\n\n```python\n# Python list comprehension\nsquares = [x ** 2 for x in range(10)]\nevens = [x for x in numbers if x % 2 == 0]\npairs = [(x, y) for x in xs for y in ys]\n```\n\n```scala\n\u002F\u002F Scala for-comprehensions or map\u002Ffilter\nval squares = (0 until 10).map(x => x * x).toList\nval evens = numbers.filter(_ % 2 == 0)\nval pairs = for { x \u003C- xs; y \u003C- ys } yield (x, y)\n```\n\n## Functions\n\n```python\n# Python\ndef add(a: int, b: int) -> int:\n    return a + b\n\n# Lambda\nsquare = lambda x: x ** 2\n\n# Default arguments\ndef greet(name: str, greeting: str = \"Hello\") -> str:\n    return f\"{greeting}, {name}!\"\n```\n\n```scala\n\u002F\u002F Scala\ndef add(a: Int, b: Int): Int = a + b\n\n\u002F\u002F Lambda\nval square: Int => Int = x => x * x\n\u002F\u002F or shorter: val square = (x: Int) => x * x\n\n\u002F\u002F Default arguments\ndef greet(name: String, greeting: String = \"Hello\"): String =\n  s\"$greeting, $name!\"\n```\n\n### Python @overload and isinstance dispatch\n\nWhen a Python function declares several `typing.overload` signatures and its\nimplementation dispatches on `isinstance(...)` over a *closed* set of input\ntypes, the overloads are the specification of the public API surface, not\ndocumentation. Translate them to Scala's *static* dispatch mechanisms and\nreserve any `Any`-taking method for a documented lower-priority fallback.\n\nRecipe (apply in order; stop at the first that fits):\n\n1. **One overloaded Scala method per concrete `@overload` variant.** Let the\n   compiler pick by parameter type\u002Farity. This preserves type safety at every\n   call site and eliminates runtime class checks.\n2. **Model closed unions as a sealed ADT** (e.g. `str | bytes` →\n   `sealed trait StringOrBytes { case class Str(...) ; case class Bytes(...) }`)\n   and pattern-match exhaustively. The compiler warns on missing cases.\n3. **Translate `@runtime_checkable` Protocol variants to a type class** (e.g.\n   `trait Tokenizable[-A] { def toToken(a: A): String }`) with `implicit`\n   instances, so user types opt in without nominal inheritance.\n4. **Only if a genuine open-world fallback is required**, add a single\n   `Any`-taking helper under a *distinct name* (e.g. `tokenizeAny`) so it does\n   not shadow or ambiguate the typed overloads.\n\nAnti-pattern — collapsing every `@overload` into one `def f(value: Any)` whose\nbody is a `match` on runtime classes (`String`, `Array[Byte]`, `Int`, `Long`,\n`Double`, `LocalDate`, ..., catch-all `case other`). This loses static type\nchecking, forces callers through `Any`, and typically ambiguates any type-class\noverload added later.\n\n```python\n# Python\n@overload\ndef tokenize(self, value: str) -> Token: ...\n@overload\ndef tokenize(self, value: int) -> Token: ...\n@overload\ndef tokenize(self, value: datetime) -> Token: ...\n@overload\ndef tokenize(self, value: Tokenizable) -> Token: ...\n\ndef tokenize(self, value: Any) -> Token:\n    if isinstance(value, Tokenizable): ...\n    if isinstance(value, (str, bytes)): ...\n    if isinstance(value, (int, float, Decimal)): ...\n    if isinstance(value, (datetime, date)): ...\n    return Token(str(value), TokenType.STRING, {\"fallback\": True})\n```\n\n```scala\n\u002F\u002F Scala - one overload per concrete input type + ADT + type class\ndef tokenize(value: String): Token          = stringTokenizer.tokenize(value)\ndef tokenize(value: Long): Token             = numericTokenizer.tokenize(value)\ndef tokenize(value: Double): Token           = numericTokenizer.tokenize(value)\ndef tokenize(value: BigDecimal): Token       = numericTokenizer.tokenize(value)\ndef tokenize(value: LocalDate): Token        = temporalTokenizer.tokenize(value)\ndef tokenize(value: LocalDateTime): Token    = temporalTokenizer.tokenize(value)\ndef tokenize[A](value: A)(implicit ev: Tokenizable[A]): Token =\n  Token(ev.toToken(value), TokenType.STRUCTURED)\n\n\u002F\u002F Reserve Any-dispatch only as a documented, distinctly named fallback.\ndef tokenizeAny(value: Any): Token = value match {\n  case null                     => Token(\"NULL\", TokenType.NULL)\n  case s: String                => tokenize(s)\n  case l: Long                  => tokenize(l)\n  case d: Double                => tokenize(d)\n  case dt: LocalDateTime        => tokenize(dt)\n  case d: LocalDate             => tokenize(d)\n  case other                    => Token(other.toString, TokenType.STRING, Map(\"fallback\" -> true))\n}\n```\n\nVerification before finishing the translation:\n- Grep the produced Scala for `: Any)` in public method signatures; each\n  occurrence must correspond to an intentional, distinctly named fallback and\n  not shadow the typed overloads.\n- Confirm each `@overload` signature in the Python source has a matching\n  Scala method with a concrete parameter type (or is subsumed by a type-class\n  overload).\n- If a call `tokenize(x)` is ambiguous between the type-class overload and an\n  `Any` overload, resolve it by renaming the `Any` method — **do not** weaken\n  the type class to a subtype trait, which loses ad-hoc polymorphism for types\n  the caller cannot modify.\n\nDo not apply this recipe to Python functions that genuinely accept arbitrary\n`object` with no `@overload` contract (e.g. `__repr__`-style debug helpers);\nthere a single `Any`\u002F`AnyRef` method with a `match` is acceptable.\n\n## String Formatting\n\n| Python | Scala |\n|--------|-------|\n| `f\"Hello, {name}!\"` | `s\"Hello, $name!\"` |\n| `f\"Value: {x:.2f}\"` | `f\"Value: $x%.2f\"` |\n| `f\"{x + y}\"` | `s\"${x + y}\"` |\n\n## Common Operators\n\n| Python | Scala |\n|--------|-------|\n| `**` (power) | `math.pow(x, y)` or use `scala.math.pow` |\n| `\u002F\u002F` (floor div) | `x \u002F y` (for Int) or `math.floor(x \u002F y)` |\n| `%` (modulo) | `%` |\n| `and`, `or`, `not` | `&&`, `||`, `!` |\n| `in` | `.contains()` |\n| `is` | `eq` (reference equality) |\n| `==` | `==` (value equality) |\n\n## Exception Handling\n\n```python\n# Python\ntry:\n    result = risky_operation()\nexcept ValueError as e:\n    handle_error(e)\nfinally:\n    cleanup()\n```\n\n```scala\n\u002F\u002F Scala\nimport scala.util.{Try, Success, Failure}\n\n\u002F\u002F Pattern 1: try-catch\ntry {\n  val result = riskyOperation()\n} catch {\n  case e: IllegalArgumentException => handleError(e)\n} finally {\n  cleanup()\n}\n\n\u002F\u002F Pattern 2: Try monad (preferred for functional style)\nval result = Try(riskyOperation()) match {\n  case Success(value) => value\n  case Failure(e) => handleError(e)\n}\n```\n\n## None\u002FNull Handling\n\n```python\n# Python\nif value is None:\n    return default\nreturn process(value)\n\n# Or\nresult = value if value is not None else default\n```\n\n```scala\n\u002F\u002F Scala - use Option\nval result = optionValue match {\n  case Some(v) => process(v)\n  case None => default\n}\n\n\u002F\u002F Or more concisely\nval result = optionValue.map(process).getOrElse(default)\n```\n","# Python to Scala Syntax Mapping\n\n## Variable Declarations\n\n| Python | Scala |\n|--------|-------|\n| `x = 5` | `val x = 5` (immutable) or `var x = 5` (mutable) |\n| `x: int = 5` | `val x: Int = 5` |\n| `x, y = 1, 2` | `val (x, y) = (1, 2)` |\n\nPrefer `val` over `var` unless mutation is required.\n\n## Type Mappings\n\n| Python | Scala |\n|--------|-------|\n| `int` | `Int` |\n| `float` | `Double` |\n| `str` | `String` |\n| `bool` | `Boolean` |\n| `None` | `None` (of type `Option`) or `null` |\n| `list[T]` | `List[T]` or `Seq[T]` |\n| `dict[K, V]` | `Map[K, V]` |\n| `set[T]` | `Set[T]` |\n| `tuple[A, B]` | `(A, B)` or `Tuple2[A, B]` |\n| `Optional[T]` | `Option[T]` |\n\n## Control Flow\n\n### Conditionals\n\n```python\n# Python\nif x > 0:\n    result = \"positive\"\nelif x \u003C 0:\n    result = \"negative\"\nelse:\n    result = \"zero\"\n```\n\n```scala\n\u002F\u002F Scala - if is an expression\nval result = if (x > 0) \"positive\"\n             else if (x \u003C 0) \"negative\"\n             else \"zero\"\n```\n\n### Loops\n\n```python\n# Python for loop\nfor i in range(10):\n    print(i)\n\nfor item in items:\n    process(item)\n\nfor i, item in enumerate(items):\n    print(f\"{i}: {item}\")\n```\n\n```scala\n\u002F\u002F Scala equivalents\nfor (i \u003C- 0 until 10) println(i)\n\nfor (item \u003C- items) process(item)\n\nfor ((item, i) \u003C- items.zipWithIndex) println(s\"$i: $item\")\n```\n\n### While loops\n\n```python\n# Python\nwhile condition:\n    do_something()\n```\n\n```scala\n\u002F\u002F Scala\nwhile (condition) {\n  doSomething()\n}\n```\n\n## Comprehensions\n\n```python\n# Python list comprehension\nsquares = [x ** 2 for x in range(10)]\nevens = [x for x in numbers if x % 2 == 0]\npairs = [(x, y) for x in xs for y in ys]\n```\n\n```scala\n\u002F\u002F Scala for-comprehensions or map\u002Ffilter\nval squares = (0 until 10).map(x => x * x).toList\nval evens = numbers.filter(_ % 2 == 0)\nval pairs = for { x \u003C- xs; y \u003C- ys } yield (x, y)\n```\n\n## Functions\n\n```python\n# Python\ndef add(a: int, b: int) -> int:\n    return a + b\n\n# Lambda\nsquare = lambda x: x ** 2\n\n# Default arguments\ndef greet(name: str, greeting: str = \"Hello\") -> str:\n    return f\"{greeting}, {name}!\"\n```\n\n```scala\n\u002F\u002F Scala\ndef add(a: Int, b: Int): Int = a + b\n\n\u002F\u002F Lambda\nval square: Int => Int = x => x * x\n\u002F\u002F or shorter: val square = (x: Int) => x * x\n\n\u002F\u002F Default arguments\ndef greet(name: String, greeting: String = \"Hello\"): String =\n  s\"$greeting, $name!\"\n```\n\n### Python @overload and isinstance dispatch\n\nWhen a Python function declares several `typing.overload` signatures and its\nimplementation dispatches on `isinstance(...)` over a *closed* set of input\ntypes, the overloads are the specification of the public API surface, not\ndocumentation. Translate them to Scala's *static* dispatch mechanisms and\nreserve any `Any`-taking method for a documented lower-priority fallback.\n\nRecipe (apply in order; stop at the first that fits):\n\n1. **One overloaded Scala method per concrete `@overload` variant.** Let the\n   compiler pick by parameter type\u002Farity. This preserves type safety at every\n   call site and eliminates runtime class checks.\n2. **Model closed unions as a sealed ADT** (e.g. `str | bytes` →\n   `sealed trait StringOrBytes { case class Str(...) ; case class Bytes(...) }`)\n   and pattern-match exhaustively. The compiler warns on missing cases.\n3. **Translate `@runtime_checkable` Protocol variants to a type class** (e.g.\n   `trait Tokenizable[-A] { def toToken(a: A): String }`) with `implicit`\n   instances, so user types opt in without nominal inheritance.\n4. **Only if a genuine open-world fallback is required**, add a single\n   `Any`-taking helper under a *distinct name* (e.g. `tokenizeAny`) so it does\n   not shadow or ambiguate the typed overloads.\n\nAnti-pattern — collapsing every `@overload` into one `def f(value: Any)` whose\nbody is a `match` on runtime classes (`String`, `Array[Byte]`, `Int`, `Long`,\n`Double`, `LocalDate`, ..., catch-all `case other`). This loses static type\nchecking, forces callers through `Any`, and typically ambiguates any type-class\noverload added later.\n\n```python\n# Python\n@overload\ndef tokenize(self, value: str) -> Token: ...\n@overload\ndef tokenize(self, value: int) -> Token: ...\n@overload\ndef tokenize(self, value: datetime) -> Token: ...\n@overload\ndef tokenize(self, value: Tokenizable) -> Token: ...\n\ndef tokenize(self, value: Any) -> Token:\n    if isinstance(value, Tokenizable): ...\n    if isinstance(value, (str, bytes)): ...\n    if isinstance(value, (int, float, Decimal)): ...\n    if isinstance(value, (datetime, date)): ...\n    return Token(str(value), TokenType.STRING, {\"fallback\": True})\n```\n\n```scala\n\u002F\u002F Scala - one overload per concrete input type + ADT + type class\ndef tokenize(value: String): Token          = stringTokenizer.tokenize(value)\ndef tokenize(value: Long): Token             = numericTokenizer.tokenize(value)\ndef tokenize(value: Double): Token           = numericTokenizer.tokenize(value)\ndef tokenize(value: BigDecimal): Token       = numericTokenizer.tokenize(value)\ndef tokenize(value: LocalDate): Token        = temporalTokenizer.tokenize(value)\ndef tokenize(value: LocalDateTime): Token    = temporalTokenizer.tokenize(value)\ndef tokenize[A](value: A)(implicit ev: Tokenizable[A]): Token =\n  Token(ev.toToken(value), TokenType.STRUCTURED)\n\n\u002F\u002F Reserve Any-dispatch only as a documented, distinctly named fallback.\ndef tokenizeAny(value: Any): Token = value match {\n  case null                     => Token(\"NULL\", TokenType.NULL)\n  case s: String                => tokenize(s)\n  case l: Long                  => tokenize(l)\n  case d: Double                => tokenize(d)\n  case dt: LocalDateTime        => tokenize(dt)\n  case d: LocalDate             => tokenize(d)\n  case other                    => Token(other.toString, TokenType.STRING, Map(\"fallback\" -> true))\n}\n```\n\nVerification before finishing the translation:\n- Grep the produced Scala for `: Any)` in public method signatures; each\n  occurrence must correspond to an intentional, distinctly named fallback and\n  not shadow the typed overloads.\n- Confirm each `@overload` signature in the Python source has a matching\n  Scala method with a concrete parameter type (or is subsumed by a type-class\n  overload).\n- If a call `tokenize(x)` is ambiguous between the type-class overload and an\n  `Any` overload, resolve it by renaming the `Any` method — **do not** weaken\n  the type class to a subtype trait, which loses ad-hoc polymorphism for types\n  the caller cannot modify.\n\nDo not apply this recipe to Python functions that genuinely accept arbitrary\n`object` with no `@overload` contract (e.g. `__repr__`-style debug helpers);\nthere a single `Any`\u002F`AnyRef` method with a `match` is acceptable.\n\n## String Formatting\n\n| Python | Scala |\n|--------|-------|\n| `f\"Hello, {name}!\"` | `s\"Hello, $name!\"` |\n| `f\"Value: {x:.2f}\"` | `f\"Value: $x%.2f\"` |\n| `f\"{x + y}\"` | `s\"${x + y}\"` |\n\n## Common Operators\n\n| Python | Scala |\n|--------|-------|\n| `**` (power) | `math.pow(x, y)` or use `scala.math.pow` |\n| `\u002F\u002F` (floor div) | `x \u002F y` (for Int) or `math.floor(x \u002F y)` |\n| `%` (modulo) | `%` |\n| `and`, `or`, `not` | `&&`, `||`, `!` |\n| `in` | `.contains()` |\n| `is` | `eq` (reference equality) |\n| `==` | `==` (value equality) |\n\n## Exception Handling\n\n```python\n# Python\ntry:\n    result = risky_operation()\nexcept ValueError as e:\n    handle_error(e)\nfinally:\n    cleanup()\n```\n\n```scala\n\u002F\u002F Scala\nimport scala.util.{Try, Success, Failure}\n\n\u002F\u002F Pattern 1: try-catch\ntry {\n  val result = riskyOperation()\n} catch {\n  case e: IllegalArgumentException => handleError(e)\n} finally {\n  cleanup()\n}\n\n\u002F\u002F Pattern 2: Try monad (preferred for functional style)\nval result = Try(riskyOperation()) match {\n  case Success(value) => value\n  case Failure(e) => handleError(e)\n}\n```\n\n## None\u002FNull Handling\n\n```python\n# Python\nif value is None:\n    return default\nreturn process(value)\n\n# Or\nresult = value if value is not None else default\n```\n\n```scala\n\u002F\u002F Scala - use Option\nval result = optionValue match {\n  case Some(v) => process(v)\n  case None => default\n}\n\n\u002F\u002F Or more concisely\nval result = optionValue.map(process).getOrElse(default)\n```\n",{"name":5,"description":7},"main","cdcb6d230f3b15c3c33f8a2bdd16439f43602cbe","evaluation\u002Fresults\u002FWML-Opus47-15Tasks-20260923\u002Ftasks\u002Fpython-scala-translation\u002Frepaired_run\u002Finputs\u002Fskills\u002Fpython-scala-syntax-mapping",1,"https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark","https:\u002F\u002Fgithub.com\u002Flinyouxue","2026-11-14 20:28:35",{"source":8,"skillName":5,"commands":32,"prompt":42,"zipAvailable":43},[33,36,39],{"tool":34,"command":35},"npx","npx skills add linyouxue\u002Fskill-repair-benchmark --skill python-scala-syntax-mapping",{"tool":37,"command":38},"bunx","bunx skills add linyouxue\u002Fskill-repair-benchmark --skill python-scala-syntax-mapping",{"tool":40,"command":41},"pnpm","pnpm dlx skills add linyouxue\u002Fskill-repair-benchmark --skill python-scala-syntax-mapping","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fevaluation\u002Fresults\u002FWML-Opus47-15Tasks-20260923\u002Ftasks\u002Fpython-scala-translation\u002Frepaired_run\u002Finputs\u002Fskills\u002Fpython-scala-syntax-mapping\u002FSKILL.md",true,[],[46,53,60,67,72,77],{"skillNo":47,"name":48,"nameZh":6,"description":49,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":50,"categories":51,"keywords":52,"publishedAt":19},"01M7E1HGVRY73NBJ022CJG13X6","video-frame-extraction","Extract frames from video files and save them as images using OpenCV","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_03\u002Finputs\u002Fskills\u002Fvideo-frame-extraction\u002FSKILL.md",[],[],{"skillNo":54,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":57,"categories":58,"keywords":59,"publishedAt":19},"01M7E1HAG5R7CJ9C8NYJS771MB","openai-vision","Analyze images and multi-frame sequences using OpenAI GPT vision models","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_03\u002Finputs\u002Fskills\u002Fopenai-vision\u002FSKILL.md",[],[],{"skillNo":61,"name":62,"nameZh":6,"description":63,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":19},"01M7E1H7DADKB6QBWKC2KQ63SZ","image-ocr","Extract text content from images using Tesseract OCR via Python, including structured field extraction from receipts and forms","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_03\u002Finputs\u002Fskills\u002Fimage-ocr\u002FSKILL.md",[],[],{"skillNo":68,"name":48,"nameZh":6,"description":49,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":19},"01M7E1H0WBNT43TENGQY7AVZHD","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_02\u002Finputs\u002Fskills\u002Fvideo-frame-extraction\u002FSKILL.md",[],[],{"skillNo":73,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":76,"publishedAt":19},"01M7E1GTC7D4N4Q2EF03875J9E","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_02\u002Finputs\u002Fskills\u002Fopenai-vision\u002FSKILL.md",[],[],{"skillNo":78,"name":62,"nameZh":6,"description":63,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":19},"01M7E1GQ92CWFMGH53KSSE4WER","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_02\u002Finputs\u002Fskills\u002Fimage-ocr\u002FSKILL.md",[],[]]