Dejar mensaje en bitacora de depuración (método interno)
437094
def log(self, msg):
        ""
        if not isinstance(msg, unicode):
            msg = unicode(msg, 'utf8', 'ignore')
        if not self.Log:
            self.Log = StringIO()
        self.Log.write(msg)
        self.Log.write('\n\r')
        if DEBUG:
            warnings.warn(msg)
149354
def ObtenerTablaParametros(self, tipo_recurso, sep="||"):
        ""        
        if not self.client:
            self.Conectar()
        self.response = self.client("parametros", "v1", tipo_recurso)
        result = json.loads(self.response)
        ret = {}
        if result['success']:
            data = result['data']
            # armo un diccionario con los datos devueltos:
            key = [k for k in data[0].keys() if k.startswith("id")][0]
            val = [k for k in data[0].keys() if k.startswith("desc")][0]
            for it in data:
                ret[it[key]] = it[val]
            self.data = data
        else:
            error = result['error']
            self.Excepcion = error['mensaje']
        if sep:
            return ["%s%%s%s%%s%s" % (sep, sep, sep) % it for it in sorted(ret.items())]
        else:
            return ret
1017402
public static function DirtyFopenConvertEncoding ($arg_file_path, $to_encoding, $from_encoding, $php_path = null) {
		//==============================================
		//何があっても/etcにはアクセスさせない
		//==============================================
		$file_path = realpath($arg_file_path);
		if (!$file_path) {
			throw CoreException::RaiseSystemError('対象ファイルが存在しません。path:%s', [$arg_file_path]);
		}

		if (substr($file_path, 0, 5) === '/etc/') {
			throw CoreException::RaiseSystemError('/etc以下を狙ったアクセスが行われました！path:%s', [$file_path]);
		}

		$php_path = $php_path ?: \PHP_BINARY;
		if (!realpath($php_path)) {
			throw CoreException::RaiseSystemError('対象コマンドが存在しません。path:%s', [$php_path]);
		}

		if ($php_path !== 'php' && substr(realpath($php_path), 0, 5) === '/etc/') {
			throw CoreException::RaiseSystemError('/etc以下を狙ったアクセスが行われました！path:%s', [$php_path]);
		}

		//
		$to_encoding = $to_encoding ?: mb_internal_encoding();

		if ($from_encoding) {
			$command = sprintf(
				"echo mb_convert_encoding(file_get_contents('%s'), '%s', '%s');",
				$file_path,
				$to_encoding,
				$from_encoding
			);
		} else {
			$command = sprintf(
				"echo mb_convert_encoding(file_get_contents('%s'), '%s');",
				$file_path,
				$to_encoding
			);
		}
//@TODO rbを定数化
		return popen(sprintf('%s -d memory_limit=-1 -r %s', escapeshellarg($php_path), escapeshellarg($command)), 'rb');
	}
647632
def ConsultarTiposOperacion(self, sep="||"):
        ""
        ops = []
        ret = self.client.tipoActividadConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoActividadReturn']
        self.__analizar_errores(ret)
        for it_act in ret.get('tiposActividad', []):

            ret = self.client.tipoOperacionXActividadConsultar(
                            auth={
                                'token': self.Token, 'sign': self.Sign,
                                'cuit': self.Cuit, },
                            nroActLiquida=it_act['codigoDescripcion']['codigo'],
                            )['tipoOperacionReturn']
            self.__analizar_errores(ret)
            array = ret.get('tiposOperacion', [])
            if sep:
                ops.extend([("%s %%s %s %%s %s %%s %s" % (sep, sep, sep, sep)) % 
                    (it_act['codigoDescripcion']['codigo'],
                     it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
                   for it in array])
            else:
                ops.extend([(it_act['codigoDescripcion']['codigo'],
                             it['codigoDescripcion']['codigo'], 
                             it['codigoDescripcion']['descripcion']) 
                           for it in array])
        return ops
376613
def __analizar_errores(self, ret):
        ""
        self.Errores = [err['codigoDescripcion'] for err in ret.get('arrayErrores', [])]
        self.ErroresFormato = [err['codigoDescripcionString'] for err in ret.get('arrayErroresFormato', [])]
        errores = self.Errores + self.ErroresFormato
        self.ErrCode = ' '.join(["%(codigo)s" % err for err in errores])
        self.ErrMsg = '\n'.join(["%(codigo)s: %(descripcion)s" % err for err in errores])
660676
public function displayInfo()
    {
        $s = "File Size: %u\n"
            ."Chunk Size: %u\n"
            ."fmt Subchunk Size: %u\n"
            ."Extended fmt Size: %u\n"
            ."fact Subchunk Size: %u\n"
            ."Data Offset: %u\n"
            ."Data Size: %u\n"
            ."Audio Format: %s\n"
            ."Audio SubFormat: %s\n"
            ."Channels: %u\n"
            ."Channel Mask: 0x%s\n"
            ."Sample Rate: %u\n"
            ."Bits Per Sample: %u\n"
            ."Valid Bits Per Sample: %u\n"
            ."Sample Block Size: %u\n"
            ."Number of Sample Blocks: %u\n"
            ."Byte Rate: %uBps\n";

        $s = sprintf($s, $this->getActualSize(),
                         $this->getChunkSize(),
                         $this->getFmtChunkSize(),
                         $this->getFmtExtendedSize(),
                         $this->getFactChunkSize(),
                         $this->getDataOffset(),
                         $this->getDataSize(),
                         $this->getAudioFormat() == self::WAVE_FORMAT_PCM ? 'PCM' : ($this->getAudioFormat() == self::WAVE_FORMAT_IEEE_FLOAT ? 'IEEE FLOAT' : 'EXTENSIBLE'),
                         $this->getAudioSubFormat() == self::WAVE_SUBFORMAT_PCM ? 'PCM' : 'IEEE FLOAT',
                         $this->getNumChannels(),
                         dechex($this->getChannelMask()),
                         $this->getSampleRate(),
                         $this->getBitsPerSample(),
                         $this->getValidBitsPerSample(),
                         $this->getBlockAlign(),
                         $this->getNumBlocks(),
                         $this->getByteRate());

        if (php_sapi_name() == 'cli') {
            return $s;
        } else {
            return nl2br($s);
        }
    }
143985
public function step2()
    {
        // atori   itate   itati, ităţi, abila   abile   abili   abilă, ibila   ibile   ibili   ibilă
        // anta, ante, anti, antă, ator, ibil, oasa   oasă   oase, ităi, abil
        // osi   oşi   ant   ici   ică iva   ive   ivi   ivă ata   ată   ati   ate, ata   ată   ati   ate uta   ută   uti   ute, ita   ită   iti   ite  ica   ice
        // at, os, iv, ut, it, ic
        //      delete
        if ( ($position = $this->search(array(
            'atori', 'itate', 'itati', 'ităţi', 'abila', 'abile', 'abili', 'abilă', 'ibila', 'ibile', 'ibili', 'ibilă',
            'anta', 'ante', 'anti', 'antă', 'ator', 'ibil', 'oasa', 'oasă', 'oase', 'ităi', 'abil',
            'osi', 'oşi', 'ant', 'ici', 'ică', 'iva', 'ive', 'ivi', 'ivă', 'ata', 'ată', 'ati', 'ate', 'ata', 'ată',
            'ati', 'ate', 'uta', 'ută', 'uti', 'ute', 'ita', 'ită', 'iti', 'ite', 'ica', 'ice',
            'at', 'os', 'iv', 'ut', 'it', 'ic'
        ))) !== false) {
            if ($this->inR2($position)) {
                $this->word = Utf8::substr($this->word, 0, $position);
            }
            return true;
        }

        // iune   iuni
        //      delete if preceded by ţ, and replace the ţ by t.
        if ( ($position = $this->search(array('iune', 'iuni'))) !== false) {
            if ($this->inR2($position)) {
                $before = $position - 1;
                $letter = Utf8::substr($this->word, $before, 1);
                if ($letter == 'ţ') {
                    $this->word = Utf8::substr($this->word, 0, $position);
                    $this->word = preg_replace('#(ţ)$#u', 't', $this->word);
                }
            }
            return true;
        }

        // ism   isme   ist   ista   iste   isti   istă   işti
        //      replace with ist
        if ( ($position = $this->search(array('isme', 'ism', 'ista', 'iste', 'isti', 'istă', 'işti', 'ist'))) !== false) {
            if ($this->inR2($position)) {
                $this->word = preg_replace('#(isme|ism|ista|iste|isti|istă|işti|ist)$#u', 'ist', $this->word);
            }
            return true;
        }

        return false;
    }
47456
def ConsultarTipoActividadRepresentado(self, sep="||"):
        ""
        try:
            ret = self.client.tipoActividadRepresentadoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoActividadReturn']
            self.__analizar_errores(ret)
            array = ret.get('tiposActividad', [])
            self.Excepcion = self.Traceback = ""
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
        except Exception:
            ex = utils.exception_info()
            self.Excepcion = ex['msg']
            self.Traceback = ex['tb']
            if sep:
                return ["ERROR"]
1077045
def ConsultarTiposContingencia(self, sep="||"):
        ""
        ret = self.client.consultarTiposContingencia(
                            authRequest={
                                'token': self.Token, 'sign': self.Sign,
                                'cuitRepresentada': self.Cuit, },
                                )['consultarTiposContingenciaReturn']
        self.__analizar_errores(ret)
        array = ret.get('arrayTiposContingencia', [])
        lista = [it['codigoDescripcion'] for it in array]
        return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista]
766897
def ConsultarContribuyentes(self, fecha_desde, fecha_hasta, cuit_contribuyente):
        ""
        self.limpiar()
        try:

            self.xml = SimpleXMLElement(XML_ENTRADA_BASE)
            self.xml.fechaDesde = fecha_desde
            self.xml.fechaHasta = fecha_hasta
            self.xml.contribuyentes.contribuyente.cuitContribuyente = cuit_contribuyente

            xml = self.xml.as_xml()
            self.CodigoHash = md5.md5(xml).hexdigest()
            nombre = "DFEServicioConsulta_%s.xml" % self.CodigoHash

            # guardo el xml en el archivo a enviar y luego lo re-abro:
            archivo = open(os.path.join(tempfile.gettempdir(), nombre), "w")
            archivo.write(xml)
            archivo.close()
            archivo = open(os.path.join(tempfile.gettempdir(), nombre), "r")

            if not self.testing:
                response = self.client(user=self.Usuario, password=self.Password,
                                   file=archivo)
            else:
                response = open(self.testing).read()
            self.XmlResponse = response
            self.xml = SimpleXMLElement(response)
            if 'tipoError' in self.xml:
                self.TipoError = str(self.xml.tipoError)
                self.CodigoError = str(self.xml.codigoError)
                self.MensajeError = str(self.xml.mensajeError).decode('latin1').encode("ascii", "replace")
            if 'numeroComprobante' in self.xml:
                self.NumeroComprobante = str(self.xml.numeroComprobante)
                self.CantidadContribuyentes = int(self.xml.cantidadContribuyentes)
                if 'contribuyentes' in self.xml:
                    for contrib in self.xml.contribuyente:
                        c = {
                            'CuitContribuytente': str(contrib.cuitContribuyente),
                            'AlicuotaPercepcion': str(contrib.alicuotaPercepcion),
                            'AlicuotaRetencion': str(contrib.alicuotaRetencion),
                            'GrupoPercepcion': str(contrib.grupoPercepcion),
                            'GrupoRetencion': str(contrib.grupoRetencion),
                            'Errores': [],
                            }
                        self.contribuyentes.append(c)
                    # establecer valores del primer contrib (sin eliminarlo)
                    self.LeerContribuyente(pop=False)
            return True
        except Exception, e:
                ex = traceback.format_exception( sys.exc_type, sys.exc_value, sys.exc_traceback)
                self.Traceback = ''.join(ex)
                try:
                    self.Excepcion = traceback.format_exception_only( sys.exc_type, sys.exc_value)[0]
                except:
                    self.Excepcion = u"<no disponible>"
                return False
870648
def analisar(retorno):
        
        if '|' not in retorno:
            raise ErroRespostaSATInvalida('Resposta nao possui pipes '
                    'separando os campos: {!r}'.format(retorno))

        resposta = _RespostaParcial(*(retorno.split('|')[:2]))

        for faixa, construtor in _RESPOSTAS_POSSIVEIS:
            if int(resposta.EEEEE) in xrange(faixa, faixa+1000):
                return construtor(retorno)

        return RespostaConsultarNumeroSessao._pos_analise(retorno)
530586
private static function _configureLogger()
    {
        //brak konfiguracji
        if (!self::$_config) {
            //tworzy pustą konfigurację
            return new \Psr\Log\NullLogger;
        }
        //nowy obiekt loggera
        $logger = new Logger(self::$_config->getName());
        //iteracja po konfiguracjach instancji
        foreach (self::$_config as $config) {
            self::_configureInstance($config, $logger);
        }
        return $logger;
    }
756167
def ConsultarTipoRetencion(self, sep="||"):
        ""
        ret = self.client.tipoRetencionConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoRetencionReturn']
        self.__analizar_errores(ret)
        array = ret.get('tiposRetencion', [])
        return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
640997
protected function busqueda($base, $filtro, $atributos, $limite = 499, $ordenar = false){
        try {
            if (!($busquedaLdap = ldap_search($this->conexionLdap, $base, $filtro, $atributos, 0, $limite))){
                throw new ErrorException (ldap_error($this->conexionLdap));
            }
            if ($ordenar) {
                ldap_sort($this->conexionLdap, $busquedaLdap, $filtro[0]);
            }
            // La función muere en el momento que un throw es invocado. Así las cosas
            // TODO: Básicamente, debo quitar esto lo más pronto posible.
            // Esta operación a estas alturas no representa un error, pero si debe cortar muchas cosas
            if (!($datos = $this->iterarEntradas($busquedaLdap, $atributos))) {
                throw new ErrorException ('La busqueda no devuelve entradas');
            }             
            return $datos;
            // Hacemos la verdadera iteracion
        } catch (ErrorException $e) {
            $this->configurarErrorLdap('Error en búsqueda', $e->getMessage());
            return FALSE;
        }
    }
832665
def ConsultarRetencionesTabacaleras(self, sep="||"):
        ""
        ret = self.client.consultarRetencionesTabacaleras(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('retencion', [])
        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]
780113
def AnalizarRemito(self, ret, archivo=None):
        ""
        if ret:
            self.CodRemito = ret.get("codRemito")
            self.TipoComprobante = ret.get("tipoComprobante")
            self.PuntoEmision = ret.get("puntoEmision")
            datos_aut = ret.get('datosAutorizacion')
            if datos_aut:
                self.NroRemito = datos_aut.get('nroRemito')
                self.CodAutorizacion = datos_aut.get('codAutorizacion')
                self.FechaEmision = datos_aut.get('fechaEmision')
                self.FechaVencimiento = datos_aut.get('fechaVencimiento')
            self.Estado = ret.get('estado')
            self.Resultado = ret.get('resultado')
            self.QR = ret.get('qr') or ""
            if archivo:
                qr = base64.b64decode(self.QR)
                f = open(archivo, "wb")
                f.write(qr)
                f.close()
779932
def AutorizarRemito(self, archivo="qr.png"):
        ""
        response = self.client.autorizarRemito(
                                authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit},
                                codRemito=self.remito['codRemito'],
                                estado=self.remito['estado'])
        ret = response.get("autorizarRemitoReturn")
        if ret:
            self.__analizar_errores(ret)
            self.__analizar_observaciones(ret)
            self.__analizar_evento(ret)
            self.AnalizarRemito(ret, archivo)
        return bool(self.CodRemito)