???<!-- GIF89;a -->
123123123123
.....................................................................................................................................???<!-- GIF89;a -->
123123123123
.....................................................................................................................................ž
¥ÿfÿz  c               @   sl  d  Z  d d g Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l	 Z	 d d l
 Z
 d d l Z d d l m Z y d d l m Z Wn" e k
 rÒ d d l m Z Yn Xy d d l Z Wn' e k
 re j Z d d	 „  Z Yn Xd
 d „  Z d d	 „  Z d d „  Z d Z e j d ƒ Z Gd d „  d ƒ Z d d „  Z d d „  Z Gd d „  d ƒ Z d d „  Z d d „  Z  d d d „ Z" d d „  Z# Gd  d „  d ƒ Z$ d! d" „  Z% d d# d$ „ Z& d% d& „  Z' Gd' d( „  d( e ƒ Z( d) d* „  Z) d+ d, „  Z* d- d. „  Z+ d/ d0 „  Z, d d1 d2 „ Z- d3 d4 „  Z. e/ d5 k rhe& ƒ  n  d S(6   u·  program/module to trace Python program or function execution

Sample use, command line:
  trace.py -c -f counts --ignore-dir '$prefix' spam.py eggs
  trace.py -t --ignore-dir '$prefix' spam.py eggs
  trace.py --trackcalls spam.py eggs

Sample use, programmatically
  import sys

  # create a Trace object, telling it what to ignore, and whether to
  # do tracing or line-counting or both.
  tracer = trace.Trace(ignoredirs=[sys.base_prefix, sys.base_exec_prefix,],
                       trace=0, count=1)
  # run the new command using the given tracer
  tracer.run('main()')
  # make a report, placing output in /tmp
  r = tracer.results()
  r.write_results(show_missing=True, coverdir="/tmp")
u   Traceu   CoverageResultsi    N(   u   warn(   u	   monotonic(   u   timec               C   s   t  j d  ƒ d  S(   N(   u   sysu   settraceu   None(    (    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _unsettraceH   s    u   _unsettracec             C   s   t  j |  ƒ t j |  ƒ d  S(   N(   u	   threadingu   settraceu   sys(   u   func(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu	   _settraceK   s    u	   _settracec               C   s   t  j d  ƒ t j d  ƒ d  S(   N(   u   sysu   settraceu   Noneu	   threading(    (    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _unsettraceO   s    c             C   s   |  j  d t j d ƒ d  S(   Nu	  Usage: %s [OPTIONS] <file> [ARGS]

Meta-options:
--help                Display this help then exit.
--version             Output version information then exit.

Otherwise, exactly one of the following three options must be given:
-t, --trace           Print each line to sys.stdout before it is executed.
-c, --count           Count the number of times each line is executed
                      and write the counts to <module>.cover for each
                      module executed, in the module's directory.
                      See also `--coverdir', `--file', `--no-report' below.
-l, --listfuncs       Keep track of which functions are executed at least
                      once and write the results to sys.stdout after the
                      program exits.
-T, --trackcalls      Keep track of caller/called pairs and write the
                      results to sys.stdout after the program exits.
-r, --report          Generate a report from a counts file; do not execute
                      any code.  `--file' must specify the results file to
                      read, which must have been created in a previous run
                      with `--count --file=FILE'.

Modifiers:
-f, --file=<file>     File to accumulate counts over several runs.
-R, --no-report       Do not generate the coverage report files.
                      Useful if you want to accumulate over several runs.
-C, --coverdir=<dir>  Directory where the report files.  The coverage
                      report for <package>.<module> is written to file
                      <dir>/<package>/<module>.cover.
-m, --missing         Annotate executable lines that were not executed
                      with '>>>>>> '.
-s, --summary         Write a brief summary on stdout for each file.
                      (Can only be used with --count or --report.)
-g, --timing          Prefix each line with the time since the program started.
                      Only used while tracing.

Filters, may be repeated multiple times:
--ignore-module=<mod> Ignore the given module(s) and its submodules
                      (if it is a package).  Accepts comma separated
                      list of module names
--ignore-dir=<dir>    Ignore files in the given directory (multiple
                      directories can be joined by os.pathsep).
i    (   u   writeu   sysu   argv(   u   outfile(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _usageS   s    *u   _usageu   #pragma NO COVERu   ^\s*(#.*)?$c             B   s2   |  Ee  Z d  Z d d d d „ Z d d „  Z d S(   u   _Ignorec             C   sT   | s t  ƒ  n	 t  | ƒ |  _ | s* g  n d d „  | Dƒ |  _ i d d 6|  _ d  S(   Nc             S   s"   g  |  ] } t  j j | ƒ ‘ q S(    (   u   osu   pathu   normpath(   u   .0u   d(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu
   <listcomp>ˆ   s   	u$   _Ignore.__init__.<locals>.<listcomp>i   u   <string>(   u   setu   _modsu   _dirsu   _ignore(   u   selfu   modulesu   dirs(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   __init__†   s    u   _Ignore.__init__c             C   sÛ   | |  j  k r |  j  | S| |  j k r: d |  j  | <d Sx5 |  j D]* } | j | d ƒ rD d |  j  | <d SqD W| d  k r d |  j  | <d Sx8 |  j D]- } | j | t j ƒ r™ d |  j  | <d Sq™ Wd |  j  | <d S(   Ni   u   .i    (   u   _ignoreu   _modsu
   startswithu   Noneu   _dirsu   osu   sep(   u   selfu   filenameu
   modulenameu   modu   d(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   namesŒ   s$    u   _Ignore.namesN(   u   __name__u
   __module__u   __qualname__u   Noneu   __init__u   names(   u
   __locals__(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _Ignore…   s   u   _Ignorec             C   s.   t  j j |  ƒ } t  j j | ƒ \ } } | S(   u-   Return a plausible module name for the patch.(   u   osu   pathu   basenameu   splitext(   u   pathu   baseu   filenameu   ext(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _modname·   s    u   _modnamec             C   s&  t  j j |  ƒ } d } xo t j D]d } t  j j | ƒ } | j | ƒ r" | t | ƒ t  j k r" t | ƒ t | ƒ k r† | } q† q" q" W| r­ |  t | ƒ d d … } n |  } t  j j | ƒ \ } } | j t  j d ƒ } t  j	 r| j t  j	 d ƒ } n  t  j j
 | ƒ \ } } | j d ƒ S(   u,   Return a plausible module name for the path.u    i   Nu   .(   u   osu   pathu   normcaseu   sysu
   startswithu   lenu   sepu
   splitdriveu   replaceu   altsepu   splitextu   lstrip(   u   pathu   comparepathu   longestu   diru   baseu   driveu   filenameu   ext(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _fullmodname¾   s     (	u   _fullmodnamec             B   sk   |  Ee  Z d  Z d d d d d d d „ Z d d „  Z d d „  Z d d d d d „ Z	 d d	 d
 „ Z
 d S(   u   CoverageResultsc             C   sY  | |  _  |  j  d  k r$ i  |  _  n  |  j  j ƒ  |  _ | |  _ |  j d  k rZ i  |  _ n  |  j j ƒ  |  _ | |  _ |  j d  k r i  |  _ n  |  j j ƒ  |  _ | |  _ | |  _ |  j rUyD t j	 t
 |  j d ƒ ƒ \ } } } |  j |  j | | | ƒ ƒ WqUt t t f k
 rQ} z% t d |  j | f d t j ƒWYd  d  } ~ XqUXn  d  S(   Nu   rbu   Skipping counts file %r: %su   file(   u   countsu   Noneu   copyu   counteru   calledfuncsu   callersu   infileu   outfileu   pickleu   loadu   openu   updateu	   __class__u   IOErroru   EOFErroru
   ValueErroru   printu   sysu   stderr(   u   selfu   countsu   calledfuncsu   infileu   callersu   outfileu   err(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   __init__Û   s*    						$ u   CoverageResults.__init__c             C   s   | j  d ƒ o | j d ƒ S(   u_   Return True if the filename does not refer to a file
        we want to have reported.
        u   <u   >(   u
   startswithu   endswith(   u   selfu   filename(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   is_ignored_filenameõ   s    u#   CoverageResults.is_ignored_filenamec       	      C   sŸ   |  j  } |  j } |  j } | j  } | j } | j } x, | D]$ } | j | d ƒ | | | | <q= Wx | D] } d | | <ql Wx | D] } d | | <q‡ Wd S(   u.   Merge in the data from another CoverageResultsi    i   N(   u   countsu   calledfuncsu   callersu   get(	   u   selfu   otheru   countsu   calledfuncsu   callersu   other_countsu   other_calledfuncsu   other_callersu   key(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   updateû   s    						"u   CoverageResults.updatec       !      C   sñ  |  j  r] t ƒ  t d ƒ |  j  } x7 t | ƒ D]& \ } } } t d | | | f ƒ q0 Wn  |  j r0t ƒ  t d ƒ d } }	 x¬ t |  j ƒ D]˜ \ \ }
 } } \ } } } |
 | k rá t ƒ  t d |
 d ƒ |
 } d }	 n  | |
 k r|	 | k rt d | ƒ | }	 n  t d | | | | f ƒ q‘ Wn  i  } xH |  j D]= \ } } | j | i  ƒ } | | <|  j | | f | | <q@Wi  } x‹| j ƒ  D]}\ } } |  j | ƒ rµq”n  | j d ƒ r×| d
 d … } n  | d
 k rt
 j j t
 j j | ƒ ƒ } t | ƒ } n4 | } t
 j j | ƒ s8t
 j | ƒ n  t | ƒ } | rYt | ƒ } n i  } t j | ƒ } t
 j j | | d ƒ } t | d ƒ  } t j | j ƒ \ } } Wd
 QX|  j | | | | | ƒ \ } } | r”| r”t d | | ƒ } | | | | f | | <q”q”W| rm| rmt d ƒ x? t | ƒ D]. } | | \ } } } } t d | | ƒ q8Wn  |  j ríy5 t j |  j |  j  |  j f t |  j d ƒ d ƒ Wqít k
 ré}  z t d |  d t  j! ƒWYd
 d
 }  ~  XqíXn  d
 S(   u!   
        @param coverdir
        u   functions called:u*   filename: %s, modulename: %s, funcname: %su   calling relationships:u    u   ***u     -->u       %s.%s -> %s.%su   .pycu   .pyoNi   u   .coveru   rbid   u   lines   cov%   module   (path)u   %5d   %3d%%   %s   (%s)u   wbu"   Can't save counts files because %su   file(   u   .pycu   .pyoiÿÿÿÿ("   u   calledfuncsu   printu   sortedu   callersu   countsu   getu   itemsu   is_ignored_filenameu   endswithu   Noneu   osu   pathu   dirnameu   abspathu   _modnameu   existsu   makedirsu   _fullmodnameu   _find_executable_linenosu	   linecacheu   getlinesu   joinu   openu   tokenizeu   detect_encodingu   readlineu   write_results_fileu   intu   outfileu   pickleu   dumpu   IOErroru   sysu   stderr(!   u   selfu   show_missingu   summaryu   coverdiru   callsu   filenameu
   modulenameu   funcnameu   lastfileu	   lastcfileu   pfileu   pmodu   pfuncu   cfileu   cmodu   cfuncu   per_fileu   linenou	   lines_hitu   sumsu   countu   diru   lnotabu   sourceu	   coverpathu   fpu   encodingu   _u   n_hitsu   n_linesu   percentu   mu   err(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   write_results  s|    	
		

+		!
	u   CoverageResults.write_resultsc             C   sN  y t  | d d | ƒ} WnF t k
 ra } z& t d | | f d t j ƒd SWYd d } ~ Xn Xd } d }	 xÉ t | d ƒ D]¸ \ }
 } |
 | k rÂ | j d | |
 ƒ |	 d 7}	 | d 7} n^ t j | ƒ rá | j d	 ƒ n? |
 | k rt	 | k r| j d
 ƒ | d 7} n | j d	 ƒ | j | j
 d ƒ ƒ q~ W| j ƒ  |	 | f S(   u'   Return a coverage results file in path.u   wu   encodingu2   trace: Could not open %r for writing: %s- skippingu   filei    Ni   u   %5d: u          u   >>>>>> i   (   i    i    (   u   openu   IOErroru   printu   sysu   stderru	   enumerateu   writeu   rx_blanku   matchu   PRAGMA_NOCOVERu
   expandtabsu   close(   u   selfu   pathu   linesu   lnotabu	   lines_hitu   encodingu   outfileu   erru   n_linesu   n_hitsu   linenou   line(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   write_results_fileb  s,    

u"   CoverageResults.write_results_fileNTF(   u   __name__u
   __module__u   __qualname__u   Noneu   __init__u   is_ignored_filenameu   updateu   Trueu   Falseu   write_resultsu   write_results_file(   u
   __locals__(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   CoverageResultsÚ   s   	Uc             C   sC   i  } x6 t  j |  ƒ D]% \ } } | | k r d | | <q q W| S(   u:   Return dict where keys are lines in the line number table.i   (   u   disu   findlinestarts(   u   codeu   strsu   linenosu   _u   lineno(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _find_lines_from_code…  s
    u   _find_lines_from_codec             C   sO   t  |  | ƒ } x9 |  j D]. } t j | ƒ r | j t | | ƒ ƒ q q W| S(   u<   Return lineno dict for all code objects reachable from code.(   u   _find_lines_from_codeu	   co_constsu   inspectu   iscodeu   updateu   _find_lines(   u   codeu   strsu   linenosu   c(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _find_lines  s
    u   _find_linesc             C   sÊ   i  } t  j } t |  d | ƒ£ } t j | j ƒ } x‡ | D] \ } } } }	 }
 | t  j k r¶ | t  j k r¶ | \ } } |	 \ } } x( t | | d ƒ D] } d | | <qœ Wq¶ n  | } q= WWd QX| S(   uÄ   Return a dict of possible docstring positions.

    The dict maps line numbers to strings.  There is an entry for
    line that contains only a string or a part of a triple-quoted
    string.
    u   encodingi   N(   u   tokenu   INDENTu   openu   tokenizeu   generate_tokensu   readlineu   STRINGu   range(   u   filenameu   encodingu   du
   prev_ttypeu   fu   toku   ttypeu   tstru   startu   endu   lineu   slineu   scolu   elineu   ecolu   i(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _find_strings›  s    	u   _find_stringsc             C   s¨   y1 t  j |  ƒ  } | j ƒ  } | j } Wd QXWnF t k
 ry } z& t d |  | f d t j ƒi  SWYd d } ~ Xn Xt | |  d ƒ } t	 |  | ƒ } t
 | | ƒ S(   uA   Return dict where keys are line numbers in the line number table.Nu%   Not printing coverage data for %r: %su   fileu   exec(   u   tokenizeu   openu   readu   encodingu   IOErroru   printu   sysu   stderru   compileu   _find_stringsu   _find_lines(   u   filenameu   fu   progu   encodingu   erru   codeu   strs(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   _find_executable_linenos²  s    u   _find_executable_linenosc             B   sÅ   |  Ee  Z d  Z d d d d f  f  d d d d d „	 Z d d „  Z d d d d „ Z d	 d
 „  Z d d „  Z	 d d „  Z
 d d „  Z d d „  Z d d „  Z d d „  Z d d „  Z d d „  Z d S(   u   Tracei   i    c
       
      C   s!  | |  _  | |  _ t | | ƒ |  _ i  |  _ i  |  _ d |  _ | |  _ i  |  _ i  |  _	 i  |  _
 d |  _ |	 r t ƒ  |  _ n  | r– |  j |  _ n‡ | r« |  j |  _ nr | rÒ | rÒ |  j |  _ |  j |  _ nK | ró |  j |  _ |  j |  _ n* | r|  j |  _ |  j |  _ n	 d |  _ d S(   ux  
        @param count true iff it should count number of times each
                     line is executed
        @param trace true iff it should print out each line that is
                     being counted
        @param countfuncs true iff it should just output a list of
                     (filename, modulename, funcname,) for functions
                     that were called at least once;  This overrides
                     `count' and `trace'
        @param ignoremods a list of the names of modules to ignore
        @param ignoredirs a list of the names of directories to ignore
                     all of the (recursive) contents of
        @param infile file from which to read stored counts to be
                     added into the results
        @param outfile file in which to write the results
        @param timing true iff timing information be displayed
        i    i   N(   u   infileu   outfileu   _Ignoreu   ignoreu   countsu   pathtobasenameu	   donothingu   traceu   _calledfuncsu   _callersu   _caller_cacheu   Noneu
   start_timeu   _timeu   globaltrace_trackcallersu   globaltraceu   globaltrace_countfuncsu   globaltrace_ltu   localtrace_trace_and_countu
   localtraceu   localtrace_traceu   localtrace_count(
   u   selfu   countu   traceu
   countfuncsu   countcallersu
   ignoremodsu
   ignoredirsu   infileu   outfileu   timing(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   __init__Á  s6    										u   Trace.__init__c             C   s,   d d  l  } | j } |  j | | | ƒ d  S(   Ni    (   u   __main__u   __dict__u   runctx(   u   selfu   cmdu   __main__u   dict(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   runó  s    	u	   Trace.runc          
   C   sr   | d  k r i  } n  | d  k r* i  } n  |  j sC t |  j ƒ n  z t | | | ƒ Wd  |  j sm t ƒ  n  Xd  S(   N(   u   Noneu	   donothingu	   _settraceu   globaltraceu   execu   _unsettrace(   u   selfu   cmdu   globalsu   locals(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   runctxø  s     	 			u   Trace.runctxc             O   sV   d  } |  j s" t j |  j ƒ n  z | | | Ž  } Wd  |  j sQ t j d  ƒ n  X| S(   N(   u   Noneu	   donothingu   sysu   settraceu   globaltrace(   u   selfu   funcu   argsu   kwu   result(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   runfunc  s    		u   Trace.runfuncc       
      C   s_  | j  } | j } | r' t | ƒ } n d  } | j } d  } | |  j k rq |  j | d  k	 r3|  j | } q3nÂ d  |  j | <d d „  t j | ƒ Dƒ } t | ƒ d k r3d d „  t j | d ƒ Dƒ } t | ƒ d k r3d d „  t j | d ƒ Dƒ }	 t |	 ƒ d k r0|	 d j	 } | |  j | <q0q3n  | d  k	 rRd | | f } n  | | | f S(   Nc             S   s%   g  |  ] } t  j | ƒ r | ‘ q S(    (   u   inspectu
   isfunction(   u   .0u   f(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu
   <listcomp>  s   	 u1   Trace.file_module_function_of.<locals>.<listcomp>i   c             S   s%   g  |  ] } t  | t ƒ r | ‘ q S(    (   u
   isinstanceu   dict(   u   .0u   d(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu
   <listcomp>%  s   	 i    c             S   s%   g  |  ] } t  | d  ƒ r | ‘ q S(   u	   __bases__(   u   hasattr(   u   .0u   c(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu
   <listcomp>(  s   	 u   %s.%s(
   u   f_codeu   co_filenameu   _modnameu   Noneu   co_nameu   _caller_cacheu   gcu   get_referrersu   lenu   __name__(
   u   selfu   frameu   codeu   filenameu
   modulenameu   funcnameu   clsnameu   funcsu   dictsu   classes(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   file_module_function_of  s,    			  u   Trace.file_module_function_ofc             C   sG   | d k rC |  j  | ƒ } |  j  | j ƒ } d |  j | | f <n  d S(   uk   Handler for call events.

        Adds information about who called who to the self._callers dict.
        u   calli   N(   u   file_module_function_ofu   f_backu   _callers(   u   selfu   frameu   whyu   argu	   this_funcu   parent_func(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   globaltrace_trackcallers7  s    u   Trace.globaltrace_trackcallersc             C   s/   | d k r+ |  j  | ƒ } d |  j | <n  d S(   uo   Handler for call events.

        Adds (filename, modulename, funcname) to the self._calledfuncs dict.
        u   calli   N(   u   file_module_function_ofu   _calledfuncs(   u   selfu   frameu   whyu   argu	   this_func(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   globaltrace_countfuncsB  s    u   Trace.globaltrace_countfuncsc             C   sž   | d k rš | j  } | j j d d ƒ } | r“ t | ƒ } | d k	 r— |  j j | | ƒ } | s |  j r† t d | | j	 f ƒ n  |  j
 Sq— qš d Sn  d S(   u’   Handler for call events.

        If the code block being entered is to be ignored, returns `None',
        else returns self.localtrace.
        u   callu   __file__u!    --- modulename: %s, funcname: %sN(   u   f_codeu	   f_globalsu   getu   Noneu   _modnameu   ignoreu   namesu   traceu   printu   co_nameu
   localtrace(   u   selfu   frameu   whyu   argu   codeu   filenameu
   modulenameu	   ignore_it(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   globaltrace_ltK  s    		u   Trace.globaltrace_ltc             C   s¼   | d k rµ | j  j } | j } | | f } |  j j | d ƒ d |  j | <|  j rw t d t ƒ  |  j d d ƒn  t j	 j
 | ƒ } t d | | t j | | ƒ f d d ƒn  |  j S(	   Nu   linei    i   u   %.2fu   endu    u
   %s(%d): %su    (   u   f_codeu   co_filenameu   f_linenou   countsu   getu
   start_timeu   printu   _timeu   osu   pathu   basenameu	   linecacheu   getlineu
   localtrace(   u   selfu   frameu   whyu   argu   filenameu   linenou   keyu   bname(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   localtrace_trace_and_countb  s    	 	! u    Trace.localtrace_trace_and_countc             C   s   | d k r‰ | j  j } | j } |  j rK t d t ƒ  |  j d d ƒn  t j j | ƒ } t d | | t	 j
 | | ƒ f d d ƒn  |  j S(   Nu   lineu   %.2fu   endu    u
   %s(%d): %su    (   u   f_codeu   co_filenameu   f_linenou
   start_timeu   printu   _timeu   osu   pathu   basenameu	   linecacheu   getlineu
   localtrace(   u   selfu   frameu   whyu   argu   filenameu   linenou   bname(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   localtrace_traceq  s    		! u   Trace.localtrace_tracec             C   sW   | d k rP | j  j } | j } | | f } |  j j | d ƒ d |  j | <n  |  j S(   Nu   linei    i   (   u   f_codeu   co_filenameu   f_linenou   countsu   getu
   localtrace(   u   selfu   frameu   whyu   argu   filenameu   linenou   key(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   localtrace_count~  s    	#u   Trace.localtrace_countc          
   C   s1   t  |  j d |  j d |  j d |  j d |  j ƒS(   Nu   infileu   outfileu   calledfuncsu   callers(   u   CoverageResultsu   countsu   infileu   outfileu   _calledfuncsu   _callers(   u   self(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   results†  s    		u   Trace.resultsNF(   u   __name__u
   __module__u   __qualname__u   Noneu   Falseu   __init__u   runu   runctxu   runfuncu   file_module_function_ofu   globaltrace_trackcallersu   globaltrace_countfuncsu   globaltrace_ltu   localtrace_trace_and_countu   localtrace_traceu   localtrace_countu   results(   u
   __locals__(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   TraceÀ  s   0)	c             C   s2   t  j j d t  j d |  f ƒ t  j d ƒ d  S(   Nu   %s: %s
i    i   (   u   sysu   stderru   writeu   argvu   exit(   u   msg(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu	   _err_exitŒ  s    !u	   _err_exitc          +   C   sq  d d  l  } |  d  k r$ t j }  n  yV | j  |  d d  … d d d d d d d	 d
 d d d d d d d d g ƒ \ } } Wnq | j k
 rí } zN t j j d t j d | f ƒ t j j d t j d ƒ t j d ƒ WYd  d  } ~ Xn Xd } d } d } d } d  }	 d }
 g  } g  } d  } d } dI } dI } dI } x| D]ü\ } } | d k rxt	 t j
 ƒ t j d ƒ n  | d k r¤t j
 j d ƒ t j d ƒ n  | d k s¼| d k rÈdJ } qCn  | d k sà| d k rìdJ } qCn  | d k s| d k rdJ } qCn  | d k s(| d k r4d } qCn  | d  k sL| d! k rXd } qCn  | d" k sp| d# k r|d } qCn  | d$ k s”| d% k r d } qCn  | d& k s¸| d' k rÄ| }	 qCn  | d( k sÜ| d) k rèd }
 qCn  | d* k s | d+ k r| } qCn  | d, k s$| d- k r0d } qCn  | d. k rox* | j d/ ƒ D] } | j | j ƒ  ƒ qLWqCn  | d0 k rCx» | j t j ƒ D]§ } t j j | ƒ } | j d1 t j j t j d2 d3 t j d  d4 … ƒ ƒ } | j d5 t j j t j d2 d3 t j d  d4 … ƒ ƒ } t j j | ƒ } | j | ƒ qŽWqCqCqCW| rb| sU| rbt d6 ƒ n  | p}| p}| p}| p}| st d7 ƒ n  | r¦| r¦t d8 ƒ n  | rÀ|	 rÀt d9 ƒ n  | råt | ƒ d k råt d: ƒ n  | rt d; |	 d< |	 ƒ } | j |
 d
 | d= | ƒnQ| t _ | d } t j j | ƒ d t j d <t | | d> | d? | d@ | dA | d; |	 d< |	 d | ƒ} yf t | ƒ  } t | j  ƒ  | dB ƒ } Wd  QXi | dC 6dD dE 6d  dF 6d  dG 6} | j! | | | ƒ WnQ t" k
 r-} z  t dH t j d | f ƒ WYd  d  } ~ Xn t# k
 r>Yn X| j$ ƒ  } | sm| j |
 d
 | d= | ƒn  d  S(K   Ni    i   u   tcrRf:d:msC:lTgu   helpu   versionu   traceu   countu   reportu	   no-reportu   summaryu   file=u   missingu   ignore-module=u   ignore-dir=u	   coverdir=u	   listfuncsu
   trackcallsu   timingu   %s: %s
u%   Try `%s --help' for more information
u   --helpu	   --versionu
   trace 2.0
u   -Tu   --trackcallsu   -lu   --listfuncsu   -gu   --timingu   -tu   --traceu   -cu   --countu   -ru   --reportu   -Ru   --no-reportu   -fu   --fileu   -mu	   --missingu   -Cu
   --coverdiru   -su	   --summaryu   --ignore-moduleu   ,u   --ignore-diru   $prefixu   libu   pythoni   u   $exec_prefixu8   cannot specify both --listfuncs and (--trace or --count)uL   must specify one of --trace, --count, --report, --listfuncs, or --trackcallsu,   cannot specify both --report and --no-reportu   --report requires a --fileu   missing name of file to runu   infileu   outfileu   coverdiru
   countfuncsu   countcallersu
   ignoremodsu
   ignoredirsu   execu   __file__u   __main__u   __name__u   __package__u
   __cached__u   Cannot run file %r because: %sFT(%   u   getoptu   Noneu   sysu   argvu   erroru   stderru   writeu   exitu   Falseu   _usageu   stdoutu   Trueu   splitu   appendu   stripu   osu   pathsepu   pathu
   expandvarsu   replaceu   joinu   base_prefixu   versionu   base_exec_prefixu   normpathu	   _err_exitu   lenu   CoverageResultsu   write_resultsu   Traceu   openu   compileu   readu   runctxu   IOErroru
   SystemExitu   results(   u   argvu   getoptu   optsu	   prog_argvu   msgu   traceu   countu   reportu	   no_reportu   counts_fileu   missingu   ignore_modulesu   ignore_dirsu   coverdiru   summaryu	   listfuncsu   countcallersu   timingu   optu   valu   modu   su   resultsu   prognameu   tu   fpu   codeu   globsu   err(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   main  sô    	! 			

-u   mainc             C   s   t  d t d ƒ t |  ƒ d  S(   Nu(   The trace.usage() function is deprecatedi   (   u   _warnu   DeprecationWarningu   _usage(   u   outfile(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   usage0  s    
u   usagec             B   s&   |  Ee  Z d  Z d d d d „ Z d S(   u   Ignorec             C   s'   t  d t d ƒ t j |  | | ƒ d  S(   Nu$   The class trace.Ignore is deprecatedi   (   u   _warnu   DeprecationWarningu   _Ignoreu   __init__(   u   selfu   modulesu   dirs(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   __init__6  s    
u   Ignore.__init__N(   u   __name__u
   __module__u   __qualname__u   Noneu   __init__(   u
   __locals__(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   Ignore5  s   u   Ignorec             C   s   t  d t d ƒ t |  ƒ S(   Nu*   The trace.modname() function is deprecatedi   (   u   _warnu   DeprecationWarningu   _modname(   u   path(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   modname;  s    
u   modnamec             C   s   t  d t d ƒ t |  ƒ S(   Nu.   The trace.fullmodname() function is deprecatedi   (   u   _warnu   DeprecationWarningu   _fullmodname(   u   path(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   fullmodname@  s    
u   fullmodnamec             C   s   t  d t d ƒ t |  | ƒ S(   Nu7   The trace.find_lines_from_code() function is deprecatedi   (   u   _warnu   DeprecationWarningu   _find_lines_from_code(   u   codeu   strs(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   find_lines_from_codeE  s    
u   find_lines_from_codec             C   s   t  d t d ƒ t |  | ƒ S(   Nu-   The trace.find_lines() function is deprecatedi   (   u   _warnu   DeprecationWarningu   _find_lines(   u   codeu   strs(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu
   find_linesJ  s    
u
   find_linesc             C   s    t  d t d ƒ t |  d d  ƒS(   Nu/   The trace.find_strings() function is deprecatedi   u   encoding(   u   _warnu   DeprecationWarningu   _find_stringsu   None(   u   filenameu   encoding(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   find_stringsO  s    
u   find_stringsc             C   s   t  d t d ƒ t |  ƒ S(   Nu:   The trace.find_executable_linenos() function is deprecatedi   (   u   _warnu   DeprecationWarningu   _find_executable_linenos(   u   filename(    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   find_executable_linenosT  s    
u   find_executable_linenosu   __main__(0   u   __doc__u   __all__u	   linecacheu   osu   reu   sysu   tokenu   tokenizeu   inspectu   gcu   disu   pickleu   warningsu   warnu   _warnu   timeu	   monotonicu   _timeu   ImportErroru	   threadingu   settraceu	   _settraceu   _unsettraceu   _usageu   PRAGMA_NOCOVERu   compileu   rx_blanku   _Ignoreu   _modnameu   _fullmodnameu   CoverageResultsu   _find_lines_from_codeu   _find_linesu   Noneu   _find_stringsu   _find_executable_linenosu   Traceu	   _err_exitu   mainu   usageu   Ignoreu   modnameu   fullmodnameu   find_lines_from_codeu
   find_linesu   find_stringsu   find_executable_linenosu   __name__(    (    (    u*   /opt/alt/python33/lib64/python3.3/trace.pyu   <module>1   s^   	-2«
Ì 