Commits on Feb 16, 2024

1. Add doom-snippets for python-base-mode …

   These snippets have been converted semi-automatically with the help of GPT-4 using the following prompt:
   
   :PROPERTIES:
   :GPTEL_MODEL: gpt-4
   :GPTEL_BACKEND: ChatGPT
   :GPTEL_SYSTEM: You are a large language model and a careful programmer. Provide code and only code as output without any additional text, prompt or note.
   :GPTEL_BOUNDS: ((11612 . 15019))
   :END:
   
   * I want to convert emacs yasnipptes to tempo template format.
   
   The templates are defined in a Lisp data file configured by ~tempel-path~. Lisp
   data files are files containing Lisp s-expressions (see ~lisp-data-mode~). By
   default the file =~/.config/emacs/templates= is used. The templates are grouped by
   major mode with an optional ~:when~ condition. Each template is a list in the
   concise form of the Emacs Tempo syntax. The first element of each list is the
   name of the template. Behind the name, the Tempo syntax elements follow.
   
   In addition, each template may specify a =:pre= and/or =:post= key with a FORM that is
   evaluated before the template is expanded or after it is finalized, respectively. The
   =:post= form is evaluated in the lexical scope of the template, which means that it can
   access the template's named fields.
   
   * Template syntax
   
   All the Tempo syntax elements are fully supported. The syntax elements are
   described in detail in the docstring of ~tempo-define-template~ in tempo.el:
   
   Signature
   (tempo-define-template NAME ELEMENTS &optional TAG DOCUMENTATION TAGLIST)
   
   Documentation
   Define a template.
   
   This function creates a template variable tempo-template-NAME and an
   interactive function tempo-template-NAME that inserts the template
   at the point.  The created function is returned.
   
   NAME is a string that contains the name of the template, ELEMENTS is a
   list of elements in the template, TAG is the tag used for completion,
   DOCUMENTATION is the documentation string for the insertion command
   created, and TAGLIST (a symbol) is the tag list that TAG (if provided)
   should be added to.  If TAGLIST is nil and TAG is non-nil, TAG is
   added to tempo-tags.  If TAG already corresponds to a template in
   the tag list, modify the list so that TAG now corresponds to the newly
   defined template.
   
   The elements in ELEMENTS can be of several types:
   
    - A string: It is sent to the hooks in tempo-insert-string-functions,
      and the result is inserted.
    - The symbol p: This position is saved in tempo-marks.
    - The symbol r: If tempo-insert is called with ON-REGION non-nil
      the current region is placed here.  Otherwise it works like p.
    - (p PROMPT <NAME> <NOINSERT>): If tempo-interactive is non-nil, the
      user is prompted in the minibuffer with PROMPT for a string to be
      inserted.  If the optional parameter NAME is non-nil, the text is
      saved for later insertion with the s tag.  If there already is
      something saved under NAME that value is used instead and no
      prompting is made.  If NOINSERT is provided and non-nil, nothing is
      inserted, but text is still saved when a NAME is provided.  For
      clarity, the symbol noinsert should be used as argument.
    - (P PROMPT <NAME> <NOINSERT>): Works just like the previous tag, but
      forces tempo-interactive to be true.
    - (r PROMPT <NAME> <NOINSERT>): Like the previous tag, but if
      tempo-interactive is nil and tempo-insert is called with
      ON-REGION non-nil, the current region is placed here.  This usually
      happens when you call the template function with a prefix argument.
    - (s NAME): Inserts text previously read with the (p ..) construct.
      Finds the insertion saved under NAME and inserts it.  Acts like p
      if tempo-interactive is nil.
    - &: If there is only whitespace between the line start and point,
      nothing happens.  Otherwise a newline is inserted.
    - %: If there is only whitespace between point and end of line,
      nothing happens.  Otherwise a newline is inserted.
    - n: Inserts a newline.
    - >: The line is indented using indent-according-to-mode.  Note
      that you often should place this item after the text you want on
      the line.
    - r>: Like r, but it also indents the region.
    - (r> PROMPT <NAME> <NOINSERT>): Like (r ...), but is also indents
      the region.
    - n>: Inserts a newline and indents line.
    - o: Like % but leaves the point before the newline.
    - nil: It is ignored.
    - Anything else: Each function in tempo-user-elements is called
      with it as argument until one of them returns non-nil, and the
      result is inserted.  If all of them return nil, it is evaluated and
      the result is treated as an element to be inserted.  One additional
      tag is useful for these cases.  If an expression returns a list (l
      foo bar), the elements after l will be inserted according to the
      usual rules.  This makes it possible to return several elements
      from one expression.
   
   * Summary of Template Syntax
   
   - "string" Inserts a string literal.
   - ~p~ Inserts an unnamed placeholder field.
   - ~n~ Inserts a newline.
   - ~>~ Indents with ~indent-according-to-mode~.
   - ~r~ Inserts the current region.
     If no region is active, quits the containing template when jumped to.
   - ~r>~ Acts like ~r~, but indent region.
   - ~n>~ Inserts a newline and indents.
   - ~&~ Insert newline unless there is only whitespace between line start and point.
   - ~%~ Insert newline unless there is only whitespace between point and line end.
   - ~o~ Like ~%~ but leaves the point before newline.
   - ~(s NAME)~ Inserts a named field.
   - ~(p PROMPT <NAME> <NOINSERT>)~ Insert an optionally named field with a prompt.
     The ~PROMPT~ is displayed directly in the buffer as default value. If ~NOINSERT~
     is non-nil, no field is inserted. Then the minibuffer is used for prompting
     and the value is bound to ~NAME~.
   - ~(r PROMPT <NAME> <NOINSERT>)~ Insert region or act like ~(p ...)~.
   - ~(r> PROMPT <NAME> <NOINSERT>)~ Act like ~(r ...)~, but indent region.
   
   Furthermore Tempel supports syntax extensions:
   
   - ~(p FORM <NAME> <NOINSERT>)~ Like ~p~ described above, but ~FORM~ is evaluated.
   - ~(FORM ...)~ Other Lisp forms are evaluated. Named fields are lexically bound.
   - ~q~ Quits the containing template when jumped to.
   
   Use caution with templates which execute arbitrary code!
   
   * Tempel Template examples
   
     ;; ~/.config/emacs/templates
   
     fundamental-mode ;; Available everywhere
   
     (today (format-time-string "%Y-%m-%d"))
   
     prog-mode
   
     (fixme (if (derived-mode-p 'emacs-lisp-mode) ";; " comment-start) "FIXME ")
     (todo (if (derived-mode-p 'emacs-lisp-mode) ";; " comment-start) "TODO ")
     (bug (if (derived-mode-p 'emacs-lisp-mode) ";; " comment-start) "BUG ")
     (hack (if (derived-mode-p 'emacs-lisp-mode) ";; " comment-start) "HACK ")
   
     latex-mode
   
     (abstract "\\begin{abstract}\n" r> n> "\\end{abstract}")
     (align "\\begin{align}\n" r> n> "\\end{align}")
     (alignn "\\begin{align*}\n" r> n> "\\end{align*}")
     (gather "\\begin{gather}\n" r> n> "\\end{gather}")
     (gatherr "\\begin{gather*}\n" r> n> "\\end{gather*}")
     (appendix "\\begin{appendix}\n" r> n> "\\end{appendix}")
     (begin "\\begin{" (s env) "}" r> n> "\\end{" (s env) "}")
     (center "\\begin{center}\n" r> n> "\\end{center}")
     (displaymath "\\begin{displaymath}\n" r> n> "\\end{displaymath}")
     (document "\\begin{document}\n" r> n> "\\end{document}")
     (enumerate "\\begin{enumerate}\n\\item " r> n> "\\end{enumerate}")
     (equation "\\begin{equation}" r> n> "\\end{equation}")
     (flushleft "\\begin{flushleft}" r> n> "\\end{flushleft}")
     (flushright "\\begin{flushright}" r> n> "\\end{flushright}")
     (frac "\\frac{" p "}{" q "}")
     (fussypar "\\begin{fussypar}" r> n> "\\end{fussypar}")
     (itemize "\\begin{itemize}\n\\item " r> n> "\\end{itemize}")
     (letter "\\begin{letter}\n" r> n> "\\end{letter}")
     (math "\\begin{math}\n" r> n> "\\end{math}")
     (minipage "\\begin{minipage}[t]{0.5\linewidth}\n" r> n> "\\end{minipage}")
     (quotation "\\begin{quotation}\n" r> n> "\\end{quotation}")
     (quote "\\begin{quote}\n" r> n> "\\end{quote}")
     (sloppypar "\\begin{sloppypar}\n" r> n> "\\end{sloppypar}")
     (theindex "\\begin{theindex}\n" r> n> "\\end{theindex}")
     (trivlist "\\begin{trivlist}\n" r> n> "\\end{trivlist}")
     (verbatim "\\begin{verbatim}\n" r> n> "\\end{verbatim}")
     (verbatimm "\\begin{verbatim*}\n" r> n> "\\end{verbatim*}")
   
   * These are the current doom snipptes for python-mode in the yasippet format.
   
   def __contains__(self, el):
       $0# -*- mode: snippet -*-
   def __enter__(self):
       $0
   
       return self# -*- mode: snippet -*-
   def __exit__(self, type, value, traceback):
       $0# -*- mode: snippet -*-
   def __len__(self):
       $0# -*- mode: snippet -*-
   def __new__(mcs, name, bases, dict):
       $0
       return type.__new__(mcs, name, bases, dict)
   __all__ = [
           $0
   ]# -*- mode: snippet -*-
   parser.add_argument('-$1', '--$2',
                       $0)
   parser.add_argument('${1:varname}', $0)# -*- mode: snippet -*-
   assert $0# -*- mode: snippet -*-
   self.assertEqual($1, $2)# -*- mode: snippet -*-
   self.assertFalse($0)# -*- mode: snippet -*-
   self.assertIn(${1:member}, ${2:container})# -*- mode: snippet -*-
   self.assertNotEqual($1, $2)# -*- mode: snippet -*-
   assertRaises(${1:Exception}, ${2:fun})# -*- mode: snippet -*-
   with self.assertRaises(${1:Exception}):
        $0
   self.assertTrue($0)# -*- mode: snippet -*-
   from celery.contrib import rdb; rdb.set_trace()# -*- mode: snippet -*-
   class ${1:Name}($2):
       $0# -*- mode: snippet -*-
   @classmethod
   def ${1:method_name}(cls, $1):
       $0# -*- mode: snippet -*-
   def ${1:decorator}(func):
       $2
       def _$1(*args, **kwargs):
           $3
           ret = func(*args, **kwargs)
           $4
           return ret
   
       return _$1# -*- mode: snippet -*-
   def ${1:func_name}($2):
       ${3:`(or % "pass")`}# -*- mode: snippet -*-
   def ${1:method_name}(self${2:, $3}):
       ${4:`(or % "pass")`}# -*- mode: snippet -*-
   """$0
   """# -*- mode: snippet -*-
   >>> ${1:function calls}
   ${2:desired output}
   $0# -*- mode: snippet -*-
   def __eq__(self, other):
       return self.$1 == other.$1# -*- mode: snippet -*-
   for ${1:var} in ${2:collection}:
       ${3:`(or % "pass")`}# -*- mode: snippet -*-
   from ${1:lib} import ${2:funs}# -*- mode: snippet -*-
   def ${1:name}($2):
       \"\"\"$3
       ${2:$(python-args-to-docstring)}
       \"\"\"
       $0# -*- mode: snippet -*-
   if ${1:cond}:
       ${2:`(or % "pass")`}# -*- mode: snippet -*-
   if $1:
       ${2:`(or % "pass")`}
   else:
       $0# -*- mode: snippet -*-
   if __name__ == '__main__':
       ${1:`(or % "pass")`}# -*- mode: snippet -*-
   import ${1:lib}${2: as ${3:alias}}
   $0# -*- mode: snippet -*-
   def __init__(self${1:, args}):
       $0# -*- mode: snippet -*-
   def __init__(self$1):
       \"\"\"$2
       ${1:$(python-args-to-docstring)}
       \"\"\"
       $0# -*- mode: snippet -*-
   import code; code.interact(local=locals())# -*- mode: snippet; require-final-newline: nil -*-
   import ipdb; ipdb.set_trace()# -*- mode: snippet -*-
   def __iter__(self):
       return ${1:iter($2)}# -*- mode: snippet -*-
   lambda ${1:x}: $0# -*- mode: snippet -*-
   [${1:x} for $1 in ${2:list}]# -*- mode: snippet -*-
   logger = logging.getLogger(__name__)# -*- mode: snippet -*-
   logger = logging.getLogger("${1:name}")
   logger.setLevel(logging.${2:level})
   def main():
       $0# -*- mode: snippet -*-
   __metaclass__ = type# -*- mode: snippet -*-
   def ${1:method_name}(self${2:, $3}):
       $0
   def ${1:name}(self$2):
       \"\"\"$3
       ${2:$(python-args-to-docstring)}
       \"\"\"
       `%`$0# -*- mode: snippet -*-
   raise NotImplementedError# -*- mode: snippet -*-
   import numpy as np
   $0# -*- mode: snippet -*-
   def parse_arguments():
       parser = argparse.ArgumentParser(description='$1')
       $0
       return parser.parse_args()# -*- mode: snippet -*-
   parser = argparse.ArgumentParser(description='$1')
   $0# -*- mode: snippet -*-
   pass# -*- mode: snippet -*-
   print($0)# -*- mode: snippet -*-
   def ${1:foo}():
      doc = """${2:Doc string}"""
      def fget(self):
          return self._$1
   
      def fset(self, value):
          self._$1 = value
   
      def fdel(self):
          del self._$1
      return locals()
   $1 = property(**$1())
   
   $0
   ${1:regexp} = re.compile(r"${2:expr}")
   $0# -*- mode: snippet -*-
   def __repr__(self):
       $0# -*- mode: snippet -*-
   return $0# -*- mode: snippet -*-
   
   def main():
      pass
   
   if __name__ == '__main__':
      main()
   self.$0# -*- mode: snippet -*-
   self# -*- mode: snippet -*-
   self.$1 = $1# -*- mode: snippet -*-
   ${1:var}.setdefault(${2:key}, []).append(${3:value})# -*- mode: snippet -*-
   from setuptools import setup
   
   package = '${1:name}'
   version = '${2:0.1}'
   
   setup(name=package,
         version=version,
         description="${3:description}",
         url='${4:url}'$0)
   $0# -*- mode: snippet -*-
   sys.getsizeof($0)# -*- mode: snippet -*-
   @staticmethod
   def ${1:method_name}($1):
       $0# -*- mode: snippet -*-
   def __str__(self):
       $0# -*- mode: snippet -*-
   super(${1:Class}, self).${2:function}(${3:args})# -*- mode: snippet -*-
   class Test${1:toTest}(${2:unittest.TestCase}):
         $0
   import unittest
   ${1:from ${2:test_file} import *}
   
   $0
   
   if __name__ == '__main__':
       unittest.main()# -*- mode: snippet -*-
   import pdb; pdb.set_trace()# -*- mode: snippet -*-
   try:
       ${1:`(or % "pass")`}
   except ${2:Exception}:
       $0# -*- mode: snippet -*-
   try:
       $1
   except $2:
       $3
   else:
       $0# -*- mode: snippet -*-
   def __unicode__(self):
       $0# -*- mode: snippet -*-
   while ${1:True}:
         $0# -*- mode: snippet -*-
   with ${1:expr}${2: as ${3:alias}}:
        $0# -*- mode: snippet -*-
   from __future__ import with_statement%
   
   Please convert all the given yasnipptes to the new tempel format described above.
   Avoid using "\n" for new lines, just use =n= symbol as described above.
   Remember to use a lips symbol to define the template name, instead of a string.
   So (templ_name ...) instead of ("templ_name").

   

   MArpogaus committed Feb 16, 2024
   Configuration menu

   • View commit details
   • Copy full SHA for fe10805
   • Browse repository at this point

   Copy the full SHA

   fe10805 View commit details

   Browse the repository at this point in the history