o 6dK@sddlmZmZmZmZddlmZmZddlm Z ddl Z ddl Z ddl Z ddl Z ddlZddlmZddlmZmZmZdZer_ddlmZddlZejejejfZed Zed Zd d Ze eGd dde Z!Gddde!Z"dS))absolute_importdivisionprint_functionunicode_literals)ABCMetaabstractmethod)contextmanagerN) doc_ref_re)is_aliasresolve_aliases strip_aliasF)ApiKVcCs|jD]}|jD]}|}t|dr!t|j|_|j}t|dsq q|jD]K}|jD] }|jD]}t|q2q-|j D]/}t|j t|j t|j t |j rX|j j|_ t |j rb|j j|_ t |j rl|j j|_ q=g|_i|_q(|S)N data_type) namespacesvaluesaliaseshasattrr r data_typesfieldsr ZroutesZ arg_data_typeZresult_data_typeZerror_data_typer Z alias_by_name)api namespacealiasZ curr_typerfieldZrouterdC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\stone/backend.pyremove_aliases_from_apis8                 rc@seZdZdZdZdZdZddZeddZ e d)d d Z d d Z d dZ ddZe d*ddZddZe ddZddZddZd+ddZ      d,dd Zd+d!d"Zd#d$Zd%d&Zed'd(ZdS)-Backendaa The parent class for all backends. All backends should extend this class to be recognized as such. You will want to implement the generate() function to do the generation that you need. Here's roughly what you need to do in generate(). 1. Use the context manager output_to_relative_path() to specify an output file. with output_to_relative_path('generated_code.py'): ... 2. Use the family of emit*() functions to write to the output file. The target_folder_path attribute is the path to the folder where all generated files should be created. FNcCstd|jj|_||_g|_d|_d|_g|_ i|_ d|_ |j rGt |j tjs0Jd|j z |j ||_ WdStyFtdwdS)z Args: target_folder_path (str): Path to the folder where all generated files should be created. z Backend<%s>rNz4expected cmdline_parser to be ArgumentParser, got %rzdNote: This is for backend-specific arguments which follow arguments to Stone after a "--" delimiter.)logging getLogger __class____name__loggertarget_folder_pathoutputlineno cur_indentpositional_placeholdersnamed_placeholdersargscmdline_parser isinstanceargparseArgumentParser parse_args SystemExitprint)selfr%r+rrr__init__gs. zBackend.__init__cCst)z Subclasses should override this method. It's the entry point that is invoked by the rest of the toolchain. Args: api (stone.api.Api): The API specification. )NotImplementedError)r3rrrrgenerates zBackend.generatewbccstj|j|}tj|}tj|s!|jd|t||jd|| dVt ||}| | dWdn1sIwY| dS)z Sets up backend so that all emits are directed towards the new file created at :param:`relative_path`. Clears the output buffer on enter and exit. z Creating %sz Generating %sNzutf-8)ospathjoinr%dirnameexistsr$infomakedirsclear_output_bufferopenwriteoutput_buffer_to_stringencode)r3Z relative_pathmode full_path directoryfrrroutput_to_relative_paths     zBackend.output_to_relative_pathcCsd|jj|ji|jS)z6Returns the contents of the output buffer as a string.)r:r&formatr)r*r3rrrrBs zBackend.output_buffer_to_stringcCsg|_g|_i|_dSN)r&r)r*rKrrrr?s zBackend.clear_output_buffercCs|jrdSdS)z@ Returns the size of a single indentation step. r)tabs_for_indentsrKrrr indent_stepzBackend.indent_stepccsP|dus |dks Jd|dur|}|j|7_dV|j|8_dS)a( For the duration of the context manager, indentation will be increased by dent. Dent is in units of spaces or tabs depending on the value of the class variable tabs_for_indents. If dent is None, indentation will increase by either four spaces or one tab. Nrzdent must be >= 0.)rOr()r3dentrrrindents zBackend.indentcCs|jrd|jSd|jS)z Returns a string representing the current indentation. Indents can be either spaces or tabs, depending on the value of the class variable tabs_for_indents.   )rNr(rKrrr make_indents  zBackend.make_indentccs0|j}g|_dV|d|j||_dS)NrI)r&rAr:)r3Z output_bufferZoriginal_outputrrrcapture_emitted_outputs  zBackend.capture_emitted_outputcCsV|j|d7_||ddddt|dkr'|ddkr)tdd Sd S) z Adds the input string to the output buffer. The string must end in a newline. It may contain any number of newline characters. No indentation is generated.  {z{{}z}}rz1Input string to emit_raw must end with a newline.N)r'count_append_outputreplacelenAssertionErrorr3srrremit_rawszBackend.emit_rawcCs|j|dSrL)r&appendr`rrrr\szBackend._append_outputrIcCsPt|tjs Jdd|vsJd|r!|d||fdS|ddS)z Adds indentation, then the input string, and lastly a newline to the output buffer. If s is an empty string (default) then an empty line is created with no indentation. zs must be a unicode stringrWz.String to emit cannot contain newline strings.z%s%s N)r-six text_typerbrUr`rrremits z Backend.emitPc Cs<|}||}|tj||||||||dddS)a Adds the input string to the output buffer with indentation and wrapping. The wrapping is performed by the :func:`textwrap.fill` Python library function. Args: s (str): The input string to wrap. prefix (str): The string to prepend to *every* line. initial_prefix (str): The string to prepend to the first line of the wrapped string. Note that the current indentation is already added to each line. subsequent_prefix (str): The string to prepend to every line after the first. Note that the current indentation is already added to each line. width (int): The target width of each line including indentation and text. break_long_words (bool): Break words longer than width. If false, those words will not be broken, and some lines might be longer than width. break_on_hyphens (bool): Allow breaking hyphenated words. If true, wrapping will occur preferably on whitespaces and right after hyphens part of compound words. )initial_indentsubsequent_indentwidthbreak_long_wordsbreak_on_hyphensrWN)rUrbtextwrapfill) r3raprefixZinitial_prefixZsubsequent_prefixrjrkrlrRrrremit_wrapped_texts"  zBackend.emit_wrapped_textcCs|d|dS)z_ Emits replacements fields that can be used to format the output string later. z{%s}N)r\r`rrremit_placeholder-szBackend.emit_placeholdercCs|j|dS)z] Format replacement fields corresponding to empty calls to emit_placeholder. N)r)rcr`rrradd_positional_placeholder4sz"Backend.add_positional_placeholdercCs||j|<dS)za Format replacement fields corresponding to non-empty calls to emit_placeholder. N)r*)r3namerarrradd_named_placeholder;rPzBackend.add_named_placeholderc Cst|tjsJdt|d}g}t|D]'}|\}}|||||}|d}|d} ||| } || q|||dd |S)a5 Helper for parsing documentation references in Stone docstrings and replacing them with more suitable annotations for the generated output. Args: doc (str): A Stone docstring. handler: A function with the following signature: `(tag: str, value: str) -> str`. It will be called for every reference found in the docstring with the tag and value parsed for you. The returned string will be substituted in the docstring in place of the reference. z)Expected string (unicode in PY2), got %r.rtagvalNrI) r-rdretyper finditerspanrcgroupr:) clsdochandlerZ cur_indexpartsmatchstartendrurvsubrrr process_docBs       zBackend.process_doc)r7rL)rI)rIrIrIrgFF)r# __module__ __qualname____doc__rNr,Zpreserve_aliasesr4rr6rrHrBr?rOrRrUrVrbr\rfrprqrrrt classmethodrrrrrrFsB      -rc@sFeZdZdZddZ      dd d Ze   dd dZd S) CodeBackendz Extend this instead of :class:`Backend` when generating source code. Contains helper functions specific to code generation. cCs*i}|D] \}}|dur|||<q|S)znGiven a dict, returns a new dict with all the same key/values except for keys that had values of None.N)items)r3dZnew_dkvrrrfilter_out_none_valued_keysks z'CodeBackend.filter_out_none_valued_keysrI()T,Fc stdkrtdtjrtdtjsJdt|dkr1|dddSt|dkrL|d|dddS|r|d|dfdd}|sldrt|td ||WddS1swYdS||dS|sdr|d(t|D]\} } | t|dkr|rˆ| q| qWdn1swYds߈rddSdrddSdS)a Given a list of items, emits one item per line. This is convenient for function prototypes and invocations, as well as for instantiating arrays, sets, and maps in some languages. TODO(kelkabany): A backend that uses tabs cannot be used with this if compact is false. Args: items (list[str]): Should contain the items to generate a list of. before (str): The string to come before the list of items. after (str): The string to follow the list of items. delim (str, str): The first element is added immediately following `before`. The second element is added prior to `after`. compact (bool): In compact mode, the enclosing parentheses are on the same lines as the first and last list item. sep (str): The string that follows each list item when compact is true. If compact is false, the separator is omitted for the last item. skip_last_sep (bool): When compact is false, whether the last line should have a trailing separator. Ignored when compact is true. rrz-delim must be a tuple of two unicode strings.NcsX|dd}t|D]\}}|t|dkr"|dq |q dS)Nr) enumerater^rf)riitemafterdelimr3seprr emit_lists z6CodeBackend.generate_multiline_list..emit_list)r^r-rdrerfrRr) r3rbeforerrcompactrZ skip_last_seprrrrrrgenerate_multiline_listusB"  &  "     z#CodeBackend.generate_multiline_listrXrYNccst|dks Jdt|dtjtdfr#t|dtjtdfs'Jd|rC|sC|ddur=|d||dn||n|rJ|||ddurW||d|| dVWdn1sjwY|ddur||d|dS||dS)a+ A context manager that emits configurable lines before and after an indented block of text. This is convenient for class and function definitions in some languages. Args: before (str): The string to be output in the first line which is not indented.. after (str): The string to be output in the last line which is not indented. delim (str, str): The first element is added immediately following `before` and a space. The second element is added prior to a space and then `after`. dent (int): The amount to indent the block. If none, the default indentation increment is used (four spaces or one tab). allman (bool): Indicates whether to use `Allman` style indentation, or the default `K&R` style. If there is no `before` string this is ignored. For more details about indent styles see http://en.wikipedia.org/wiki/Indent_style rz!delim must be a tuple of length 2rNrz.delim must be a tuple of two optional strings.z{} {})r^r-rdrerwrfrJrR)r3rrrrQZallmanrrrblocks*       zCodeBackend.block)rIrIrTrF)rIrIrNF)r#rrrrrrrrrrrrds"  Hr)# __future__rrrrabcrr contextlibrr.r r8rdrmZstone.frontend.ir_generatorr Zstone.irr r r Z_MYPYr typingTupleTextZ DelimTupleTypeVarrrr add_metaclassobjectrrrrrrs.     )