Genera una cadena dado un formato y un diccionario de claves/valores
766242
def escribir(dic, formato, contraer_fechas=False):
    ""
    linea = " " * sum([fmt[1] for fmt in formato])
    comienzo = 1
    for fmt in formato:
        clave, longitud, tipo = fmt[0:3]
        try:
            dec = (len(fmt)>3 and isinstance(fmt[3], int)) and fmt[3] or 2
            if clave.capitalize() in dic:
                clave = clave.capitalize()
            s = dic.get(clave,"")
            if isinstance(s, unicode):
                s = s.encode("latin1")
            if s is None:
                valor = ""
            else:
                valor = str(s)
            # reemplazo saltos de linea por tabulaci{on vertical
            valor = valor.replace("\n\r", "\v").replace("\n", "\v").replace("\r", "\v")
            if tipo == N and valor and valor!="NULL":
                valor = ("%%0%dd" % longitud) % long(valor)
            elif tipo == I and valor:
                valor = ("%%0%d.%df" % (longitud+1, dec) % float(valor)).replace(".", "")
            elif contraer_fechas and clave.lower().startswith("fec") and longitud <= 8 and valor:
                valor = valor.replace("-", "")
            else:
                valor = ("%%-0%ds" % longitud) % valor
            linea = linea[:comienzo-1] + valor + linea[comienzo-1+longitud:]
            comienzo += longitud
        except Exception, e:
            warnings.warn("Error al escribir campo %s pos %s val '%s': %s" % (
                clave, comienzo, valor, str(e)))
    return linea + "\n"
464878
def CargarFormatoPDF(self, archivo="liquidacion_form_c1116b_wslpg.csv"):
        ""

        # si no encuentro archivo, lo busco en el directorio predeterminado:
        if not os.path.exists(archivo):
            archivo = os.path.join(self.InstallDir, "plantillas", os.path.basename(archivo))

        if DEBUG: print "abriendo archivo ", archivo
        # inicializo la lista de los elementos:
        self.elements = []
        for lno, linea in enumerate(open(archivo.encode('latin1')).readlines()):
            if DEBUG: print "procesando linea ", lno, linea
            args = []
            for i,v in enumerate(linea.split(";")):
                if not v.startswith("'"): 
                    v = v.replace(",",".")
                else:
                    v = v#.decode('latin1')
                if v.strip()=='':
                    v = None
                else:
                    v = eval(v.strip())
                args.append(v)

            # corrijo path relativo para las imágenes:
            if args[1] == 'I':
                if not os.path.exists(args[14]):
                    args[14] = os.path.join(self.InstallDir, "plantillas", os.path.basename(args[14]))
                if DEBUG: print "NUEVO PATH:", args[14]          

            self.AgregarCampoPDF(*args)

        self.AgregarCampoPDF("anulado", 'T', 150, 250, 0, 0, 
              size=70, rotate=45, foreground=0x808080, 
              priority=-1)

        if HOMO:
            self.AgregarCampoPDF("homo", 'T', 100, 250, 0, 0,
                              size=70, rotate=45, foreground=0x808080, 
                              priority=-1)

        
        # cargo los elementos en la plantilla
        self.template.load_elements(self.elements)
        
        return True
646706
def LeerDatosLiquidacion(self, pop=True):
        ""
        
        if self.DatosLiquidacion:
            # extraigo el primer item
            if pop:
                datos_liq = self.DatosLiquidacion.pop(0)
            else:
                datos_liq = self.DatosLiquidacion[0]
            self.COE = str(datos_liq['coe'])
            self.Estado = unicode(datos_liq.get('estado', ""))
            return self.COE
        else:
            return ""
535984
def ConsultarCondicionesVenta(self, sep="||"):
        ""
        ret = self.client.consultarCondicionesVenta(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('condicionVenta', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
249909
public function getTextFormat()
    {
        $args = func_get_args();
        if (count($args) == 2) {
            $pageNumber = $args[0];
            $fragmentNumber = $args[1];
        }
        if (count($args) == 3) {
            $pageNumber = $args[0];
            $fragmentNumber = $args[1];
            $segamentNumber = $args[2];
        }
        $strURI = Product::$baseProductUri . '/pdf/' . $this->getFileName() . '/pages/' . $pageNumber .
            '/fragments/' . $fragmentNumber;
        if (isset($segamentNumber)) {
            $strURI .= '/segments/' . '/textformat';
        } else {
            $strURI .= '/textformat';
        }
        $signedURI = Utils::sign($strURI);

        $responseStream = Utils::processCommand($signedURI, 'GET', '', '');

        $json = json_decode($responseStream);

        return $json->TextFormat;
    }
1297288
def ConsultarTributos(self, sep="||"):
        ""
        ret = self.client.consultarTributos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('tributo', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
891254
def ConsultarTipoDeduccion(self, sep="||"):
        ""
        ret = self.client.tipoDeduccionConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoDeduccionReturn']
        self.__analizar_errores(ret)
        array = ret.get('tiposDeduccion', [])
        return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
1177548
def dar_nombre_campo_dbf(clave, claves):
    ""
    # achico el nombre del campo para que quepa en la tabla:
    nombre = clave.replace("_","")[:10]
    # si el campo esta repetido, le agrego un número
    i = 0
    while nombre in claves:
        i += 1    
        nombre = nombre[:9] + str(i)
    return nombre.lower()
164101
def to_s
			string = ""
			string << @autor << " (" << Date::MONTHNAMES[get_publicacion.month] << " " << get_publicacion.day.to_s << ", " << get_publicacion.year.to_s << "). " << @titulo << @formato << ". " << @editorial << ": " << @edicion << ". Disponible en: " << @url << " (" << Date::MONTHNAMES[get_fechacceso.month] << " " << get_fechacceso.day.to_s << ", " << get_fechacceso.year.to_s << "). "
		end
1120274
def ConsultarCTGRechazados(self):
        ""
        ret = self.client.consultarCTGRechazados(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                            ))['response']
        self.__analizar_errores(ret)
        datos = ret.get('arrayConsultarCTGRechazados')
        if datos:
            self.DatosCTG = datos
            self.LeerDatosCTG(pop=False)
            return True
        else:
            self.DatosCTG = []
        return False
490642
public function escribirCerrar()
    {
        if (!$this->iniciado) {
            throw new \RuntimeException('La sesión no fue iniciada previamente.');
        }

        if (!$this->adaptador->escribir($this->id, $this->datos)) {
            throw new \RuntimeException('Hubo un error escribiendo la sesión.');
        }

        $this->adaptador->cerrar();
        $this->iniciado = false;

        return true;
    }
1362234
public static function crearDesdeGlobales()
    {
        // Preparamos Metodo
        if (isset($_SERVER['REQUEST_METHOD'])) {
            $metodo = $_SERVER['REQUEST_METHOD'];
        } else {
            $metodo = 'GET';
        }

        // Preparamos URL
        $url = '';
        if (!empty($_SERVER['HTTPS'])) {
            if ($_SERVER['HTTPS'] !== 'off') {
                $url .= 'https';
            } else {
                $url .= 'http';
            }
        } else {
            if ($_SERVER['SERVER_PORT'] == 443) {
                $url .= 'https';
            } else {
                $url .= 'http';
            }
        }
        $url .= '://';
        if (isset($_SERVER['HTTP_HOST'])) {
            $url .= $_SERVER['HTTP_HOST'];
        } else {
            $url .= $_SERVER['SERVER_NAME'] . ':' . $_SERVER['SERVER_PORT'];
        }
        $url .= $_SERVER['REQUEST_URI'];

        // Preparamos cabeceras
        $cabeceras = [];
        foreach ($_SERVER as $nombre => $valor) {
            if (substr($nombre, 0, 5) == 'HTTP_') {
                $nombre = str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($nombre, 5)))));
                $cabeceras[$nombre] = $valor;
            } else if ($nombre == 'CONTENT_MD5') {
                $cabeceras['Content-Md5'] = $valor;
            } else if ($nombre == 'CONTENT_TYPE') {
                $cabeceras['Content-Type'] = $valor;
            } else if ($nombre == 'CONTENT_LENGTH') {
                $cabeceras['Content-Length'] = $valor;
            }
        }
        if (!isset($cabeceras['Authorization'])) {
            if (isset($_SERVER['REDIRECT_HTTP_AUTHORIZATION'])) {
                $cabeceras['Authorization'] = $_SERVER['REDIRECT_HTTP_AUTHORIZATION'];
            } elseif (isset($_SERVER['PHP_AUTH_USER'])) {
                $temp = isset($_SERVER['PHP_AUTH_PW']) ? $_SERVER['PHP_AUTH_PW'] : '';
                $cabeceras['Authorization'] = 'Basic ' . base64_encode($_SERVER['PHP_AUTH_USER'] . ':' . $temp);
            } elseif (isset($_SERVER['PHP_AUTH_DIGEST'])) {
                $cabeceras['Authorization'] = $_SERVER['PHP_AUTH_DIGEST'];
            }
        }

        // Preparamos parámetros según método
        $parametros = [];
        if ($metodo != 'GET') {
            $parametros = self::procesarParametros(file_get_contents('php://input'), $cabeceras['Content-Type'], $_POST);
        }

        // Preparamos galletas
        $galletas = [];
        if (!empty($_COOKIE)) {
            $galletas = $_COOKIE;
        }

        // Preparamos archivos
        $archivos = [];
        if (!empty($_FILES)) {
            $archivos = self::prepararArchivos($_FILES);
        }

        // Iniciamos instancia de petición con los datos ya preparados
        $peticion = new Peticion($url, $metodo, $parametros, $cabeceras, $galletas, $archivos);


        // Preparamos IP del cliente
        if (isset($_SERVER['HTTP_CLIENT_IP'])) {
            $peticion->cliente_ip = $_SERVER['HTTP_CLIENT_IP'];
        } elseif (isset($_SERVER['HTTP_X_FORWARDED_FOR']) && filter_var($_SERVER['HTTP_X_FORWARDED_FOR'], FILTER_VALIDATE_IP)) {
            $peticion->cliente_ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
        } else {
            $peticion->cliente_ip = $_SERVER['REMOTE_ADDR'];
        }


        // Retornamos instancia iniciada
        return $peticion;
    }
219883
def AutorizarLiquidacion(self):
        ""
        # limpio los elementos que no correspondan por estar vacios:
        for campo in ["guia", "dte", "gasto", "tributo"]:
            if campo in self.solicitud and not self.solicitud[campo]:
                del self.solicitud[campo]
        for item in self.solicitud['itemDetalleLiquidacion']:
            if not item.get("liquidacionCompraAsociada", True):
                del item["liquidacionCompraAsociada"]
        # llamo al webservice:
        ret = self.client.generarLiquidacion(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        solicitud=self.solicitud,
                        )
        # analizo la respusta
        ret = ret['respuesta']
        self.__analizar_errores(ret)
        self.AnalizarLiquidacion(ret)
        return True
907792
protected function gerarNossoNumero()
    {
        $ano = $this->getDataDocumento()->format('y');
        $byte = $this->getByte();
        $numero_boleto = Util::numberFormatGeral($this->getNumero(), 5);
        $nossoNumero = $ano . $byte . $numero_boleto
            . CalculoDV::sicrediNossoNumero($this->getAgencia(), $this->getPosto(), $this->getConta(), $ano, $byte, $numero_boleto);
        return $nossoNumero;
    }
1341918
protected function gerarNossoNumero()
    {
        $numero_boleto = $this->getNumero();
        return Util::numberFormatGeral($numero_boleto, 7) . CalculoDV::bnbNossoNumero($this->getNumero());
    }
814802
def AutorizarLiquidacion(self):
        ""
        
        # limpio los elementos que no correspondan por estar vacios:
        if not self.liquidacion['certificados']:
            del self.liquidacion['certificados']
        if not self.retenciones:
            self.retenciones = None
        if not self.deducciones:
            self.deducciones = None
        if not self.percepciones:
            self.percepciones = None
        else:
            # ajustar los nombres de campos que varian entre LPG y LSG
            for it in self.percepciones:
                per = it['percepcion']
                per['descripcion'] = per.pop("detalleAclaratoria")
                del per['baseCalculo']
                del per['alicuota']
        
        # llamo al webservice:
        ret = self.client.liquidacionAutorizar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        liquidacion=self.liquidacion,
                        retenciones=self.retenciones,
                        deducciones=self.deducciones,
                        percepciones=self.percepciones,
                        )

        # analizo la respusta
        ret = ret['liqReturn']
        self.__analizar_errores(ret)
        self.AnalizarLiquidacion(ret.get('autorizacion'), self.liquidacion)
        return True
387311
public function main()
    {
        // cargar XML y extraer arreglo con datos de carátula y DTEs
        $EnvioDte = new \sasco\LibreDTE\Sii\EnvioDte();
        $EnvioDte->loadXML(file_get_contents($this->args['xml']));
        $Caratula = $EnvioDte->getCaratula();
        $Documentos = $EnvioDte->getDocumentos();
        // procesar cada DTEs e ir creando los archivos PDF
        foreach ($Documentos as $DTE) {
            if (!$DTE->getDatos())
                $this->error('No se pudieron obtener los datos de uno de los DTE del XML');
            $this->out('Generando PDF para DTE '.$DTE->getID());
            $pdf = new \sasco\LibreDTE\Sii\Dte\PDF\Dte($this->args['papel']);
            $pdf->setFooterText();
            if ($this->args['logo'])
                $pdf->setLogo($this->args['logo']);
            $pdf->setResolucion(['FchResol'=>$Caratula['FchResol'], 'NroResol'=>$Caratula['NroResol']]);
            $pdf->setWebVerificacion($this->args['web']);
            $pdf->agregar($DTE->getDatos(), $DTE->getTED());
            if (isset($this->args['cedible'])) {
                $pdf->setCedible(true);
                $pdf->agregar($DTE->getDatos(), $DTE->getTED());
            }
            $pdf->Output($this->args['dir'].'/dte_'.$Caratula['RutEmisor'].'_'.$DTE->getID().'.pdf', 'F');
        }
        return 0;
    }