[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7BW49RSXJ2ACSRASVNV81CF":3,"skill-same:01M7BW49RSXJ2ACSRASVNV81CF":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},"01M7BW49RSXJ2ACSRASVNV81CF","python-scala-functional",null,"Guide for translating Python code to functional Scala style. Use when converting Python code involving higher-order functions, decorators, closures, generators, or when aiming for idiomatic functional Scala with pattern matching, Option handling, and monadic operations.","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\u002FMMG2Skill-Opus47-Gold15-20260924\u002Ftasks\u002Fpython-scala-translation\u002Frepaired_skill\u002Fpython-scala-functional\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: python-scala-functional\ndescription: Guide for translating Python code to functional Scala style. Use when converting Python code involving higher-order functions, decorators, closures, generators, or when aiming for idiomatic functional Scala with pattern matching, Option handling, and monadic operations.\n---\n\n# Python to Scala Functional Programming Translation\n## Higher-Order Functions\n```python\n# Python\ndef apply_twice(f, x):\n    return f(f(x))\ndef make_multiplier(n):\n    return lambda x: x * n\ndouble = make_multiplier(2)\nresult = apply_twice(double, 5)  # 20\n```\n```scala\n\u002F\u002F Scala\ndef applyTwice[A](f: A => A, x: A): A = f(f(x))\ndef makeMultiplier(n: Int): Int => Int = x => x * n\nval double = makeMultiplier(2)\nval result = applyTwice(double, 5)  \u002F\u002F 20\n```\n## Decorators → Function Composition\n```python\n# Python\ndef log_calls(func):\n    def wrapper(*args, **kwargs):\n        print(f\"Calling {func.__name__}\")\n        result = func(*args, **kwargs)\n        print(f\"Finished {func.__name__}\")\n        return result\n    return wrapper\n@log_calls\ndef add(a, b):\n    return a + b\n```\n```scala\n\u002F\u002F Scala - function composition\ndef logCalls[A, B](f: A => B, name: String): A => B = { a =>\n  println(s\"Calling $name\")\n  val result = f(a)\n  println(s\"Finished $name\")\n  result\n}\nval add = (a: Int, b: Int) => a + b\nval loggedAdd = logCalls(add.tupled, \"add\")\n\u002F\u002F Alternative: using by-name parameters\ndef withLogging[A](name: String)(block: => A): A = {\n  println(s\"Calling $name\")\n  val result = block\n  println(s\"Finished $name\")\n  result\n}\n```\n## Pattern Matching\n```python\n# Python (3.10+)\ndef describe(value):\n    match value:\n        case 0:\n            return \"zero\"\n        case int(x) if x > 0:\n            return \"positive int\"\n        case int(x):\n            return \"negative int\"\n        case [x, y]:\n            return f\"pair: {x}, {y}\"\n        case {\"name\": name, \"age\": age}:\n            return f\"{name} is {age}\"\n        case _:\n            return \"unknown\"\n```\n```scala\n\u002F\u002F Scala - pattern matching is more powerful\ndef describe(value: Any): String = value match {\n  case 0 => \"zero\"\n  case x: Int if x > 0 => \"positive int\"\n  case _: Int => \"negative int\"\n  case (x, y) => s\"pair: $x, $y\"\n  case List(x, y) => s\"list of two: $x, $y\"\n  case m: Map[_, _] if m.contains(\"name\") =>\n    s\"${m(\"name\")} is ${m(\"age\")}\"\n  case _ => \"unknown\"\n}\n\u002F\u002F Case class pattern matching (preferred)\nsealed trait Result\ncase class Success(value: Int) extends Result\ncase class Error(message: String) extends Result\ndef handle(result: Result): String = result match {\n  case Success(v) if v > 100 => s\"Big success: $v\"\n  case Success(v) => s\"Success: $v\"\n  case Error(msg) => s\"Failed: $msg\"\n}\n```\n## Option Handling (None\u002Fnull Safety)\n```python\n# Python\ndef find_user(user_id: int) -> Optional[User]:\n    user = db.get(user_id)\n    return user if user else None\ndef get_user_email(user_id: int) -> Optional[str]:\n    user = find_user(user_id)\n    if user is None:\n        return None\n    return user.email\n# Chained operations\ndef get_user_city(user_id: int) -> Optional[str]:\n    user = find_user(user_id)\n    if user is None:\n        return None\n    address = user.address\n    if address is None:\n        return None\n    return address.city\n```\n```scala\n\u002F\u002F Scala - Option monad\ndef findUser(userId: Int): Option[User] = db.get(userId)\ndef getUserEmail(userId: Int): Option[String] =\n  findUser(userId).map(_.email)\n\u002F\u002F Chained operations with flatMap\ndef getUserCity(userId: Int): Option[String] =\n  findUser(userId)\n    .flatMap(_.address)\n    .map(_.city)\n\u002F\u002F For-comprehension (cleaner for multiple operations)\ndef getUserCity(userId: Int): Option[String] = for {\n  user \u003C- findUser(userId)\n  address \u003C- user.address\n  city \u003C- Option(address.city)\n} yield city\n\u002F\u002F Getting values out\nval email = getUserEmail(1).getOrElse(\"no-email@example.com\")\nval emailOrThrow = getUserEmail(1).get  \u002F\u002F Throws if None\n```\n## Generators → Iterators\u002FLazyList\n```python\n# Python\ndef fibonacci():\n    a, b = 0, 1\n    while True:\n        yield a\n        a, b = b, a + b\n# Take first 10\nfibs = list(itertools.islice(fibonacci(), 10))\n```\n```scala\n\u002F\u002F Scala - LazyList (was Stream in Scala 2.12)\ndef fibonacci: LazyList[BigInt] = {\n  def loop(a: BigInt, b: BigInt): LazyList[BigInt] =\n    a #:: loop(b, a + b)\n  loop(0, 1)\n}\nval fibs = fibonacci.take(10).toList\n\u002F\u002F Alternative: Iterator\ndef fibonacciIterator: Iterator[BigInt] = new Iterator[BigInt] {\n  private var (a, b) = (BigInt(0), BigInt(1))\n  def hasNext: Boolean = true\n  def next(): BigInt = {\n    val result = a\n    val newB = a + b\n    a = b\n    b = newB\n    result\n  }\n}\n```\n## Try\u002FEither for Error Handling\n```python\n# Python - exceptions\ndef parse_int(s: str) -> int:\n    try:\n        return int(s)\n    except ValueError:\n        return 0\n# Python - Optional for errors\ndef safe_parse_int(s: str) -> Optional[int]:\n    try:\n        return int(s)\n    except ValueError:\n        return None\n```\n```scala\n\u002F\u002F Scala - Try monad\nimport scala.util.{Try, Success, Failure}\ndef parseInt(s: String): Try[Int] = Try(s.toInt)\nval result = parseInt(\"123\") match {\n  case Success(n) => s\"Got: $n\"\n  case Failure(e) => s\"Error: ${e.getMessage}\"\n}\n\u002F\u002F Chaining Try operations\nval doubled = parseInt(\"123\").map(_ * 2)\n\u002F\u002F Either for custom error types\ndef parsePositive(s: String): Either[String, Int] = {\n  Try(s.toInt).toEither\n    .left.map(_ => \"Not a number\")\n    .flatMap { n =>\n      if (n > 0) Right(n)\n      else Left(\"Must be positive\")\n    }\n}\n```\n## Function Composition\n```python\n# Python\ndef compose(f, g):\n    return lambda x: f(g(x))\ndef pipe(*functions):\n    def inner(x):\n        result = x\n        for f in functions:\n            result = f(result)\n        return result\n    return inner\n# Usage\nadd_one = lambda x: x + 1\ndouble = lambda x: x * 2\npipeline = pipe(add_one, double, add_one)  # (x + 1) * 2 + 1\n```\n```scala\n\u002F\u002F Scala - built-in composition\nval addOne: Int => Int = _ + 1\nval double: Int => Int = _ * 2\n\u002F\u002F compose: f.compose(g) = f(g(x))\nval composed = addOne.compose(double)  \u002F\u002F addOne(double(x))\n\u002F\u002F andThen: f.andThen(g) = g(f(x))\nval pipeline = addOne.andThen(double).andThen(addOne)  \u002F\u002F (x + 1) * 2 + 1\n```\n## Currying and Partial Application\n```python\n# Python\nfrom functools import partial\ndef add(a, b, c):\n    return a + b + c\nadd_5 = partial(add, 5)\nresult = add_5(3, 2)  # 10\n```\n```scala\n\u002F\u002F Scala - curried functions\ndef add(a: Int)(b: Int)(c: Int): Int = a + b + c\nval add5 = add(5) _  \u002F\u002F Partially applied\nval result = add5(3)(2)  \u002F\u002F 10\n\u002F\u002F Converting between curried and uncurried\nval uncurried = Function.uncurried(add _)\nval curried = (uncurried _).curried\n\u002F\u002F Multiple parameter lists\ndef fold[A, B](init: B)(list: List[A])(f: (B, A) => B): B =\n  list.foldLeft(init)(f)\nval sum = fold(0)(List(1, 2, 3))(_ + _)\n```\n## Tail Recursion\n```python\n# Python - no tail call optimization\ndef factorial(n):\n    if n \u003C= 1:\n        return 1\n    return n * factorial(n - 1)\n# Workaround: iterative\ndef factorial_iter(n):\n    result = 1\n    for i in range(2, n + 1):\n        result *= i\n    return result\n```\n```scala\n\u002F\u002F Scala - tail recursion with annotation\nimport scala.annotation.tailrec\ndef factorial(n: Int): BigInt = {\n  @tailrec\n  def loop(n: Int, acc: BigInt): BigInt = {\n    if (n \u003C= 1) acc\n    else loop(n - 1, n * acc)\n  }\n  loop(n, 1)\n}\n```\n## Implicit Conversions and Type Classes\n```python\n# Python - no direct equivalent\n# Duck typing provides flexibility\n```\n```scala\n\u002F\u002F Scala - type classes via implicits (Scala 2) or given\u002Fusing (Scala 3)\n\u002F\u002F Scala 3\ntrait Show[A]:\n  def show(a: A): String\ngiven Show[Int] with\n  def show(a: Int): String = s\"Int: $a\"\ndef display[A](a: A)(using s: Show[A]): String = s.show(a)\n\u002F\u002F Scala 2\ntrait Show[A] {\n  def show(a: A): String\n}\nimplicit val intShow: Show[Int] = new Show[Int] {\n  def show(a: Int): String = s\"Int: $a\"\n}\ndef display[A](a: A)(implicit s: Show[A]): String = s.show(a)\n```\n### Avoiding overload ambiguity between Any and type-class dispatch\nIf you have both `def tokenize(x: Any)` and `def tokenize[A: TC](x: A)`, calls become ambiguous. Prefer one of these instead:\n- Use a **subtype trait** (`trait Tokenizable { def toToken: Token }`) and dispatch via pattern match on `Any` at the top level (e.g. `UniversalTokenizer`).\n- Or expose the type-class form only on a specialized tokenizer (e.g. `NumericTokenizer[A: Numeric]`), and let the universal entry point use `Any` + pattern match.\nDon't try to mix both signatures on the same method name.\n","# Python to Scala Functional Programming Translation\n## Higher-Order Functions\n```python\n# Python\ndef apply_twice(f, x):\n    return f(f(x))\ndef make_multiplier(n):\n    return lambda x: x * n\ndouble = make_multiplier(2)\nresult = apply_twice(double, 5)  # 20\n```\n```scala\n\u002F\u002F Scala\ndef applyTwice[A](f: A => A, x: A): A = f(f(x))\ndef makeMultiplier(n: Int): Int => Int = x => x * n\nval double = makeMultiplier(2)\nval result = applyTwice(double, 5)  \u002F\u002F 20\n```\n## Decorators → Function Composition\n```python\n# Python\ndef log_calls(func):\n    def wrapper(*args, **kwargs):\n        print(f\"Calling {func.__name__}\")\n        result = func(*args, **kwargs)\n        print(f\"Finished {func.__name__}\")\n        return result\n    return wrapper\n@log_calls\ndef add(a, b):\n    return a + b\n```\n```scala\n\u002F\u002F Scala - function composition\ndef logCalls[A, B](f: A => B, name: String): A => B = { a =>\n  println(s\"Calling $name\")\n  val result = f(a)\n  println(s\"Finished $name\")\n  result\n}\nval add = (a: Int, b: Int) => a + b\nval loggedAdd = logCalls(add.tupled, \"add\")\n\u002F\u002F Alternative: using by-name parameters\ndef withLogging[A](name: String)(block: => A): A = {\n  println(s\"Calling $name\")\n  val result = block\n  println(s\"Finished $name\")\n  result\n}\n```\n## Pattern Matching\n```python\n# Python (3.10+)\ndef describe(value):\n    match value:\n        case 0:\n            return \"zero\"\n        case int(x) if x > 0:\n            return \"positive int\"\n        case int(x):\n            return \"negative int\"\n        case [x, y]:\n            return f\"pair: {x}, {y}\"\n        case {\"name\": name, \"age\": age}:\n            return f\"{name} is {age}\"\n        case _:\n            return \"unknown\"\n```\n```scala\n\u002F\u002F Scala - pattern matching is more powerful\ndef describe(value: Any): String = value match {\n  case 0 => \"zero\"\n  case x: Int if x > 0 => \"positive int\"\n  case _: Int => \"negative int\"\n  case (x, y) => s\"pair: $x, $y\"\n  case List(x, y) => s\"list of two: $x, $y\"\n  case m: Map[_, _] if m.contains(\"name\") =>\n    s\"${m(\"name\")} is ${m(\"age\")}\"\n  case _ => \"unknown\"\n}\n\u002F\u002F Case class pattern matching (preferred)\nsealed trait Result\ncase class Success(value: Int) extends Result\ncase class Error(message: String) extends Result\ndef handle(result: Result): String = result match {\n  case Success(v) if v > 100 => s\"Big success: $v\"\n  case Success(v) => s\"Success: $v\"\n  case Error(msg) => s\"Failed: $msg\"\n}\n```\n## Option Handling (None\u002Fnull Safety)\n```python\n# Python\ndef find_user(user_id: int) -> Optional[User]:\n    user = db.get(user_id)\n    return user if user else None\ndef get_user_email(user_id: int) -> Optional[str]:\n    user = find_user(user_id)\n    if user is None:\n        return None\n    return user.email\n# Chained operations\ndef get_user_city(user_id: int) -> Optional[str]:\n    user = find_user(user_id)\n    if user is None:\n        return None\n    address = user.address\n    if address is None:\n        return None\n    return address.city\n```\n```scala\n\u002F\u002F Scala - Option monad\ndef findUser(userId: Int): Option[User] = db.get(userId)\ndef getUserEmail(userId: Int): Option[String] =\n  findUser(userId).map(_.email)\n\u002F\u002F Chained operations with flatMap\ndef getUserCity(userId: Int): Option[String] =\n  findUser(userId)\n    .flatMap(_.address)\n    .map(_.city)\n\u002F\u002F For-comprehension (cleaner for multiple operations)\ndef getUserCity(userId: Int): Option[String] = for {\n  user \u003C- findUser(userId)\n  address \u003C- user.address\n  city \u003C- Option(address.city)\n} yield city\n\u002F\u002F Getting values out\nval email = getUserEmail(1).getOrElse(\"no-email@example.com\")\nval emailOrThrow = getUserEmail(1).get  \u002F\u002F Throws if None\n```\n## Generators → Iterators\u002FLazyList\n```python\n# Python\ndef fibonacci():\n    a, b = 0, 1\n    while True:\n        yield a\n        a, b = b, a + b\n# Take first 10\nfibs = list(itertools.islice(fibonacci(), 10))\n```\n```scala\n\u002F\u002F Scala - LazyList (was Stream in Scala 2.12)\ndef fibonacci: LazyList[BigInt] = {\n  def loop(a: BigInt, b: BigInt): LazyList[BigInt] =\n    a #:: loop(b, a + b)\n  loop(0, 1)\n}\nval fibs = fibonacci.take(10).toList\n\u002F\u002F Alternative: Iterator\ndef fibonacciIterator: Iterator[BigInt] = new Iterator[BigInt] {\n  private var (a, b) = (BigInt(0), BigInt(1))\n  def hasNext: Boolean = true\n  def next(): BigInt = {\n    val result = a\n    val newB = a + b\n    a = b\n    b = newB\n    result\n  }\n}\n```\n## Try\u002FEither for Error Handling\n```python\n# Python - exceptions\ndef parse_int(s: str) -> int:\n    try:\n        return int(s)\n    except ValueError:\n        return 0\n# Python - Optional for errors\ndef safe_parse_int(s: str) -> Optional[int]:\n    try:\n        return int(s)\n    except ValueError:\n        return None\n```\n```scala\n\u002F\u002F Scala - Try monad\nimport scala.util.{Try, Success, Failure}\ndef parseInt(s: String): Try[Int] = Try(s.toInt)\nval result = parseInt(\"123\") match {\n  case Success(n) => s\"Got: $n\"\n  case Failure(e) => s\"Error: ${e.getMessage}\"\n}\n\u002F\u002F Chaining Try operations\nval doubled = parseInt(\"123\").map(_ * 2)\n\u002F\u002F Either for custom error types\ndef parsePositive(s: String): Either[String, Int] = {\n  Try(s.toInt).toEither\n    .left.map(_ => \"Not a number\")\n    .flatMap { n =>\n      if (n > 0) Right(n)\n      else Left(\"Must be positive\")\n    }\n}\n```\n## Function Composition\n```python\n# Python\ndef compose(f, g):\n    return lambda x: f(g(x))\ndef pipe(*functions):\n    def inner(x):\n        result = x\n        for f in functions:\n            result = f(result)\n        return result\n    return inner\n# Usage\nadd_one = lambda x: x + 1\ndouble = lambda x: x * 2\npipeline = pipe(add_one, double, add_one)  # (x + 1) * 2 + 1\n```\n```scala\n\u002F\u002F Scala - built-in composition\nval addOne: Int => Int = _ + 1\nval double: Int => Int = _ * 2\n\u002F\u002F compose: f.compose(g) = f(g(x))\nval composed = addOne.compose(double)  \u002F\u002F addOne(double(x))\n\u002F\u002F andThen: f.andThen(g) = g(f(x))\nval pipeline = addOne.andThen(double).andThen(addOne)  \u002F\u002F (x + 1) * 2 + 1\n```\n## Currying and Partial Application\n```python\n# Python\nfrom functools import partial\ndef add(a, b, c):\n    return a + b + c\nadd_5 = partial(add, 5)\nresult = add_5(3, 2)  # 10\n```\n```scala\n\u002F\u002F Scala - curried functions\ndef add(a: Int)(b: Int)(c: Int): Int = a + b + c\nval add5 = add(5) _  \u002F\u002F Partially applied\nval result = add5(3)(2)  \u002F\u002F 10\n\u002F\u002F Converting between curried and uncurried\nval uncurried = Function.uncurried(add _)\nval curried = (uncurried _).curried\n\u002F\u002F Multiple parameter lists\ndef fold[A, B](init: B)(list: List[A])(f: (B, A) => B): B =\n  list.foldLeft(init)(f)\nval sum = fold(0)(List(1, 2, 3))(_ + _)\n```\n## Tail Recursion\n```python\n# Python - no tail call optimization\ndef factorial(n):\n    if n \u003C= 1:\n        return 1\n    return n * factorial(n - 1)\n# Workaround: iterative\ndef factorial_iter(n):\n    result = 1\n    for i in range(2, n + 1):\n        result *= i\n    return result\n```\n```scala\n\u002F\u002F Scala - tail recursion with annotation\nimport scala.annotation.tailrec\ndef factorial(n: Int): BigInt = {\n  @tailrec\n  def loop(n: Int, acc: BigInt): BigInt = {\n    if (n \u003C= 1) acc\n    else loop(n - 1, n * acc)\n  }\n  loop(n, 1)\n}\n```\n## Implicit Conversions and Type Classes\n```python\n# Python - no direct equivalent\n# Duck typing provides flexibility\n```\n```scala\n\u002F\u002F Scala - type classes via implicits (Scala 2) or given\u002Fusing (Scala 3)\n\u002F\u002F Scala 3\ntrait Show[A]:\n  def show(a: A): String\ngiven Show[Int] with\n  def show(a: Int): String = s\"Int: $a\"\ndef display[A](a: A)(using s: Show[A]): String = s.show(a)\n\u002F\u002F Scala 2\ntrait Show[A] {\n  def show(a: A): String\n}\nimplicit val intShow: Show[Int] = new Show[Int] {\n  def show(a: Int): String = s\"Int: $a\"\n}\ndef display[A](a: A)(implicit s: Show[A]): String = s.show(a)\n```\n### Avoiding overload ambiguity between Any and type-class dispatch\nIf you have both `def tokenize(x: Any)` and `def tokenize[A: TC](x: A)`, calls become ambiguous. Prefer one of these instead:\n- Use a **subtype trait** (`trait Tokenizable { def toToken: Token }`) and dispatch via pattern match on `Any` at the top level (e.g. `UniversalTokenizer`).\n- Or expose the type-class form only on a specialized tokenizer (e.g. `NumericTokenizer[A: Numeric]`), and let the universal entry point use `Any` + pattern match.\nDon't try to mix both signatures on the same method name.\n",{"name":5,"description":7},"main","cdcb6d230f3b15c3c33f8a2bdd16439f43602cbe","evaluation\u002Fresults\u002FMMG2Skill-Opus47-Gold15-20260924\u002Ftasks\u002Fpython-scala-translation\u002Frepaired_skill\u002Fpython-scala-functional",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-functional",{"tool":37,"command":38},"bunx","bunx skills add linyouxue\u002Fskill-repair-benchmark --skill python-scala-functional",{"tool":40,"command":41},"pnpm","pnpm dlx skills add linyouxue\u002Fskill-repair-benchmark --skill python-scala-functional","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fevaluation\u002Fresults\u002FMMG2Skill-Opus47-Gold15-20260924\u002Ftasks\u002Fpython-scala-translation\u002Frepaired_skill\u002Fpython-scala-functional\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",[],[]]