satcfdi.create.pld.tcv - Code Metrics - SAT-CFDI/python-satcfdi - Measure and Improve Code Quality continuously with Scrutinizer

satcfdi.create.pld.tcv A
last analyzed 2025-06-07 00:41 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	915
Duplicated Lines	5.25 %

Importance

Changes

Metric	Value
eloc	451
dl	48
loc	915
rs	9.2
c	0
b	0
f	0
wmc	40

40 Methods

Rating	Name	Duplication	Size	Complexity
A	DatosNoSucursalType.__init__()	0	14	1
A	FideicomisoSimpleType.__init__()	0	10	1
A	PersonaMoralType.__init__()	0	16	1
A	DatosValoresType.__init__()	0	10	1
A	EntregaType.__init__()	0	8	1
A	PersonaFisicaSimpleType.__init__()	0	18	1
A	NacionalEntregaType.__init__()	0	6	1
A	PersonaAvisoType.__init__()	0	10	1
A	DuenoBeneficiarioType.__init__()	0	6	1
A	FideicomisoType.__init__()	0	12	1
A	PersonaMoralSimpleType.__init__()	0	12	1
A	AlertaType.__init__()	0	8	1
A	ExtranjeroType.__init__()	0	20	1
A	DatosOperacionType.__init__()	0	18	1
A	RepresentanteApoderadoType.__init__()	0	16	1
A	PersonaFisicaDestinatarioType.__init__()	0	16	1
A	CustodiaType.__init__()	0	10	1
A	DatosSucursalType.__init__()	0	6	1
A	RecepcionType.__init__()	0	10	1
A	TipoEntregaType.__init__()	0	8	1
A	FideicomisoDestinatarioType.__init__()	0	10	1
A	NacionalType.__init__()	0	14	1
A	SujetoObligadoType.__init__()	0	12	1
A	TipoCustodiaType.__init__()	0	8	1
A	ExtranjeroEntregaType.__init__()	0	12	1
A	DatosEfectivoInstrumentosType.__init__()	0	10	1
A	TelefonoType.__init__()	0	10	1
A	TipoBienType.__init__()	0	8	1
A	PersonaFisicaType.__init__()	0	20	1
A	ModificatorioType.__init__()	0	8	1
A	TipoDomicilioType.__init__()	0	8	1
A	PersonaMoralDestinatarioType.__init__()	0	10	1
A	DetalleOperacionesType.__init__()	0	6	1
A	TipoPersonaSimpleType.__init__()	0	10	1
A	TipoPersonaType.__init__()	0	10	1
A	ArchivoType.__init__()	0	6	1
A	DestinatarioType.__init__()	0	8	1
A	AvisoType.__init__()	18	18	1
A	InformeType.__init__()	10	10	1
A	TipoPersonaDestinatarioType.__init__()	0	10	1

How to fix Duplicated Code Complexity

"""tcv http://www.uif.shcp.gob.mx/recepcion/tcv"""
from decimal import Decimal
from datetime import datetime, date, time
from collections.abc import Sequence
from ...cfdi import CFDI
from ...xelement import XElement
from ...utils import ScalarMap


class FideicomisoDestinatarioType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param rfc:
    :param identificador_fideicomiso:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            rfc: str = None,
            identificador_fideicomiso: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'Rfc': rfc,
            'IdentificadorFideicomiso': identificador_fideicomiso,
        })
        

class PersonaMoralDestinatarioType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param fecha_constitucion:
    :param rfc:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            fecha_constitucion: date = None,
            rfc: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'FechaConstitucion': fecha_constitucion,
            'Rfc': rfc,
        })
        

class PersonaFisicaDestinatarioType(ScalarMap):
    """
    
    :param nombre:
    :param apellido_paterno:
    :param apellido_materno:
    :param fecha_nacimiento:
    :param rfc:
    :param curp:
    """
    
    def __init__(
            self,
            nombre: str,
            apellido_paterno: str,
            apellido_materno: str,
            fecha_nacimiento: date = None,
            rfc: str = None,
            curp: str = None,
    ): 
        super().__init__({
            'Nombre': nombre,
            'ApellidoPaterno': apellido_paterno,
            'ApellidoMaterno': apellido_materno,
            'FechaNacimiento': fecha_nacimiento,
            'Rfc': rfc,
            'Curp': curp,
        })
        

class TipoPersonaDestinatarioType(ScalarMap):
    """
    
    :param persona_fisica:
    :param persona_moral:
    :param fideicomiso:
    """
    
    def __init__(
            self,
            persona_fisica: PersonaFisicaDestinatarioType | dict = None,
            persona_moral: PersonaMoralDestinatarioType | dict = None,
            fideicomiso: FideicomisoDestinatarioType | dict = None,
    ): 
        super().__init__({
            'PersonaFisica': persona_fisica,
            'PersonaMoral': persona_moral,
            'Fideicomiso': fideicomiso,
        })
        

class DestinatarioType(ScalarMap):
    """
    
    :param destinatario_persona_aviso:
    :param tipo_persona:
    """
    
    def __init__(
            self,
            destinatario_persona_aviso: str,
            tipo_persona: TipoPersonaDestinatarioType | dict = None,
    ): 
        super().__init__({
            'DestinatarioPersonaAviso': destinatario_persona_aviso,
            'TipoPersona': tipo_persona,
        })
        

class ExtranjeroEntregaType(ScalarMap):
    """
    
    :param pais:
    :param estado_provincia:
    :param ciudad_poblacion:
    :param codigo_postal:
    """
    
    def __init__(
            self,
            pais: str,
            estado_provincia: str,
            ciudad_poblacion: str,
            codigo_postal: str,
    ): 
        super().__init__({
            'Pais': pais,
            'EstadoProvincia': estado_provincia,
            'CiudadPoblacion': ciudad_poblacion,
            'CodigoPostal': codigo_postal,
        })
        

class NacionalEntregaType(ScalarMap):
    """
    
    :param codigo_postal:
    """
    
    def __init__(
            self,
            codigo_postal: str,
    ): 
        super().__init__({
            'CodigoPostal': codigo_postal,
        })
        

class TipoEntregaType(ScalarMap):
    """
    
    :param nacional:
    :param extranjero:
    """
    
    def __init__(
            self,
            nacional: NacionalEntregaType | dict = None,
            extranjero: ExtranjeroEntregaType | dict = None,
    ): 
        super().__init__({
            'Nacional': nacional,
            'Extranjero': extranjero,
        })
        

class EntregaType(ScalarMap):
    """
    
    :param fecha_entrega:
    :param tipo_entrega:
    """
    
    def __init__(
            self,
            fecha_entrega: date,
            tipo_entrega: TipoEntregaType | dict,
    ): 
        super().__init__({
            'FechaEntrega': fecha_entrega,
            'TipoEntrega': tipo_entrega,
        })
        

class DatosNoSucursalType(ScalarMap):
    """
    
    :param colonia:
    :param calle:
    :param numero_exterior:
    :param codigo_postal:
    :param numero_interior:
    """
    
    def __init__(
            self,
            colonia: str,
            calle: str,
            numero_exterior: str,
            codigo_postal: str,
            numero_interior: str = None,
    ): 
        super().__init__({
            'Colonia': colonia,
            'Calle': calle,
            'NumeroExterior': numero_exterior,
            'CodigoPostal': codigo_postal,
            'NumeroInterior': numero_interior,
        })
        

class DatosSucursalType(ScalarMap):
    """
    
    :param codigo_postal:
    """
    
    def __init__(
            self,
            codigo_postal: str,
    ): 
        super().__init__({
            'CodigoPostal': codigo_postal,
        })
        

class TipoCustodiaType(ScalarMap):
    """
    
    :param datos_sucursal:
    :param datos_no_sucursal:
    """
    
    def __init__(
            self,
            datos_sucursal: DatosSucursalType | dict = None,
            datos_no_sucursal: DatosNoSucursalType | dict = None,
    ): 
        super().__init__({
            'DatosSucursal': datos_sucursal,
            'DatosNoSucursal': datos_no_sucursal,
        })
        

class CustodiaType(ScalarMap):
    """
    
    :param fecha_inicio:
    :param fecha_fin:
    :param tipo_custodia:
    """
    
    def __init__(
            self,
            fecha_inicio: date,
            fecha_fin: date,
            tipo_custodia: TipoCustodiaType | dict,
    ): 
        super().__init__({
            'FechaInicio': fecha_inicio,
            'FechaFin': fecha_fin,
            'TipoCustodia': tipo_custodia,
        })
        

class RecepcionType(ScalarMap):
    """
    
    :param tipo_servicio:
    :param fecha_recepcion:
    :param codigo_postal:
    """
    
    def __init__(
            self,
            tipo_servicio: str,
            fecha_recepcion: date,
            codigo_postal: str,
    ): 
        super().__init__({
            'TipoServicio': tipo_servicio,
            'FechaRecepcion': fecha_recepcion,
            'CodigoPostal': codigo_postal,
        })
        

class DatosValoresType(ScalarMap):
    """
    
    :param tipo_valor:
    :param valor_objeto:
    :param descripcion:
    """
    
    def __init__(
            self,
            tipo_valor: str,
            valor_objeto: str,
            descripcion: str,
    ): 
        super().__init__({
            'TipoValor': tipo_valor,
            'ValorObjeto': valor_objeto,
            'Descripcion': descripcion,
        })
        

class DatosEfectivoInstrumentosType(ScalarMap):
    """
    
    :param instrumento_monetario:
    :param moneda:
    :param monto_operacion:
    """
    
    def __init__(
            self,
            instrumento_monetario: str,
            moneda: str,
            monto_operacion: str,
    ): 
        super().__init__({
            'InstrumentoMonetario': instrumento_monetario,
            'Moneda': moneda,
            'MontoOperacion': monto_operacion,
        })
        

class TipoBienType(ScalarMap):
    """
    
    :param datos_efectivo_instrumentos:
    :param datos_valores:
    """
    
    def __init__(
            self,
            datos_efectivo_instrumentos: DatosEfectivoInstrumentosType | dict = None,
            datos_valores: DatosValoresType | dict = None,
    ): 
        super().__init__({
            'DatosEfectivoInstrumentos': datos_efectivo_instrumentos,
            'DatosValores': datos_valores,
        })
        

class DatosOperacionType(ScalarMap):
    """
    
    :param fecha_operacion:
    :param tipo_operacion:
    :param tipo_bien:
    :param recepcion:
    :param custodia:
    :param entrega:
    :param destinatario:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            tipo_operacion: str,
            tipo_bien: TipoBienType | dict | Sequence[TipoBienType | dict],
            recepcion: RecepcionType | dict = None,
            custodia: CustodiaType | dict = None,
            entrega: EntregaType | dict = None,
            destinatario: DestinatarioType | dict = None,
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'TipoOperacion': tipo_operacion,
            'TipoBien': tipo_bien,
            'Recepcion': recepcion,
            'Custodia': custodia,
            'Entrega': entrega,
            'Destinatario': destinatario,
        })
        

class DetalleOperacionesType(ScalarMap):
    """
    
    :param datos_operacion:
    """
    
    def __init__(
            self,
            datos_operacion: DatosOperacionType | dict | Sequence[DatosOperacionType | dict],
    ): 
        super().__init__({
            'DatosOperacion': datos_operacion,
        })
        

class FideicomisoSimpleType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param rfc:
    :param identificador_fideicomiso:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            rfc: str = None,
            identificador_fideicomiso: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'Rfc': rfc,
            'IdentificadorFideicomiso': identificador_fideicomiso,
        })
        

class PersonaMoralSimpleType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param fecha_constitucion:
    :param rfc:
    :param pais_nacionalidad:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            fecha_constitucion: date = None,
            rfc: str = None,
            pais_nacionalidad: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'FechaConstitucion': fecha_constitucion,
            'Rfc': rfc,
            'PaisNacionalidad': pais_nacionalidad,
        })
        

class PersonaFisicaSimpleType(ScalarMap):
    """
    
    :param nombre:
    :param apellido_paterno:
    :param apellido_materno:
    :param fecha_nacimiento:
    :param rfc:
    :param curp:
    :param pais_nacionalidad:
    """
    
    def __init__(
            self,
            nombre: str,
            apellido_paterno: str,
            apellido_materno: str,
            fecha_nacimiento: date = None,
            rfc: str = None,
            curp: str = None,
            pais_nacionalidad: str = None,
    ): 
        super().__init__({
            'Nombre': nombre,
            'ApellidoPaterno': apellido_paterno,
            'ApellidoMaterno': apellido_materno,
            'FechaNacimiento': fecha_nacimiento,
            'Rfc': rfc,
            'Curp': curp,
            'PaisNacionalidad': pais_nacionalidad,
        })
        

class TipoPersonaSimpleType(ScalarMap):
    """
    
    :param persona_fisica:
    :param persona_moral:
    :param fideicomiso:
    """
    
    def __init__(
            self,
            persona_fisica: PersonaFisicaSimpleType | dict = None,
            persona_moral: PersonaMoralSimpleType | dict = None,
            fideicomiso: FideicomisoSimpleType | dict = None,
    ): 
        super().__init__({
            'PersonaFisica': persona_fisica,
            'PersonaMoral': persona_moral,
            'Fideicomiso': fideicomiso,
        })
        

class DuenoBeneficiarioType(ScalarMap):
    """
    
    :param tipo_persona:
    """
    
    def __init__(
            self,
            tipo_persona: TipoPersonaSimpleType | dict,
    ): 
        super().__init__({
            'TipoPersona': tipo_persona,
        })
        

class TelefonoType(ScalarMap):
    """
    
    :param clave_pais:
    :param numero_telefono:
    :param correo_electronico:
    """
    
    def __init__(
            self,
            clave_pais: str = None,
            numero_telefono: str = None,
            correo_electronico: str = None,
    ): 
        super().__init__({
            'ClavePais': clave_pais,
            'NumeroTelefono': numero_telefono,
            'CorreoElectronico': correo_electronico,
        })
        

class ExtranjeroType(ScalarMap):
    """
    
    :param pais:
    :param estado_provincia:
    :param ciudad_poblacion:
    :param colonia:
    :param calle:
    :param numero_exterior:
    :param codigo_postal:
    :param numero_interior:
    """
    
    def __init__(
            self,
            pais: str,
            estado_provincia: str,
            ciudad_poblacion: str,
            colonia: str,
            calle: str,
            numero_exterior: str,
            codigo_postal: str,
            numero_interior: str = None,
    ): 
        super().__init__({
            'Pais': pais,
            'EstadoProvincia': estado_provincia,
            'CiudadPoblacion': ciudad_poblacion,
            'Colonia': colonia,
            'Calle': calle,
            'NumeroExterior': numero_exterior,
            'CodigoPostal': codigo_postal,
            'NumeroInterior': numero_interior,
        })
        

class NacionalType(ScalarMap):
    """
    
    :param colonia:
    :param calle:
    :param numero_exterior:
    :param codigo_postal:
    :param numero_interior:
    """
    
    def __init__(
            self,
            colonia: str,
            calle: str,
            numero_exterior: str,
            codigo_postal: str,
            numero_interior: str = None,
    ): 
        super().__init__({
            'Colonia': colonia,
            'Calle': calle,
            'NumeroExterior': numero_exterior,
            'CodigoPostal': codigo_postal,
            'NumeroInterior': numero_interior,
        })
        

class TipoDomicilioType(ScalarMap):
    """
    
    :param nacional:
    :param extranjero:
    """
    
    def __init__(
            self,
            nacional: NacionalType | dict = None,
            extranjero: ExtranjeroType | dict = None,
    ): 
        super().__init__({
            'Nacional': nacional,
            'Extranjero': extranjero,
        })
        

class RepresentanteApoderadoType(ScalarMap):
    """
    
    :param nombre:
    :param apellido_paterno:
    :param apellido_materno:
    :param fecha_nacimiento:
    :param rfc:
    :param curp:
    """
    
    def __init__(
            self,
            nombre: str,
            apellido_paterno: str,
            apellido_materno: str,
            fecha_nacimiento: date = None,
            rfc: str = None,
            curp: str = None,
    ): 
        super().__init__({
            'Nombre': nombre,
            'ApellidoPaterno': apellido_paterno,
            'ApellidoMaterno': apellido_materno,
            'FechaNacimiento': fecha_nacimiento,
            'Rfc': rfc,
            'Curp': curp,
        })
        

class FideicomisoType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param apoderado_delegado:
    :param rfc:
    :param identificador_fideicomiso:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            apoderado_delegado: RepresentanteApoderadoType | dict,
            rfc: str = None,
            identificador_fideicomiso: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'ApoderadoDelegado': apoderado_delegado,
            'Rfc': rfc,
            'IdentificadorFideicomiso': identificador_fideicomiso,
        })
        

class PersonaMoralType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param pais_nacionalidad:
    :param giro_mercantil:
    :param representante_apoderado:
    :param fecha_constitucion:
    :param rfc:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            pais_nacionalidad: str,
            giro_mercantil: str,
            representante_apoderado: RepresentanteApoderadoType | dict,
            fecha_constitucion: date = None,
            rfc: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'PaisNacionalidad': pais_nacionalidad,
            'GiroMercantil': giro_mercantil,
            'RepresentanteApoderado': representante_apoderado,
            'FechaConstitucion': fecha_constitucion,
            'Rfc': rfc,
        })
        

class PersonaFisicaType(ScalarMap):
    """
    
    :param nombre:
    :param apellido_paterno:
    :param apellido_materno:
    :param pais_nacionalidad:
    :param actividad_economica:
    :param fecha_nacimiento:
    :param rfc:
    :param curp:
    """
    
    def __init__(
            self,
            nombre: str,
            apellido_paterno: str,
            apellido_materno: str,
            pais_nacionalidad: str,
            actividad_economica: str,
            fecha_nacimiento: date = None,
            rfc: str = None,
            curp: str = None,
    ): 
        super().__init__({
            'Nombre': nombre,
            'ApellidoPaterno': apellido_paterno,
            'ApellidoMaterno': apellido_materno,
            'PaisNacionalidad': pais_nacionalidad,
            'ActividadEconomica': actividad_economica,
            'FechaNacimiento': fecha_nacimiento,
            'Rfc': rfc,
            'Curp': curp,
        })
        

class TipoPersonaType(ScalarMap):
    """
    
    :param persona_fisica:
    :param persona_moral:
    :param fideicomiso:
    """
    
    def __init__(
            self,
            persona_fisica: PersonaFisicaType | dict = None,
            persona_moral: PersonaMoralType | dict = None,
            fideicomiso: FideicomisoType | dict = None,
    ): 
        super().__init__({
            'PersonaFisica': persona_fisica,
            'PersonaMoral': persona_moral,
            'Fideicomiso': fideicomiso,
        })
        

class PersonaAvisoType(ScalarMap):
    """
    
    :param tipo_persona:
    :param tipo_domicilio:
    :param telefono:
    """
    
    def __init__(
            self,
            tipo_persona: TipoPersonaType | dict,
            tipo_domicilio: TipoDomicilioType | dict = None,
            telefono: TelefonoType | dict = None,
    ): 
        super().__init__({
            'TipoPersona': tipo_persona,
            'TipoDomicilio': tipo_domicilio,
            'Telefono': telefono,
        })
        

class AlertaType(ScalarMap):
    """
    
    :param tipo_alerta:
    :param descripcion_alerta:
    """
    
    def __init__(
            self,
            tipo_alerta: str,
            descripcion_alerta: str = None,
    ): 
        super().__init__({
            'TipoAlerta': tipo_alerta,
            'DescripcionAlerta': descripcion_alerta,
        })
        

class ModificatorioType(ScalarMap):
    """
    
    :param folio_modificacion:
    :param descripcion_modificacion:
    """
    
    def __init__(
            self,
            folio_modificacion: str,
            descripcion_modificacion: str,
    ): 
        super().__init__({
            'FolioModificacion': folio_modificacion,
            'DescripcionModificacion': descripcion_modificacion,
        })
        

class AvisoType(ScalarMap):

    """
    
    :param referencia_aviso:
    :param prioridad:
    :param alerta:
    :param persona_aviso:
    :param detalle_operaciones:
    :param modificatorio:
    :param dueno_beneficiario:
    """
    
    def __init__(
            self,
            referencia_aviso: str,
            prioridad: str,
            alerta: AlertaType | dict,
            persona_aviso: PersonaAvisoType | dict | Sequence[PersonaAvisoType | dict],
            detalle_operaciones: DetalleOperacionesType | dict,
            modificatorio: ModificatorioType | dict = None,
            dueno_beneficiario: DuenoBeneficiarioType | dict | Sequence[DuenoBeneficiarioType | dict] = None,
    ): 
        super().__init__({
            'ReferenciaAviso': referencia_aviso,
            'Prioridad': prioridad,
            'Alerta': alerta,
            'PersonaAviso': persona_aviso,
            'DetalleOperaciones': detalle_operaciones,
            'Modificatorio': modificatorio,
            'DuenoBeneficiario': dueno_beneficiario,
        })
        

class SujetoObligadoType(ScalarMap):
    """
    
    :param clave_sujeto_obligado:
    :param clave_actividad:
    :param clave_entidad_colegiada:
    :param exento:
    """
    
    def __init__(
            self,
            clave_sujeto_obligado: str,
            clave_actividad: str,
            clave_entidad_colegiada: str = None,
            exento: str = None,
    ): 
        super().__init__({
            'ClaveSujetoObligado': clave_sujeto_obligado,
            'ClaveActividad': clave_actividad,
            'ClaveEntidadColegiada': clave_entidad_colegiada,
            'Exento': exento,
        })
        

class InformeType(ScalarMap):

    """
    
    :param mes_reportado:
    :param sujeto_obligado:
    :param aviso:
    """
    
    def __init__(
            self,
            mes_reportado: str,
            sujeto_obligado: SujetoObligadoType | dict,
            aviso: AvisoType | dict | Sequence[AvisoType | dict] = None,
    ): 
        super().__init__({
            'MesReportado': mes_reportado,
            'SujetoObligado': sujeto_obligado,
            'Aviso': aviso,
        })
        

class ArchivoType(ScalarMap):
    """
    
    :param informe:
    """
    
    def __init__(
            self,
            informe: InformeType | dict | Sequence[InformeType | dict],
    ): 
        super().__init__({
            'Informe': informe,
        })
        

class Archivo(ArchivoType, XElement):
    tag = '{http://www.uif.shcp.gob.mx/recepcion/tcv}archivo'



1		"""tcv http://www.uif.shcp.gob.mx/recepcion/tcv"""
2		from decimal import Decimal
3		from datetime import datetime, date, time
4		from collections.abc import Sequence
5		from ...cfdi import CFDI
6		from ...xelement import XElement
7		from ...utils import ScalarMap
8
9
10		class FideicomisoDestinatarioType(ScalarMap):
11		"""
12
13		:param denominacion_razon:
14		:param rfc:
15		:param identificador_fideicomiso:
16		"""
17
18		def __init__(
19		self,
20		denominacion_razon: str,
21		rfc: str = None,
22		identificador_fideicomiso: str = None,
23		):
24		super().__init__({
25		'DenominacionRazon': denominacion_razon,
26		'Rfc': rfc,
27		'IdentificadorFideicomiso': identificador_fideicomiso,
28		})
29
30
31		class PersonaMoralDestinatarioType(ScalarMap):
32		"""
33
34		:param denominacion_razon:
35		:param fecha_constitucion:
36		:param rfc:
37		"""
38
39		def __init__(
40		self,
41		denominacion_razon: str,
42		fecha_constitucion: date = None,
43		rfc: str = None,
44		):
45		super().__init__({
46		'DenominacionRazon': denominacion_razon,
47		'FechaConstitucion': fecha_constitucion,
48		'Rfc': rfc,
49		})
50
51
52		class PersonaFisicaDestinatarioType(ScalarMap):
53		"""
54
55		:param nombre:
56		:param apellido_paterno:
57		:param apellido_materno:
58		:param fecha_nacimiento:
59		:param rfc:
60		:param curp:
61		"""
62
63		def __init__(
64		self,
65		nombre: str,
66		apellido_paterno: str,
67		apellido_materno: str,
68		fecha_nacimiento: date = None,
69		rfc: str = None,
70		curp: str = None,
71		):
72		super().__init__({
73		'Nombre': nombre,
74		'ApellidoPaterno': apellido_paterno,
75		'ApellidoMaterno': apellido_materno,
76		'FechaNacimiento': fecha_nacimiento,
77		'Rfc': rfc,
78		'Curp': curp,
79		})
80
81
82		class TipoPersonaDestinatarioType(ScalarMap):
83		"""
84
85		:param persona_fisica:
86		:param persona_moral:
87		:param fideicomiso:
88		"""
89
90		def __init__(
91		self,
92		persona_fisica: PersonaFisicaDestinatarioType \| dict = None,
93		persona_moral: PersonaMoralDestinatarioType \| dict = None,
94		fideicomiso: FideicomisoDestinatarioType \| dict = None,
95		):
96		super().__init__({
97		'PersonaFisica': persona_fisica,
98		'PersonaMoral': persona_moral,
99		'Fideicomiso': fideicomiso,
100		})
101
102
103		class DestinatarioType(ScalarMap):
104		"""
105
106		:param destinatario_persona_aviso:
107		:param tipo_persona:
108		"""
109
110		def __init__(
111		self,
112		destinatario_persona_aviso: str,
113		tipo_persona: TipoPersonaDestinatarioType \| dict = None,
114		):
115		super().__init__({
116		'DestinatarioPersonaAviso': destinatario_persona_aviso,
117		'TipoPersona': tipo_persona,
118		})
119
120
121		class ExtranjeroEntregaType(ScalarMap):
122		"""
123
124		:param pais:
125		:param estado_provincia:
126		:param ciudad_poblacion:
127		:param codigo_postal:
128		"""
129
130		def __init__(
131		self,
132		pais: str,
133		estado_provincia: str,
134		ciudad_poblacion: str,
135		codigo_postal: str,
136		):
137		super().__init__({
138		'Pais': pais,
139		'EstadoProvincia': estado_provincia,
140		'CiudadPoblacion': ciudad_poblacion,
141		'CodigoPostal': codigo_postal,
142		})
143
144
145		class NacionalEntregaType(ScalarMap):
146		"""
147
148		:param codigo_postal:
149		"""
150
151		def __init__(
152		self,
153		codigo_postal: str,
154		):
155		super().__init__({
156		'CodigoPostal': codigo_postal,
157		})
158
159
160		class TipoEntregaType(ScalarMap):
161		"""
162
163		:param nacional:
164		:param extranjero:
165		"""
166
167		def __init__(
168		self,
169		nacional: NacionalEntregaType \| dict = None,
170		extranjero: ExtranjeroEntregaType \| dict = None,
171		):
172		super().__init__({
173		'Nacional': nacional,
174		'Extranjero': extranjero,
175		})
176
177
178		class EntregaType(ScalarMap):
179		"""
180
181		:param fecha_entrega:
182		:param tipo_entrega:
183		"""
184
185		def __init__(
186		self,
187		fecha_entrega: date,
188		tipo_entrega: TipoEntregaType \| dict,
189		):
190		super().__init__({
191		'FechaEntrega': fecha_entrega,
192		'TipoEntrega': tipo_entrega,
193		})
194
195
196		class DatosNoSucursalType(ScalarMap):
197		"""
198
199		:param colonia:
200		:param calle:
201		:param numero_exterior:
202		:param codigo_postal:
203		:param numero_interior:
204		"""
205
206		def __init__(
207		self,
208		colonia: str,
209		calle: str,
210		numero_exterior: str,
211		codigo_postal: str,
212		numero_interior: str = None,
213		):
214		super().__init__({
215		'Colonia': colonia,
216		'Calle': calle,
217		'NumeroExterior': numero_exterior,
218		'CodigoPostal': codigo_postal,
219		'NumeroInterior': numero_interior,
220		})
221
222
223		class DatosSucursalType(ScalarMap):
224		"""
225
226		:param codigo_postal:
227		"""
228
229		def __init__(
230		self,
231		codigo_postal: str,
232		):
233		super().__init__({
234		'CodigoPostal': codigo_postal,
235		})
236
237
238		class TipoCustodiaType(ScalarMap):
239		"""
240
241		:param datos_sucursal:
242		:param datos_no_sucursal:
243		"""
244
245		def __init__(
246		self,
247		datos_sucursal: DatosSucursalType \| dict = None,
248		datos_no_sucursal: DatosNoSucursalType \| dict = None,
249		):
250		super().__init__({
251		'DatosSucursal': datos_sucursal,
252		'DatosNoSucursal': datos_no_sucursal,
253		})
254
255
256		class CustodiaType(ScalarMap):
257		"""
258
259		:param fecha_inicio:
260		:param fecha_fin:
261		:param tipo_custodia:
262		"""
263
264		def __init__(
265		self,
266		fecha_inicio: date,
267		fecha_fin: date,
268		tipo_custodia: TipoCustodiaType \| dict,
269		):
270		super().__init__({
271		'FechaInicio': fecha_inicio,
272		'FechaFin': fecha_fin,
273		'TipoCustodia': tipo_custodia,
274		})
275
276
277		class RecepcionType(ScalarMap):
278		"""
279
280		:param tipo_servicio:
281		:param fecha_recepcion:
282		:param codigo_postal:
283		"""
284
285		def __init__(
286		self,
287		tipo_servicio: str,
288		fecha_recepcion: date,
289		codigo_postal: str,
290		):
291		super().__init__({
292		'TipoServicio': tipo_servicio,
293		'FechaRecepcion': fecha_recepcion,
294		'CodigoPostal': codigo_postal,
295		})
296
297
298		class DatosValoresType(ScalarMap):
299		"""
300
301		:param tipo_valor:
302		:param valor_objeto:
303		:param descripcion:
304		"""
305
306		def __init__(
307		self,
308		tipo_valor: str,
309		valor_objeto: str,
310		descripcion: str,
311		):
312		super().__init__({
313		'TipoValor': tipo_valor,
314		'ValorObjeto': valor_objeto,
315		'Descripcion': descripcion,
316		})
317
318
319		class DatosEfectivoInstrumentosType(ScalarMap):
320		"""
321
322		:param instrumento_monetario:
323		:param moneda:
324		:param monto_operacion:
325		"""
326
327		def __init__(
328		self,
329		instrumento_monetario: str,
330		moneda: str,
331		monto_operacion: str,
332		):
333		super().__init__({
334		'InstrumentoMonetario': instrumento_monetario,
335		'Moneda': moneda,
336		'MontoOperacion': monto_operacion,
337		})
338
339
340		class TipoBienType(ScalarMap):
341		"""
342
343		:param datos_efectivo_instrumentos:
344		:param datos_valores:
345		"""
346
347		def __init__(
348		self,
349		datos_efectivo_instrumentos: DatosEfectivoInstrumentosType \| dict = None,
350		datos_valores: DatosValoresType \| dict = None,
351		):
352		super().__init__({
353		'DatosEfectivoInstrumentos': datos_efectivo_instrumentos,
354		'DatosValores': datos_valores,
355		})
356
357
358		class DatosOperacionType(ScalarMap):
359		"""
360
361		:param fecha_operacion:
362		:param tipo_operacion:
363		:param tipo_bien:
364		:param recepcion:
365		:param custodia:
366		:param entrega:
367		:param destinatario:
368		"""
369
370		def __init__(
371		self,
372		fecha_operacion: date,
373		tipo_operacion: str,
374		tipo_bien: TipoBienType \| dict \| Sequence[TipoBienType \| dict],
375		recepcion: RecepcionType \| dict = None,
376		custodia: CustodiaType \| dict = None,
377		entrega: EntregaType \| dict = None,
378		destinatario: DestinatarioType \| dict = None,
379		):
380		super().__init__({
381		'FechaOperacion': fecha_operacion,
382		'TipoOperacion': tipo_operacion,
383		'TipoBien': tipo_bien,
384		'Recepcion': recepcion,
385		'Custodia': custodia,
386		'Entrega': entrega,
387		'Destinatario': destinatario,
388		})
389
390
391		class DetalleOperacionesType(ScalarMap):
392		"""
393
394		:param datos_operacion:
395		"""
396
397		def __init__(
398		self,
399		datos_operacion: DatosOperacionType \| dict \| Sequence[DatosOperacionType \| dict],
400		):
401		super().__init__({
402		'DatosOperacion': datos_operacion,
403		})
404
405
406		class FideicomisoSimpleType(ScalarMap):
407		"""
408
409		:param denominacion_razon:
410		:param rfc:
411		:param identificador_fideicomiso:
412		"""
413
414		def __init__(
415		self,
416		denominacion_razon: str,
417		rfc: str = None,
418		identificador_fideicomiso: str = None,
419		):
420		super().__init__({
421		'DenominacionRazon': denominacion_razon,
422		'Rfc': rfc,
423		'IdentificadorFideicomiso': identificador_fideicomiso,
424		})
425
426
427		class PersonaMoralSimpleType(ScalarMap):
428		"""
429
430		:param denominacion_razon:
431		:param fecha_constitucion:
432		:param rfc:
433		:param pais_nacionalidad:
434		"""
435
436		def __init__(
437		self,
438		denominacion_razon: str,
439		fecha_constitucion: date = None,
440		rfc: str = None,
441		pais_nacionalidad: str = None,
442		):
443		super().__init__({
444		'DenominacionRazon': denominacion_razon,
445		'FechaConstitucion': fecha_constitucion,
446		'Rfc': rfc,
447		'PaisNacionalidad': pais_nacionalidad,
448		})
449
450
451		class PersonaFisicaSimpleType(ScalarMap):
452		"""
453
454		:param nombre:
455		:param apellido_paterno:
456		:param apellido_materno:
457		:param fecha_nacimiento:
458		:param rfc:
459		:param curp:
460		:param pais_nacionalidad:
461		"""
462
463		def __init__(
464		self,
465		nombre: str,
466		apellido_paterno: str,
467		apellido_materno: str,
468		fecha_nacimiento: date = None,
469		rfc: str = None,
470		curp: str = None,
471		pais_nacionalidad: str = None,
472		):
473		super().__init__({
474		'Nombre': nombre,
475		'ApellidoPaterno': apellido_paterno,
476		'ApellidoMaterno': apellido_materno,
477		'FechaNacimiento': fecha_nacimiento,
478		'Rfc': rfc,
479		'Curp': curp,
480		'PaisNacionalidad': pais_nacionalidad,
481		})
482
483
484		class TipoPersonaSimpleType(ScalarMap):
485		"""
486
487		:param persona_fisica:
488		:param persona_moral:
489		:param fideicomiso:
490		"""
491
492		def __init__(
493		self,
494		persona_fisica: PersonaFisicaSimpleType \| dict = None,
495		persona_moral: PersonaMoralSimpleType \| dict = None,
496		fideicomiso: FideicomisoSimpleType \| dict = None,
497		):
498		super().__init__({
499		'PersonaFisica': persona_fisica,
500		'PersonaMoral': persona_moral,
501		'Fideicomiso': fideicomiso,
502		})
503
504
505		class DuenoBeneficiarioType(ScalarMap):
506		"""
507
508		:param tipo_persona:
509		"""
510
511		def __init__(
512		self,
513		tipo_persona: TipoPersonaSimpleType \| dict,
514		):
515		super().__init__({
516		'TipoPersona': tipo_persona,
517		})
518
519
520		class TelefonoType(ScalarMap):
521		"""
522
523		:param clave_pais:
524		:param numero_telefono:
525		:param correo_electronico:
526		"""
527
528		def __init__(
529		self,
530		clave_pais: str = None,
531		numero_telefono: str = None,
532		correo_electronico: str = None,
533		):
534		super().__init__({
535		'ClavePais': clave_pais,
536		'NumeroTelefono': numero_telefono,
537		'CorreoElectronico': correo_electronico,
538		})
539
540
541		class ExtranjeroType(ScalarMap):
542		"""
543
544		:param pais:
545		:param estado_provincia:
546		:param ciudad_poblacion:
547		:param colonia:
548		:param calle:
549		:param numero_exterior:
550		:param codigo_postal:
551		:param numero_interior:
552		"""
553
554		def __init__(
555		self,
556		pais: str,
557		estado_provincia: str,
558		ciudad_poblacion: str,
559		colonia: str,
560		calle: str,
561		numero_exterior: str,
562		codigo_postal: str,
563		numero_interior: str = None,
564		):
565		super().__init__({
566		'Pais': pais,
567		'EstadoProvincia': estado_provincia,
568		'CiudadPoblacion': ciudad_poblacion,
569		'Colonia': colonia,
570		'Calle': calle,
571		'NumeroExterior': numero_exterior,
572		'CodigoPostal': codigo_postal,
573		'NumeroInterior': numero_interior,
574		})
575
576
577		class NacionalType(ScalarMap):
578		"""
579
580		:param colonia:
581		:param calle:
582		:param numero_exterior:
583		:param codigo_postal:
584		:param numero_interior:
585		"""
586
587		def __init__(
588		self,
589		colonia: str,
590		calle: str,
591		numero_exterior: str,
592		codigo_postal: str,
593		numero_interior: str = None,
594		):
595		super().__init__({
596		'Colonia': colonia,
597		'Calle': calle,
598		'NumeroExterior': numero_exterior,
599		'CodigoPostal': codigo_postal,
600		'NumeroInterior': numero_interior,
601		})
602
603
604		class TipoDomicilioType(ScalarMap):
605		"""
606
607		:param nacional:
608		:param extranjero:
609		"""
610
611		def __init__(
612		self,
613		nacional: NacionalType \| dict = None,
614		extranjero: ExtranjeroType \| dict = None,
615		):
616		super().__init__({
617		'Nacional': nacional,
618		'Extranjero': extranjero,
619		})
620
621
622		class RepresentanteApoderadoType(ScalarMap):
623		"""
624
625		:param nombre:
626		:param apellido_paterno:
627		:param apellido_materno:
628		:param fecha_nacimiento:
629		:param rfc:
630		:param curp:
631		"""
632
633		def __init__(
634		self,
635		nombre: str,
636		apellido_paterno: str,
637		apellido_materno: str,
638		fecha_nacimiento: date = None,
639		rfc: str = None,
640		curp: str = None,
641		):
642		super().__init__({
643		'Nombre': nombre,
644		'ApellidoPaterno': apellido_paterno,
645		'ApellidoMaterno': apellido_materno,
646		'FechaNacimiento': fecha_nacimiento,
647		'Rfc': rfc,
648		'Curp': curp,
649		})
650
651
652		class FideicomisoType(ScalarMap):
653		"""
654
655		:param denominacion_razon:
656		:param apoderado_delegado:
657		:param rfc:
658		:param identificador_fideicomiso:
659		"""
660
661		def __init__(
662		self,
663		denominacion_razon: str,
664		apoderado_delegado: RepresentanteApoderadoType \| dict,
665		rfc: str = None,
666		identificador_fideicomiso: str = None,
667		):
668		super().__init__({
669		'DenominacionRazon': denominacion_razon,
670		'ApoderadoDelegado': apoderado_delegado,
671		'Rfc': rfc,
672		'IdentificadorFideicomiso': identificador_fideicomiso,
673		})
674
675
676		class PersonaMoralType(ScalarMap):
677		"""
678
679		:param denominacion_razon:
680		:param pais_nacionalidad:
681		:param giro_mercantil:
682		:param representante_apoderado:
683		:param fecha_constitucion:
684		:param rfc:
685		"""
686
687		def __init__(
688		self,
689		denominacion_razon: str,
690		pais_nacionalidad: str,
691		giro_mercantil: str,
692		representante_apoderado: RepresentanteApoderadoType \| dict,
693		fecha_constitucion: date = None,
694		rfc: str = None,
695		):
696		super().__init__({
697		'DenominacionRazon': denominacion_razon,
698		'PaisNacionalidad': pais_nacionalidad,
699		'GiroMercantil': giro_mercantil,
700		'RepresentanteApoderado': representante_apoderado,
701		'FechaConstitucion': fecha_constitucion,
702		'Rfc': rfc,
703		})
704
705
706		class PersonaFisicaType(ScalarMap):
707		"""
708
709		:param nombre:
710		:param apellido_paterno:
711		:param apellido_materno:
712		:param pais_nacionalidad:
713		:param actividad_economica:
714		:param fecha_nacimiento:
715		:param rfc:
716		:param curp:
717		"""
718
719		def __init__(
720		self,
721		nombre: str,
722		apellido_paterno: str,
723		apellido_materno: str,
724		pais_nacionalidad: str,
725		actividad_economica: str,
726		fecha_nacimiento: date = None,
727		rfc: str = None,
728		curp: str = None,
729		):
730		super().__init__({
731		'Nombre': nombre,
732		'ApellidoPaterno': apellido_paterno,
733		'ApellidoMaterno': apellido_materno,
734		'PaisNacionalidad': pais_nacionalidad,
735		'ActividadEconomica': actividad_economica,
736		'FechaNacimiento': fecha_nacimiento,
737		'Rfc': rfc,
738		'Curp': curp,
739		})
740
741
742		class TipoPersonaType(ScalarMap):
743		"""
744
745		:param persona_fisica:
746		:param persona_moral:
747		:param fideicomiso:
748		"""
749
750		def __init__(
751		self,
752		persona_fisica: PersonaFisicaType \| dict = None,
753		persona_moral: PersonaMoralType \| dict = None,
754		fideicomiso: FideicomisoType \| dict = None,
755		):
756		super().__init__({
757		'PersonaFisica': persona_fisica,
758		'PersonaMoral': persona_moral,
759		'Fideicomiso': fideicomiso,
760		})
761
762
763		class PersonaAvisoType(ScalarMap):
764		"""
765
766		:param tipo_persona:
767		:param tipo_domicilio:
768		:param telefono:
769		"""
770
771		def __init__(
772		self,
773		tipo_persona: TipoPersonaType \| dict,
774		tipo_domicilio: TipoDomicilioType \| dict = None,
775		telefono: TelefonoType \| dict = None,
776		):
777		super().__init__({
778		'TipoPersona': tipo_persona,
779		'TipoDomicilio': tipo_domicilio,
780		'Telefono': telefono,
781		})
782
783
784		class AlertaType(ScalarMap):
785		"""
786
787		:param tipo_alerta:
788		:param descripcion_alerta:
789		"""
790
791		def __init__(
792		self,
793		tipo_alerta: str,
794		descripcion_alerta: str = None,
795		):
796		super().__init__({
797		'TipoAlerta': tipo_alerta,
798		'DescripcionAlerta': descripcion_alerta,
799		})
800
801
802		class ModificatorioType(ScalarMap):
803		"""
804
805		:param folio_modificacion:
806		:param descripcion_modificacion:
807		"""
808
809		def __init__(
810		self,
811		folio_modificacion: str,
812		descripcion_modificacion: str,
813		):
814		super().__init__({
815		'FolioModificacion': folio_modificacion,
816		'DescripcionModificacion': descripcion_modificacion,
817		})
818
819
820	View Code Duplication	class AvisoType(ScalarMap):
		0 ignored issues – show Duplication introduced 2022-11-24 01:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
821		"""
822
823		:param referencia_aviso:
824		:param prioridad:
825		:param alerta:
826		:param persona_aviso:
827		:param detalle_operaciones:
828		:param modificatorio:
829		:param dueno_beneficiario:
830		"""
831
832		def __init__(
833		self,
834		referencia_aviso: str,
835		prioridad: str,
836		alerta: AlertaType \| dict,
837		persona_aviso: PersonaAvisoType \| dict \| Sequence[PersonaAvisoType \| dict],
838		detalle_operaciones: DetalleOperacionesType \| dict,
839		modificatorio: ModificatorioType \| dict = None,
840		dueno_beneficiario: DuenoBeneficiarioType \| dict \| Sequence[DuenoBeneficiarioType \| dict] = None,
841		):
842		super().__init__({
843		'ReferenciaAviso': referencia_aviso,
844		'Prioridad': prioridad,
845		'Alerta': alerta,
846		'PersonaAviso': persona_aviso,
847		'DetalleOperaciones': detalle_operaciones,
848		'Modificatorio': modificatorio,
849		'DuenoBeneficiario': dueno_beneficiario,
850		})
851
852
853		class SujetoObligadoType(ScalarMap):
854		"""
855
856		:param clave_sujeto_obligado:
857		:param clave_actividad:
858		:param clave_entidad_colegiada:
859		:param exento:
860		"""
861
862		def __init__(
863		self,
864		clave_sujeto_obligado: str,
865		clave_actividad: str,
866		clave_entidad_colegiada: str = None,
867		exento: str = None,
868		):
869		super().__init__({
870		'ClaveSujetoObligado': clave_sujeto_obligado,
871		'ClaveActividad': clave_actividad,
872		'ClaveEntidadColegiada': clave_entidad_colegiada,
873		'Exento': exento,
874		})
875
876
877	View Code Duplication	class InformeType(ScalarMap):
		0 ignored issues – show Duplication introduced 2022-11-24 01:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
878		"""
879
880		:param mes_reportado:
881		:param sujeto_obligado:
882		:param aviso:
883		"""
884
885		def __init__(
886		self,
887		mes_reportado: str,
888		sujeto_obligado: SujetoObligadoType \| dict,
889		aviso: AvisoType \| dict \| Sequence[AvisoType \| dict] = None,
890		):
891		super().__init__({
892		'MesReportado': mes_reportado,
893		'SujetoObligado': sujeto_obligado,
894		'Aviso': aviso,
895		})
896
897
898		class ArchivoType(ScalarMap):
899		"""
900
901		:param informe:
902		"""
903
904		def __init__(
905		self,
906		informe: InformeType \| dict \| Sequence[InformeType \| dict],
907		):
908		super().__init__({
909		'Informe': informe,
910		})
911
912
913		class Archivo(ArchivoType, XElement):
914		tag = '{http://www.uif.shcp.gob.mx/recepcion/tcv}archivo'
915
916

SAT-CFDI / python-satcfdi

satcfdi.create.pld.tcv A last analyzed 2025-06-07 00:41 UTC

Complexity

Size/Duplication

Importance

40 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complexity

Duplication Side-by-Side

Filter issues like

satcfdi.create.pld.tcv A
last analyzed 2025-06-07 00:41 UTC