python.json

{
  "main function": {
    "prefix": "main",
    "body": [
      "if __name__ == '__main__':",
      "    main()"
    ]
  },
  "Main function with arg parser": {
    "prefix": "argparse",
    "body": [
      "def ${1:main}() -> None:",
      "    \"\"\"${2:Main method}\"\"\"",
      "    parser = argparse.ArgumentParser(description=$1.__doc__)",
      "    parser.add_argument('-f', help=\"\")",
      "    args = parser.parse_args()"
    ]
  },
  "const value": {
    "prefix": "const",
    "body": [
      "$1: Final[Literal[\"$1\"]] = \"$1\""
    ]
  },
  "read-only property": {
    "prefix": [
      "@p",
      "propr"
    ],
    "body": [
      "@property",
      "def $1(self) -> $2:",
      "    \"\"\" ${3:Getter for $1} \"\"\"",
      "    ${4:return self._$1}"
    ]
  },
  "read-write property": {
    "prefix": [
      "@pp",
      "proprw"
    ],
    "body": [
      "@property",
      "def $1(self) -> $2:",
      "    \"\"\"${3:Getter for $1}\"\"\"",
      "    ${4:return self._$1}",
      "",
      "@$1.setter",
      "def $1(self, $1: $2) -> None:",
      "    \"\"\"${5:Setter for $1}\"\"\"",
      "    ${6:self._$1 = $1}"
    ]
  },
  "classmethod": {
    "prefix": "@c",
    "body": [
      "@classmethod",
      "def $1(cls$2):",
      "  \"\"\"$3\"\"\"",
      "  $0"
    ]
  },
  "staticmethod": {
    "prefix": "@s",
    "body": [
      "@staticmethod",
      "def $1($2):",
      "  \"\"\"$3\"\"\"",
      "  $0"
    ]
  },
  "Inline docstring": {
    "prefix": "\"",
    "body": [
      "\"\"\"$1\"\"\""
    ]
  },
  "Multiline docstring": {
    "prefix": "\"\"",
    "body": [
      "\"\"\"",
      "$1",
      "",
      "\"\"\""
    ]
  },
  "Function definition": {
    "prefix": "def",
    "body": [
      "def $1($2):",
      "    $0"
    ]
  },
  "Method definition": {
    "prefix": "defm",
    "body": [
      "def $1(self$2):",
      "    $0"
    ]
  },
  "Property access": {
    "prefix": ".",
    "body": [
      "self."
    ]
  },
  "UnitTest assertEqual": {
    "prefix": "ae",
    "body": [
      "self.assertEqual($1, $2)"
    ]
  },
  "UnitTest assertAlmostEqual": {
    "prefix": "aae",
    "body": [
      "self.assertAlmostEqual($1, $2)"
    ]
  },
  "UnitTest assertTrue": {
    "prefix": "at",
    "body": [
      "self.assertTrue($1)"
    ]
  },
  "UnitTest assertFalse": {
    "prefix": "af",
    "body": [
      "self.assertFalse($1)"
    ]
  },
  "UnitTest assertRaises": {
    "prefix": "ar",
    "body": [
      "with self.assertRaises(${1:Exception}):",
      "    $0"
    ]
  },
  "UnitTest assertIsNone": {
    "prefix": "ain",
    "body": [
      "self.assertIsNone($1)"
    ]
  },
  "UnitTest assertIsNotNone": {
    "prefix": "ainn",
    "body": [
      "self.assertIsNotNone($1)"
    ]
  },
  "UnitTest assertCountEqual": {
    "prefix": "ace",
    "body": [
      "self.assertCountEqual($1, $2)"
    ]
  },
  "UnitTest class": {
    "prefix": "T_",
    "body": [
      "class Test${1:Class}(${2:unittest.TestCase}):",
      "",
      "    \"\"\" $3 \"\"\"",
      "",
      "    $0"
    ]
  },
  "Interview UnitTest class": {
    "prefix": "T__",
    "body": [
      "class Test${1:Class}(${2:unittest.TestCase}):",
      "",
      "    $0",
      "",
      "unittest.main(exit=False)"
    ]
  },
  "UnitTest test case": {
    "prefix": "t_",
    "body": [
      "def test_$1(self) -> None:",
      "    \"\"\" $2 \"\"\"",
      "    $0"
    ]
  },
  "UnitTest setUp": {
    "prefix": "su",
    "body": [
      "def setUp(self) -> None:",
      "    super().setUp()",
      "    $0"
    ]
  },
  "UnitTest tearDown": {
    "prefix": "td",
    "body": [
      "def tearDown(self) -> None:",
      "    super().tearDown()",
      "    $0"
    ]
  },
  "UnitTest setUpClass": {
    "prefix": "suc",
    "body": [
      "@classmethod",
      "def setUpClass(cls) -> None:",
      "    super().setUpClass()",
      "    $0"
    ]
  },
  "UnitTest tearDownClass": {
    "prefix": "tdc",
    "body": [
      "@classmethod",
      "def tearDownClass(self) -> None:",
      "    super().tearDownClass()",
      "    $0"
    ]
  },
  "Version-safe type import": {
    "prefix": [
      "timport",
      "timp"
    ],
    "body": [
      "if sys.version_info < (3, 8):",
      "    from typing_extensions import ${1:Literal}",
      "else:",
      "    from typing import $1"
    ]
  }
}