├── Lib
    └── site-packages
    │   ├── builder.py
    │   └── components
    │       ├── __init__.py
    │       ├── arginput.py
    │       └── argument.py
├── README.rst
├── brython_dist.js
├── index.html
└── resources
    ├── gears.gif
    └── style.css


/Lib/site-packages/builder.py:
--------------------------------------------------------------------------------
  1 | #! /usr/bin/env python3
  2 | #
  3 | # Interpreter version: brython
  4 | #
  5 | from collections import OrderedDict
  6 | 
  7 | from browser import document as doc
  8 | 
  9 | from components import ArgInput
 10 | from components import Argument
 11 | from components import bind_links
 12 | 
 13 | 
 14 | # Functions & objects =========================================================
 15 | def hide_help_frame(ev):
 16 |     """
 17 |     Remove help popup from the HTML.
 18 |     """
 19 |     doc["help_placeholder"].innerHTML = ""
 20 |     doc["black_overlay"].style.display = "none"
 21 | 
 22 | 
 23 | def parse_arguments(ev):
 24 |     """
 25 |     Parse arguments from inputs and save the result to the output textarea.
 26 |     """
 27 |     text = a.__str__()
 28 | 
 29 |     if doc["output_use_spaces"].checked:
 30 |         text = text.replace("\t", "    ")
 31 | 
 32 |     doc["output"].value = text
 33 | 
 34 | 
 35 | # Object definitions ==========================================================
 36 | class ArgParser:
 37 |     """
 38 |     This object holds references to all argument tables and global argparse
 39 |     settings.
 40 | 
 41 |     Attr:
 42 |         arguments (ordered dict): References to :class:`Argument` objects.
 43 |         element (obj): Reference to `argument_parser` <span>.
 44 |         inputs (ordered dict): Reference to global settings inputs.
 45 |     """
 46 |     def __init__(self):
 47 |         self.arguments = OrderedDict()
 48 |         self.add_argument_callback()
 49 | 
 50 |         # parse all inputs belonging to the argparser objects
 51 |         self.element = doc["argument_parser"]
 52 |         arguments = self.element.get(selector="input") or []
 53 |         arguments.extend(self.element.get(selector="textarea") or [])
 54 | 
 55 |         self.inputs = OrderedDict(
 56 |             (x.id.split("_")[-1], ArgInput(element=x, parent=self))
 57 |             for x in arguments if x
 58 |         )
 59 | 
 60 |     def new_argument(self):
 61 |         """
 62 |         Create new :class:`Argument` object and bind events to the buttons.
 63 | 
 64 |         Returns:
 65 |             Argument object: Created object.
 66 |         """
 67 |         arg = Argument()
 68 |         self.bind_argument(arg)
 69 |         return arg
 70 | 
 71 |     def bind_argument(self, argument):
 72 |         """
 73 |         Bind buttons in `argument` object to callbacks methods in this object.
 74 |         """
 75 |         doc[argument.ID + "_argument_button_add"].bind(
 76 |             "click",
 77 |             self.add_argument_callback
 78 |         )
 79 |         doc[argument.ID + "_argument_button_rm"].bind(
 80 |             "click",
 81 |             self.remove_argument_callback
 82 |         )
 83 |         doc[argument.ID + "_argument_button_up"].bind(
 84 |             "click",
 85 |             self.move_arg_up_callback
 86 |         )
 87 |         doc[argument.ID + "_argument_button_down"].bind(
 88 |             "click",
 89 |             self.move_arg_down_callback
 90 |         )
 91 | 
 92 |     def add_argument_callback(self, ev=None):
 93 |         """
 94 |         Add new argument into HTML representation and internal dict.
 95 | 
 96 |         Note:
 97 |             This method is called asynchronously, when the button is pressed.
 98 |         """
 99 |         arg = self.new_argument()
100 |         self.arguments[arg.ID] = arg
101 | 
102 |     def remove_argument_callback(self, ev=None):
103 |         """
104 |         Remove argument from HTML representation and internal dict.
105 | 
106 |         ID of the argument is parsed from `ev` parameter.
107 | 
108 |         Note:
109 |             This method is called asynchronously, when the button is pressed.
110 |         """
111 |         if len(self.arguments) > 1:
112 |             ID = ev.target.id.split("_")[0]
113 |             self.arguments[ID].remove()
114 |             del self.arguments[ID]
115 | 
116 |     def move_arg_up_callback(self, ev):
117 |         """
118 |         Switch two arguments - move the argument where the button was pressed
119 |         down.
120 | 
121 |         Note:
122 |             This method is called asynchronously, when the button is pressed.
123 |         """
124 |         ID = ev.target.id.split("_")[0]
125 |         keys = list(self.arguments.keys())
126 |         ioa = keys.index(ID)
127 | 
128 |         if len(self.arguments) > 1 and ioa > 0:
129 |             arg1 = self.arguments[keys[ioa]]
130 |             arg2 = self.arguments[keys[ioa - 1]]
131 | 
132 |             arg1.switch(arg2)
133 | 
134 |     def move_arg_down_callback(self, ev=None):
135 |         """
136 |         Switch two arguments - move the argument where the button was pressed
137 |         down.
138 | 
139 |         Note:
140 |             This method is called asynchronously, when the button is pressed.
141 |         """
142 |         ID = ev.target.id.split("_")[0]
143 |         keys = list(self.arguments.keys())
144 |         ioa = keys.index(ID)
145 | 
146 |         if len(self.arguments) > 1 and ioa < len(self.arguments) - 1:
147 |             arg1 = self.arguments[keys[ioa]]
148 |             arg2 = self.arguments[keys[ioa + 1]]
149 | 
150 |             arg1.switch(arg2)
151 | 
152 |     def __str__(self):
153 |         # read value of all inputs in this object, pick only inputs with value
154 |         vals = [
155 |             str(x)
156 |             for x in self.inputs.values()
157 |             if x.wrapped_value is not None
158 |         ]
159 | 
160 |         # add \n\t only if there are used inputs
161 |         inp_string = ",\n\t".join(vals)
162 |         if inp_string:
163 |             inp_string = "\n\t" + inp_string + "\n"
164 | 
165 |         # put inputs to template
166 |         ARG_PARSER_TEMPLATE = """import argparse
167 | 
168 | # ...
169 | parser = argparse.ArgumentParser($parameters)
170 | $arguments
171 | args = parser.parse_args()
172 | 
173 | """
174 |         out = ARG_PARSER_TEMPLATE.replace("$parameters", inp_string)
175 | 
176 |         # convert arguments to strings
177 |         arguments = ""
178 |         for item in self.arguments.values():
179 |             arguments += item.__str__()
180 | 
181 |         # put arguments to template
182 |         return out.replace("$arguments", arguments)
183 | 
184 | 
185 | # Main program ================================================================
186 | if __name__ == '__main__':
187 |     a = ArgParser()
188 | 
189 |     # bind click on output textarea with generation of the source code
190 |     doc["output"].bind("click", parse_arguments)
191 |     doc["output_use_spaces"].bind("click", parse_arguments)
192 | 
193 |     # bind links with popup help
194 |     doc["black_overlay"].bind("click", hide_help_frame)
195 |     bind_links(doc["argument_parser"])
196 | 
197 |     doc["loading_gears_background"].style.display = "none"


--------------------------------------------------------------------------------
/Lib/site-packages/components/__init__.py:
--------------------------------------------------------------------------------
1 | #! /usr/bin/env python3
2 | #
3 | # Interpreter version: brython
4 | #
5 | 
6 | from .arginput import ArgInput
7 | from .argument import Argument
8 | from .argument import bind_links
9 | 


--------------------------------------------------------------------------------
/Lib/site-packages/components/arginput.py:
--------------------------------------------------------------------------------
  1 | #! /usr/bin/env python3
  2 | #
  3 | # Interpreter version: brython
  4 | #
  5 | from browser import document as doc
  6 | 
  7 | 
  8 | def type_on_change_event(self, ev):
  9 |     """
 10 |     This code switches select for input when user selects `Custom` in
 11 |     `type` select element.
 12 |     """
 13 |     if ev.target.value == "custom":
 14 |         ID = self.element.id
 15 |         new_html = '<input id="%s" type="text" _non_str="true" ' % ID
 16 |         new_html += '_non_key="" _default="" />'
 17 |         ev.target.outerHTML = new_html
 18 | 
 19 |         self.element = doc[ID]
 20 | 
 21 | 
 22 | def action_on_change_event(self, ev):
 23 |     """
 24 |     Event raised when user changes value in `action` input.
 25 |     """
 26 |     bool_switches = [
 27 |         "count",
 28 |         "store_true",
 29 |         "store_false",
 30 |         "help",
 31 |         "version"
 32 |     ]
 33 |     bool_disables = [
 34 |         "type",
 35 |         "const",
 36 |         "nargs",
 37 |         "choices",
 38 |         "default",
 39 |         "metavar"
 40 |     ]
 41 | 
 42 |     # enable/disable other inputs
 43 |     disabled = (ev.target.value in bool_switches)
 44 |     disabled_inputs = [self.parent.inputs[x] for x in bool_disables]
 45 | 
 46 |     for item in disabled_inputs:
 47 |         item.disabled = disabled
 48 | 
 49 | 
 50 | class ArgInput:
 51 |     """
 52 |     This class is used to wrap <input>, <select> and <textarea> HTML elements.
 53 | 
 54 |     It provides unified setters and getters for those elements, allows to
 55 |     define callbacks when clicked/changed, switch two :class:`ArgInput`
 56 |     objects, serialize them to string, enable/disable them and so on.
 57 | 
 58 |     Attr:
 59 |         ID (str): Unique ID. Thanks to this, objects know which HTML elements
 60 |                   belong to them.
 61 |         name (str): Name of the argparse argument - `descr`, `type` and so on.
 62 |         color (str): Default color for input text.
 63 |         parent (str): Pointer to :class:`Argument`, where this object is
 64 |                       stored. This can be used to disable other inputs and so
 65 |                       on.
 66 |         element (obj): Pointer to HTML element.
 67 |         is_text_type (bool): True for inputs/textareas, false for select,
 68 |                              checkboxes and others.
 69 |         wrapped_value (str): Value used when element is serialized to python.
 70 |         value (str): Clean value of the element.
 71 |         disabled (bool): Property which allows to enable/disable HTML element.
 72 |     """
 73 |     def __init__(self, element, parent):
 74 |         self.ID = element.id.split("_")[0]
 75 |         self.name = element.id.split("_")[-1]
 76 |         self.color = "gray"
 77 | 
 78 |         self.parent = parent
 79 |         self.element = element  # reference to html object
 80 | 
 81 |         if self.element.value == "":
 82 |             self.element.value = self.element.title
 83 |             self.element.style.color = self.color
 84 | 
 85 |         if self.is_text_type:
 86 |             element.bind("focus", self.input_remove_help_callback)
 87 |             element.bind("blur", self.input_add_help_callback)
 88 |         elif element.nodeName == "SELECT":
 89 |             element.bind("change", self.on_change_callback)
 90 | 
 91 |         self.on_change_events = {
 92 |             "type": type_on_change_event,
 93 |             "action": action_on_change_event
 94 |         }
 95 | 
 96 |     def on_change_callback(self, ev):
 97 |         """
 98 |         Callback called every time the select HTML element is changed.
 99 |         """
100 |         func = self.on_change_events.get(self.name, None)
101 | 
102 |         if func:
103 |             func(self, ev)
104 | 
105 |     def input_remove_help_callback(self, ev):
106 |         """
107 |         Called when user clicks to the input/textarea element to remove help.
108 |         """
109 |         if ev.target.value == ev.target.title:
110 |             ev.target.value = ""
111 |             ev.target.style.color = "black"
112 | 
113 |     def input_add_help_callback(self, ev):
114 |         """
115 |         Called every time user removes focus from input element to restere
116 |         help, if the input is blank.
117 |         """
118 |         if ev.target.value == "":
119 |             ev.target.value = ev.target.title
120 |             ev.target.style.color = self.color
121 | 
122 |     @property
123 |     def wrapped_value(self):
124 |         """
125 |         Property to wrap the internal raw value to string.
126 | 
127 |         This is used for string serialization - some of the elements needs to
128 |         add quotes, some have default values and so on.
129 |         """
130 |         if self.disabled:
131 |             return None
132 | 
133 |         # selects
134 |         if not self.is_text_type and \
135 |            self.element.value == self.element._default:
136 |             return None
137 | 
138 |         # checkboxes
139 |         if self.element.type == "checkbox":
140 |             value = self.element.checked
141 | 
142 |             if self.element._default == str(value):
143 |                 return None
144 | 
145 |             return value
146 | 
147 |         # text elements - textearea/input
148 |         if self.element.value != self.element.title:
149 |             # nargs are strings only in some special cases (+*?)
150 |             if self.name == "nargs" and self.element.value in "+*?":
151 |                 return '"%s"' % self.element.value
152 | 
153 |             if self.element._non_str.strip():
154 |                 return self.element.value
155 | 
156 |             return self._wrap_strings()
157 | 
158 |         return None
159 | 
160 |     def _wrap_strings(self):
161 |         def wrap(text, first_wrap, other_wraps, other_indents, line_len=79):
162 |             """
163 |             Wrap `text` after `first_wrap` chars and then every `other_wraps`
164 |             characters.
165 | 
166 |             Args:
167 |                 text (str): Text which will be wrapped.
168 |                 first_wrap (int): Perform first wrap after `first_wrap`
169 |                     characters.
170 |                 other_wraps (int): Wrap other lines after `other_wraps`
171 |                     characters.
172 | 
173 |             Returns:
174 |                 list: List of strings wrapped after `first_wrap` and \
175 |                       `other_wraps`.
176 |             """
177 |             out = []
178 | 
179 |             if len(text) <= line_len:
180 |                 return text
181 | 
182 |             # first wrap
183 |             out.append(text[:first_wrap])
184 |             text = text[first_wrap:]
185 | 
186 |             # other wraps
187 |             while len(text) > other_wraps:
188 |                 out.append(other_indents + text[:other_wraps])
189 |                 text = text[other_wraps:]
190 | 
191 |             return "\\\n".join(out + [other_indents + text])
192 | 
193 |         val = self.element.value.replace(r"\\", r"\\")  # don't even ask
194 | 
195 |         # use """ for multiline strings
196 |         quote = '"'
197 |         argument_len = len((4 * " ") + self.name + "=" + quote + val + quote)
198 |         MAX_LINELEN = 79
199 |         if "\n" in val or argument_len >= MAX_LINELEN:
200 |             quote = quote * 3
201 | 
202 |         # escape quotes in string
203 |         if quote in val:
204 |             val = val.replace(quote, quote.replace('"', '\\"'))
205 | 
206 |         # can fit to one line?
207 |         first_indentation = "    %s=%s" % (self.name, quote)
208 |         if len(first_indentation + val + quote) <= MAX_LINELEN:
209 |             return quote + val + quote
210 | 
211 |         # wrap long lines
212 |         val = wrap(
213 |             text=quote + val,
214 |             first_wrap=MAX_LINELEN - len(first_indentation),
215 |             other_wraps=MAX_LINELEN - len(first_indentation),
216 |             other_indents=len(first_indentation) * " ",
217 |             line_len=MAX_LINELEN,
218 |         )
219 |         return val + quote
220 | 
221 |     @property
222 |     def value(self):
223 |         """
224 |         Property to access value of the HTML element.
225 |         """
226 |         if self.element.type == "checkbox":
227 |             return self.element.checked
228 | 
229 |         return self.element.value
230 | 
231 |     @value.setter
232 |     def value(self, new_val):
233 |         """
234 |         Property to set value of the HTML element.
235 |         """
236 |         if self.element.type == "checkbox":
237 |             self.element.checked = new_val
238 |         else:
239 |             self.element.value = new_val
240 | 
241 |     @property
242 |     def is_text_type(self):
243 |         """
244 |         Getter showing whether the ArgInput object wraps text element or
245 |         switch/checkbox.
246 |         """
247 |         return (self.element.type == "text" or
248 |                 self.element.nodeName == "TEXTAREA")
249 | 
250 |     @property
251 |     def disabled(self):
252 |         """
253 |         Abstration over disabled property.
254 |         """
255 |         return self.element.disabled
256 | 
257 |     @disabled.setter
258 |     def disabled(self, val):
259 |         """
260 |         Setteer for diabled property.
261 |         """
262 |         self.element.disabled = val
263 | 
264 |     def switch(self, inp2):
265 |         """
266 |         Switch two ArgInput objects.
267 | 
268 |         Switch values, if the objects are of the same type, or whole HTML
269 |         elements, if they are different types.
270 | 
271 |         Args:
272 |             inp2 (object): :class:`ArgInput` class.
273 |         """
274 |         inp1 = self
275 | 
276 |         el1, el2 = inp1.element, inp2.element
277 |         el1.style.color, el2.style.color = el2.style.color, el1.style.color
278 | 
279 |         if inp1.element.nodeName != inp2.element.nodeName:
280 |             val1, val2 = inp1.value, inp2.value
281 |             el1.id, el2.id = el2.id, el2.id
282 |             el1.outerHTML, el2.outerHTML = el2.outerHTML, el2.outerHTML
283 | 
284 |             inp1.element = doc[inp1.ID + "_argument_" + inp1.name]
285 |             inp2.element = doc[inp2.ID + "_argument_" + inp2.name]
286 |             inp1.value, inp2.value = val2, val1
287 |         else:
288 |             inp1.value, inp2.value = inp2.value, inp1.value
289 | 
290 |     def __str__(self):
291 |         if self.element._non_key:
292 |             return str(self.wrapped_value)
293 | 
294 |         return self.name + "=" + str(self.wrapped_value)
295 | 
296 |     def __hash__(self):
297 |         return hash(self.ID)
298 | 


--------------------------------------------------------------------------------
/Lib/site-packages/components/argument.py:
--------------------------------------------------------------------------------
  1 | #! /usr/bin/env python3
  2 | #
  3 | # Interpreter version: brython
  4 | #
  5 | from collections import OrderedDict
  6 | 
  7 | from browser import html
  8 | from browser import document as doc
  9 | 
 10 | from .arginput import ArgInput
 11 | 
 12 | 
 13 | # Variables ===================================================================
 14 | _ARG_COUNTER = range(100000).__iter__()  # argument table ID pool
 15 | ARG_TEMPLATE = """parser.add_argument(
 16 | \t$parameters
 17 | )
 18 | """
 19 | 
 20 | 
 21 | def get_id_from_pool():
 22 |     """
 23 |     Returns:
 24 |         int: Incremented ID from previous call.
 25 |     """
 26 |     return _ARG_COUNTER.__next__()
 27 | 
 28 | 
 29 | def show_help_frame(ev):
 30 |     """
 31 |     Add help popup to the HTML.
 32 |     """
 33 |     src = '<iframe id="white_content" src="' + ev.target.fhref + '"></iframe>'
 34 | 
 35 |     doc["help_placeholder"].innerHTML = src
 36 |     doc["black_overlay"].style.display = "inline"
 37 |     doc["white_content"].style.display = "inline"
 38 | 
 39 | 
 40 | def bind_links(container):
 41 |     """
 42 |     Bind all links in given `container` to popup help/iframe.
 43 | 
 44 |     Note:
 45 |         This function can be called only once for each link, or it wouln't
 46 |         work.
 47 |     """
 48 |     # bind all links to show popup with help
 49 |     for el in container.get(selector="a"):
 50 |         el.fhref = el.href
 51 |         el.href = "#"
 52 |         el.bind("click", show_help_frame)
 53 | 
 54 | 
 55 | class Argument:
 56 |     """
 57 |     This object is used to represent sets of :class:`ArgInput` objects, in
 58 |     order as they are defined in <span> with ID `arguments`.
 59 | 
 60 |     It can also :func:`remove` itself from the HTML page and serialize content
 61 |     of the inputs to python code.
 62 | 
 63 |     Attr:
 64 |         ID (str): Unique ID. Thanks to this, objects know which HTML elements
 65 |                   belong to them.
 66 |         element (obj): Pointer to corresponding HTML table with inputs.
 67 |         inputs (ordered dict): Dictionary with HTML inputs stored in format
 68 |                ``{"$NAME": el_reference}`` where ``$NAME`` is last part of
 69 |                HTML `id` splitted by ``_``.
 70 |     """
 71 |     def __init__(self):
 72 |         self.ID = str(get_id_from_pool())
 73 |         self.element = self._add_html_repr()
 74 | 
 75 |         arguments = self.element.get(selector="input")
 76 |         arguments = [x for x in arguments if x.type != "button"]
 77 |         arguments.extend(self.element.get(selector="select"))
 78 |         arguments.extend(self.element.get(selector="textarea"))
 79 | 
 80 |         self.inputs = OrderedDict(
 81 |             (x.id.split("_")[-1], ArgInput(element=x, parent=self))
 82 |             for x in arguments if x
 83 |         )
 84 | 
 85 |         bind_links(self.element)
 86 | 
 87 |     def _add_html_repr(self):
 88 |         """
 89 |         Add HTML representation of the argument to the HTML page.
 90 |         """
 91 |         template = doc["argument_template"].innerHTML
 92 | 
 93 |         table = html.TABLE(id=self.ID + "_argument", Class="argument_table")
 94 |         table.html = template.replace("$ID", self.ID)
 95 |         doc["arguments"] <= table
 96 | 
 97 |         return table
 98 | 
 99 |     def remove(self):
100 |         """
101 |         Remove argument from HTML.
102 |         """
103 |         doc[self.ID + "_argument"].outerHTML = ""
104 | 
105 |     def switch(self, arg2):
106 |         """
107 |         Switch all values in this Argument with `arg2`.
108 |         """
109 |         assert isinstance(arg2, Argument)
110 | 
111 |         for key in self.inputs.keys():
112 |             self.inputs[key].switch(arg2.inputs[key])
113 | 
114 |     def __str__(self):
115 |         # collect strings from all inputs
116 |         vals = [
117 |             str(x)
118 |             for x in self.inputs.values()
119 |             if x.wrapped_value is not None
120 |         ]
121 | 
122 |         if not vals:
123 |             return ""
124 | 
125 |         return ARG_TEMPLATE.replace(
126 |             "$parameters",
127 |             ",\n\t".join(vals)
128 |         )
129 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
 1 | argparse builder
 2 | ================
 3 | 
 4 | This project helps you to quickly create complex ``argparse`` interfaces.
 5 | Active parts of this tool are written in brython_ (python dialect for the web
 6 | browsers).
 7 | 
 8 | .. _brython: http://brython.info
 9 | 
10 | Demo
11 | ----
12 | 
13 | Live demo can be found here:
14 | 
15 | - http://kitakitsune.org/argparse_builder/
16 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
  1 | <HTML>
  2 | <head>
  3 |     <title>Argparse builder</title>
  4 |     <link rel="stylesheet" type="text/css" href="resources/style.css">
  5 |     <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  6 |     <script src="brython_dist.js"></script>
  7 |     <script type="text/python3" src="Lib/site-packages/builder.py"></script>
  8 | </head>
  9 | <body onload="brython(1)">
 10 | 
 11 | 
 12 | <h1><code>argparse</code> builder</h1>
 13 | 
 14 | <p class="perex">
 15 |     Python 2.7 <code><a href="https://docs.python.org/2.7/library/argparse.html">argparse</a></code> builder (see <a href="https://github.com/Bystroushaak/argparse_builder">github for sources</a>).
 16 | 
 17 |     This webpage helps you to quickly create complex <code>argparse</code> interfaces.
 18 |     Active <a href="./scripts/builder.py">parts</a> of this tool are written in <a href="http://brython.info">brython</a> (python dialect for the web browsers).
 19 | </p>
 20 | 
 21 | <h2>ArgumentParser object</h2>
 22 | 
 23 | <span id="argument_parser">
 24 | <fieldset>
 25 |     <legend><a href="https://docs.python.org/2.7/library/argparse.html#prog">prog</a></legend>
 26 |     <input type="text" id="ArgumentParser_prog" title="The name of the program. Default sys.argv[0]." _non_str="" _non_key="" _default="">
 27 | </fieldset>
 28 | 
 29 | <fieldset>
 30 |     <legend><a href="https://docs.python.org/2.7/library/argparse.html#usage">usage</a></legend>
 31 |     <input type="text" id="ArgumentParser_usage" title="The string describing the program usage (default: generated from arguments added to parser)." _non_str="" _non_key="" _default="">
 32 | </fieldset>
 33 | 
 34 | <fieldset>
 35 |     <legend><a href="https://docs.python.org/2.7/library/argparse.html#description">description</a></legend>
 36 |     <textarea id="ArgumentParser_description" title="Text to display before the argument help (default: None). It shouldn't be too long - don't mistake this with man page." _non_str="" _non_key="" _default=""></textarea>
 37 | </fieldset>
 38 | 
 39 | <fieldset>
 40 |     <legend><a href="https://docs.python.org/2.7/library/argparse.html#epilog">epilog</a></legend>
 41 |     <textarea id="ArgumentParser_epilog" title="Text to display after the argument help (default: None)." _non_str="" _non_key="" _default=""></textarea>
 42 | </fieldset>
 43 | 
 44 | <fieldset>
 45 |     <legend><a href="https://docs.python.org/2.7/library/argparse.html#add-help">add_help</a></legend>
 46 |     <p>
 47 |         <input type="checkbox" checked="true" id="ArgumentParser_add_help" _non_str="true" _non_key="" _default="True">
 48 |         Add a <code>-h</code>/<code>–help</code> option to the parser.
 49 |     </p>
 50 | </fieldset>
 51 | </span>
 52 | 
 53 | <h2>Arguments</h2>
 54 | 
 55 | <span id="arguments">
 56 | <table class="argument_table" id="argument_template">
 57 |  <tr>
 58 |   <td class="buttons" id="$ID_argument_buttons">
 59 |     <input id="$ID_argument_button_up" title="Move argument up" type="button" value="↑"><br />
 60 |     <input id="$ID_argument_button_add" title="Add new argument" type="button" value="+"><br />
 61 |     <input id="$ID_argument_button_down" title="Move argument down" type="button" value="↓" /><br />
 62 |     <hr class="remove_button" />
 63 |     <input id="$ID_argument_button_rm" title="Remove argument" type="button" value="✖">
 64 |   </td>
 65 |   <td class="argument">
 66 |     <table>
 67 |         <tr>
 68 |             <td>
 69 |                 <span class="descr">
 70 |                     <a href="https://docs.python.org/2.7/library/argparse.html#name-or-flags">flag</a>:
 71 |                 </span>
 72 |                 <q><input id="$ID_argument_flag" title="Short flag like -h." type="text" _non_str="" _non_key="true" _default=""></q>
 73 |             </td>
 74 |             <td>
 75 |                 <span class="descr">
 76 |                     <a href="https://docs.python.org/2.7/library/argparse.html#name-or-flags">name</a>:
 77 |                 </span>
 78 |                 <q><input id="$ID_argument_name" title="Long flag like --help." type="text" _non_str="" _non_key="true" _default=""></q>
 79 |             </td>
 80 |             <td>
 81 |                 <span class="descr">
 82 |                     <a href="https://docs.python.org/2.7/library/argparse.html#action">action</a>:
 83 |                 </span>
 84 |                 <select name="action" id="$ID_argument_action" _non_str="" _non_key="" _default="store">
 85 |                     <option value="store" selected="selected">store</option>
 86 |                     <option value="store_const">store_const</option>
 87 |                     <option value="store_true">store_true</option>
 88 |                     <option value="store_false">store_false</option>
 89 |                     <option value="append_const">append_const</option>
 90 |                     <option value="count">count</option>
 91 |                     <option value="help">help</option>
 92 |                     <option value="version">version</option>
 93 |                 </select>
 94 |             </td>
 95 |         </tr>
 96 | 
 97 |         <tr>
 98 |             <td>
 99 |                 <span class="descr">
100 |                     <a href="https://docs.python.org/2.7/library/argparse.html#nargs">nargs</a>:
101 |                 </span>
102 |                 <input id="$ID_argument_nargs" title="N/?/*/+/argparse.REMAINDER" type="text" _non_str="true" _non_key="" _default="">
103 |             </td>
104 |             <td>
105 |                 <span class="descr">
106 |                     <a href="https://docs.python.org/2.7/library/argparse.html#const">const</a>:
107 |                 </span>
108 |                 <input id="$ID_argument_const" title="Constant value for action." type="text" _non_str="true" _non_key="" _default="">
109 |             </td>
110 |             <td>
111 |                 <span class="descr">
112 |                     <a href="https://docs.python.org/2.7/library/argparse.html#default">default</a>:
113 |                 </span>
114 |                 <input id="$ID_argument_default" title="Default value. Use quotes for string." type="text" _non_str="true" _non_key="" _default="">
115 |             </td>
116 |         </tr>
117 | 
118 |         <tr>
119 |             <td><span class="descr">
120 |                 <a href="https://docs.python.org/2.7/library/argparse.html#type">type</a>:
121 |             </span>
122 |                 <select name="type" id="$ID_argument_type" _non_str="true" _non_key="" _default="str">
123 |                     <option value="int">int</option>
124 |                     <option value="float">float</option>
125 |                     <option value="long">long</option>
126 |                     <option value="str" selected="selected">str</option>
127 |                     <option value="custom">Custom</option>
128 |                 </select>
129 |             </td>
130 |             <td>
131 |                 <span class="descr">
132 |                     <a href="https://docs.python.org/2.7/library/argparse.html#choices">choices</a>:
133 |                 </span>
134 |                 <input id="$ID_argument_choices" title="A container of the allowable values for the argument." type="text" _non_str="true" _non_key="" _default="">
135 |             </td>
136 |             <td>
137 |                 <span class="descr">
138 |                     <a href="https://docs.python.org/2.7/library/argparse.html#required">required</a>:
139 |                 </span>
140 |                 <input id="$ID_argument_required" type="checkbox" _non_str="true" _non_key="" _default="False">
141 |             </td>
142 |         </tr>
143 | 
144 |         <tr>
145 |             <td>
146 |                 <span class="descr">
147 |                     <a href="https://docs.python.org/2.7/library/argparse.html#metavar">metavar</a>:
148 |                 </span>
149 |                 <q><input id="$ID_argument_metavar" title="Specify alternative data example in help." type="text" _non_str="" _non_key="" _default=""></q>
150 |             </td>
151 |             <td>
152 |                 <span class="descr">
153 |                     <a href="https://docs.python.org/2.7/library/argparse.html#dest">dest</a>:
154 |                 </span>
155 |                 <q><input id="$ID_argument_dest" title="Name of variable in parsed object." type="text" _non_str="" _non_key="" _default=""></q>
156 |             </td>
157 |             <td></td>
158 |         </tr>
159 |     </table>
160 |     <textarea id="$ID_argument_help" title="Help (a brief description of what the argument does)." _non_str="" _non_key="" _default=""></textarea>
161 |   </td>
162 |  </tr>
163 | </table>
164 | </span>
165 | 
166 | <h2>Output</h2>
167 | 
168 | <p>
169 |     <input type="checkbox" checked="true" id="output_use_spaces">
170 |     Use spaces for indentation.
171 | </p>
172 | 
173 | <textarea id="output" title="Click here to get the output." href="https://docs.python.org/2.7/library/argparse.html#metavar">Click here to get output.</textarea>
174 | 
175 | <div id="black_overlay"></div>
176 | 
177 | <span id="help_placeholder"></span>
178 | 
179 | <div id="loading_gears_background">
180 |     <div id="loading_gears_foreground">
181 |     <img src="resources/gears.gif" />
182 |     </div>
183 | </div>
184 | 
185 | </body>
186 | </HTML>
187 | 


--------------------------------------------------------------------------------
/resources/gears.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Bystroushaak/argparse_builder/85031d2d9e35cdb8fe9ee52dc7acf4028ef9dbe0/resources/gears.gif


--------------------------------------------------------------------------------
/resources/style.css:
--------------------------------------------------------------------------------
  1 | html{
  2 |     background-color: #CCCCCC;
  3 | }
  4 | 
  5 | body {
  6 |     display: block;
  7 |     margin: 0 auto;
  8 | 
  9 |     margin-top: 1em;
 10 |     margin-bottom: 1em;
 11 | 
 12 |     width: 57em; /* ~900px */
 13 |     padding: 1em;
 14 |     background-color: #FFFFFF;
 15 |     
 16 |     border: 1px solid black;
 17 |     text-align: justify;
 18 | }
 19 | 
 20 | h1 a, h2 a, h3 a {
 21 |     text-decoration: none;
 22 |     color: black;
 23 | }
 24 | 
 25 | h1 a:hover, h2 a:hover, h3 a:hover {
 26 |     text-decoration: underline;
 27 | }
 28 | 
 29 | .perex {
 30 |     font-style: italic;
 31 | }
 32 | 
 33 | fieldset p {
 34 |     font-style: italic;
 35 |     margin: 0;
 36 | }
 37 | 
 38 | fieldset {
 39 |     border: 0;
 40 | }
 41 | 
 42 | fieldset legend {
 43 |     font-weight: bold;
 44 |     font-family: monospace;
 45 | }
 46 | 
 47 | fieldset textarea {
 48 |     width: 100%;
 49 | }
 50 | 
 51 | fieldset input {
 52 |     width: 100%;
 53 | }
 54 | 
 55 | fieldset p input {
 56 |     width: auto;
 57 | }
 58 | 
 59 | .buttons {
 60 |     width: 0.8em;
 61 |     font-size: 3em;
 62 | 
 63 |     margin: 0;
 64 |     padding: 0;
 65 | 
 66 |     line-height: 0.8em;
 67 |     text-align: center;
 68 | }
 69 | 
 70 | .remove_button {
 71 |     padding: 0;
 72 |     margin: 0.1em;
 73 | }
 74 | 
 75 | .argument {
 76 |     word-wrap: break-word;
 77 |     word-break: break-all;
 78 | }
 79 | 
 80 | .argument_table {
 81 |     border: 1px solid lightgray;
 82 |     margin-bottom: 1em;
 83 | }
 84 | 
 85 | .argument_table input[type="button"] {
 86 |     height: 2.9em;
 87 |     font-weight: bold;
 88 | }
 89 | 
 90 | #argument_template {
 91 |     display: none;
 92 | }
 93 | 
 94 | textarea {
 95 |     width: 100%;
 96 | }
 97 | 
 98 | table {
 99 |     width: 100%;
100 | }
101 | 
102 | .descr {
103 |     float: left;
104 |     width: 30%;
105 |     font-family: monospace;
106 | }
107 | 
108 | #output {
109 |     min-height: 40em;
110 | }
111 | 
112 | q {
113 |     margin-left: -0.5em;
114 | }
115 | 
116 | #black_overlay {
117 |     display: none;
118 |     position: absolute;
119 |     top: 0%;
120 |     left: 0%;
121 |     width: 100%;
122 |     height: 200%;
123 |     background-color: black;
124 |     z-index: 1001;
125 |     -moz-opacity: 0.8;
126 |     opacity:.80;
127 |     filter: alpha(opacity=80);
128 | }
129 | 
130 | #white_content {
131 |     display: none;
132 |     position: absolute;
133 |     top: 10%;
134 |     left: 15%;
135 |     width: 70%;
136 |     height: 80%;
137 |     border: 1px solid orange;
138 |     z-index: 1002;
139 |     overflow: auto;
140 |     background-color: white;
141 | }
142 | 
143 | #loading_gears_background {
144 |     position: absolute;
145 |     top: 0%;
146 |     left: 0%;
147 |     width: 100%;
148 |     height: 200%;
149 |     background: rgba(0, 0, 0, 0.8);
150 |     z-index:1001;
151 | }
152 | 
153 | #loading_gears_foreground {
154 |     display: block;
155 |     margin: 0 auto;
156 | 
157 |     margin-top: 20%;
158 | 
159 |     width: 15em; /* ~900px */
160 |     padding: 1em;
161 |     background-color: #FFFFFF;
162 | 
163 |     color: rgba(255, 255, 255, 1);
164 |     border: 2px solid black;
165 | 
166 |     text-align: center;
167 | }


--------------------------------------------------------------------------------