satcfdi.create.pld.ari - Code Metrics - Inspection of "Fixed dependency issue" - SAT-CFDI/python-satcfdi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( c89de9...8b8d32 )

by Sat CFDI

created 2023-06-27 18:07 UTC

satcfdi.create.pld.ari A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	627
Duplicated Lines	7.66 %

Test Coverage

Coverage

86.75%

Importance

Changes

Metric	Value
eloc	319
dl	48
loc	627
ccs	72
cts	83
cp	0.8675
rs	10
c	0
b	0
f	0
wmc	25

25 Methods

Rating	Name	Duplication	Size	Complexity
A	DatosLiquidacionType.__init__()	0	14	1
A	DatosOperacionType.__init__()	0	12	1
A	PersonaMoralSimpleType.__init__()	0	12	1
A	ExtranjeroType.__init__()	0	20	1
A	PersonaFisicaSimpleType.__init__()	0	18	1
A	PersonaFisicaType.__init__()	0	20	1
A	FideicomisoSimpleType.__init__()	0	10	1
A	ModificatorioType.__init__()	0	8	1
A	PersonaMoralType.__init__()	0	16	1
A	TipoPersonaType.__init__()	0	10	1
A	PersonaAvisoType.__init__()	0	10	1
A	NacionalType.__init__()	0	14	1
A	SujetoObligadoType.__init__()	0	12	1
A	RepresentanteApoderadoType.__init__()	0	16	1
A	DetalleOperacionesType.__init__()	0	6	1
A	TelefonoType.__init__()	0	10	1
A	DuenoBeneficiarioType.__init__()	0	6	1
A	FideicomisoType.__init__()	0	12	1
A	AvisoType.__init__()	18	18	1
A	ArchivoType.__init__()	0	6	1
A	AlertaType.__init__()	0	8	1
A	TipoPersonaSimpleType.__init__()	0	10	1
A	CaracteristicasType.__init__()	0	24	1
A	InformeType.__init__()	10	10	1
A	TipoDomicilioType.__init__()	0	8	1

How to fix Duplicated Code

"""ari http://www.uif.shcp.gob.mx/recepcion/ari"""
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 DatosLiquidacionType(ScalarMap):
    """
    
    :param fecha_pago:
    :param forma_pago:
    :param instrumento_monetario:
    :param moneda:
    :param monto_operacion:
    """
    
    def __init__(
            self,
            fecha_pago: date,
            forma_pago: str,
            instrumento_monetario: str,
            moneda: str,
            monto_operacion: str,
    ): 
        super().__init__({
            'FechaPago': fecha_pago,
            'FormaPago': forma_pago,
            'InstrumentoMonetario': instrumento_monetario,
            'Moneda': moneda,
            'MontoOperacion': monto_operacion,
        })
        

class CaracteristicasType(ScalarMap):
    """
    
    :param fecha_inicio:
    :param fecha_termino:
    :param tipo_inmueble:
    :param valor_referencia:
    :param colonia:
    :param calle:
    :param numero_exterior:
    :param codigo_postal:
    :param folio_real:
    :param numero_interior:
    """
    
    def __init__(
            self,
            fecha_inicio: date,
            fecha_termino: date,
            tipo_inmueble: str,
            valor_referencia: str,
            colonia: str,
            calle: str,
            numero_exterior: str,
            codigo_postal: str,
            folio_real: str,
            numero_interior: str = None,
    ): 
        super().__init__({
            'FechaInicio': fecha_inicio,
            'FechaTermino': fecha_termino,
            'TipoInmueble': tipo_inmueble,
            'ValorReferencia': valor_referencia,
            'Colonia': colonia,
            'Calle': calle,
            'NumeroExterior': numero_exterior,
            'CodigoPostal': codigo_postal,
            'FolioReal': folio_real,
            'NumeroInterior': numero_interior,
        })
        

class DatosOperacionType(ScalarMap):
    """
    
    :param fecha_operacion:
    :param tipo_operacion:
    :param caracteristicas:
    :param datos_liquidacion:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            tipo_operacion: str,
            caracteristicas: CaracteristicasType | dict | Sequence[CaracteristicasType | dict],
            datos_liquidacion: DatosLiquidacionType | dict | Sequence[DatosLiquidacionType | dict],
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'TipoOperacion': tipo_operacion,
            'Caracteristicas': caracteristicas,
            'DatosLiquidacion': datos_liquidacion,
        })
        

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/ari}archivo'



1			"""ari http://www.uif.shcp.gob.mx/recepcion/ari"""
2	1		from decimal import Decimal
3	1		from datetime import datetime, date, time
4	1		from collections.abc import Sequence
5	1		from ...cfdi import CFDI
6	1		from ...xelement import XElement
7	1		from ...utils import ScalarMap
8
9
10	1		class DatosLiquidacionType(ScalarMap):
11			"""
12
13			:param fecha_pago:
14			:param forma_pago:
15			:param instrumento_monetario:
16			:param moneda:
17			:param monto_operacion:
18			"""
19
20	1		def __init__(
21			self,
22			fecha_pago: date,
23			forma_pago: str,
24			instrumento_monetario: str,
25			moneda: str,
26			monto_operacion: str,
27			):
28	1		super().__init__({
29			'FechaPago': fecha_pago,
30			'FormaPago': forma_pago,
31			'InstrumentoMonetario': instrumento_monetario,
32			'Moneda': moneda,
33			'MontoOperacion': monto_operacion,
34			})
35
36
37	1		class CaracteristicasType(ScalarMap):
38			"""
39
40			:param fecha_inicio:
41			:param fecha_termino:
42			:param tipo_inmueble:
43			:param valor_referencia:
44			:param colonia:
45			:param calle:
46			:param numero_exterior:
47			:param codigo_postal:
48			:param folio_real:
49			:param numero_interior:
50			"""
51
52	1		def __init__(
53			self,
54			fecha_inicio: date,
55			fecha_termino: date,
56			tipo_inmueble: str,
57			valor_referencia: str,
58			colonia: str,
59			calle: str,
60			numero_exterior: str,
61			codigo_postal: str,
62			folio_real: str,
63			numero_interior: str = None,
64			):
65	1		super().__init__({
66			'FechaInicio': fecha_inicio,
67			'FechaTermino': fecha_termino,
68			'TipoInmueble': tipo_inmueble,
69			'ValorReferencia': valor_referencia,
70			'Colonia': colonia,
71			'Calle': calle,
72			'NumeroExterior': numero_exterior,
73			'CodigoPostal': codigo_postal,
74			'FolioReal': folio_real,
75			'NumeroInterior': numero_interior,
76			})
77
78
79	1		class DatosOperacionType(ScalarMap):
80			"""
81
82			:param fecha_operacion:
83			:param tipo_operacion:
84			:param caracteristicas:
85			:param datos_liquidacion:
86			"""
87
88	1		def __init__(
89			self,
90			fecha_operacion: date,
91			tipo_operacion: str,
92			caracteristicas: CaracteristicasType \| dict \| Sequence[CaracteristicasType \| dict],
93			datos_liquidacion: DatosLiquidacionType \| dict \| Sequence[DatosLiquidacionType \| dict],
94			):
95	1		super().__init__({
96			'FechaOperacion': fecha_operacion,
97			'TipoOperacion': tipo_operacion,
98			'Caracteristicas': caracteristicas,
99			'DatosLiquidacion': datos_liquidacion,
100			})
101
102
103	1		class DetalleOperacionesType(ScalarMap):
104			"""
105
106			:param datos_operacion:
107			"""
108
109	1		def __init__(
110			self,
111			datos_operacion: DatosOperacionType \| dict \| Sequence[DatosOperacionType \| dict],
112			):
113	1		super().__init__({
114			'DatosOperacion': datos_operacion,
115			})
116
117
118	1		class FideicomisoSimpleType(ScalarMap):
119			"""
120
121			:param denominacion_razon:
122			:param rfc:
123			:param identificador_fideicomiso:
124			"""
125
126	1		def __init__(
127			self,
128			denominacion_razon: str,
129			rfc: str = None,
130			identificador_fideicomiso: str = None,
131			):
132			super().__init__({
133			'DenominacionRazon': denominacion_razon,
134			'Rfc': rfc,
135			'IdentificadorFideicomiso': identificador_fideicomiso,
136			})
137
138
139	1		class PersonaMoralSimpleType(ScalarMap):
140			"""
141
142			:param denominacion_razon:
143			:param fecha_constitucion:
144			:param rfc:
145			:param pais_nacionalidad:
146			"""
147
148	1		def __init__(
149			self,
150			denominacion_razon: str,
151			fecha_constitucion: date = None,
152			rfc: str = None,
153			pais_nacionalidad: str = None,
154			):
155			super().__init__({
156			'DenominacionRazon': denominacion_razon,
157			'FechaConstitucion': fecha_constitucion,
158			'Rfc': rfc,
159			'PaisNacionalidad': pais_nacionalidad,
160			})
161
162
163	1		class PersonaFisicaSimpleType(ScalarMap):
164			"""
165
166			:param nombre:
167			:param apellido_paterno:
168			:param apellido_materno:
169			:param fecha_nacimiento:
170			:param rfc:
171			:param curp:
172			:param pais_nacionalidad:
173			"""
174
175	1		def __init__(
176			self,
177			nombre: str,
178			apellido_paterno: str,
179			apellido_materno: str,
180			fecha_nacimiento: date = None,
181			rfc: str = None,
182			curp: str = None,
183			pais_nacionalidad: str = None,
184			):
185			super().__init__({
186			'Nombre': nombre,
187			'ApellidoPaterno': apellido_paterno,
188			'ApellidoMaterno': apellido_materno,
189			'FechaNacimiento': fecha_nacimiento,
190			'Rfc': rfc,
191			'Curp': curp,
192			'PaisNacionalidad': pais_nacionalidad,
193			})
194
195
196	1		class TipoPersonaSimpleType(ScalarMap):
197			"""
198
199			:param persona_fisica:
200			:param persona_moral:
201			:param fideicomiso:
202			"""
203
204	1		def __init__(
205			self,
206			persona_fisica: PersonaFisicaSimpleType \| dict = None,
207			persona_moral: PersonaMoralSimpleType \| dict = None,
208			fideicomiso: FideicomisoSimpleType \| dict = None,
209			):
210			super().__init__({
211			'PersonaFisica': persona_fisica,
212			'PersonaMoral': persona_moral,
213			'Fideicomiso': fideicomiso,
214			})
215
216
217	1		class DuenoBeneficiarioType(ScalarMap):
218			"""
219
220			:param tipo_persona:
221			"""
222
223	1		def __init__(
224			self,
225			tipo_persona: TipoPersonaSimpleType \| dict,
226			):
227			super().__init__({
228			'TipoPersona': tipo_persona,
229			})
230
231
232	1		class TelefonoType(ScalarMap):
233			"""
234
235			:param clave_pais:
236			:param numero_telefono:
237			:param correo_electronico:
238			"""
239
240	1		def __init__(
241			self,
242			clave_pais: str = None,
243			numero_telefono: str = None,
244			correo_electronico: str = None,
245			):
246			super().__init__({
247			'ClavePais': clave_pais,
248			'NumeroTelefono': numero_telefono,
249			'CorreoElectronico': correo_electronico,
250			})
251
252
253	1		class ExtranjeroType(ScalarMap):
254			"""
255
256			:param pais:
257			:param estado_provincia:
258			:param ciudad_poblacion:
259			:param colonia:
260			:param calle:
261			:param numero_exterior:
262			:param codigo_postal:
263			:param numero_interior:
264			"""
265
266	1		def __init__(
267			self,
268			pais: str,
269			estado_provincia: str,
270			ciudad_poblacion: str,
271			colonia: str,
272			calle: str,
273			numero_exterior: str,
274			codigo_postal: str,
275			numero_interior: str = None,
276			):
277	1		super().__init__({
278			'Pais': pais,
279			'EstadoProvincia': estado_provincia,
280			'CiudadPoblacion': ciudad_poblacion,
281			'Colonia': colonia,
282			'Calle': calle,
283			'NumeroExterior': numero_exterior,
284			'CodigoPostal': codigo_postal,
285			'NumeroInterior': numero_interior,
286			})
287
288
289	1		class NacionalType(ScalarMap):
290			"""
291
292			:param colonia:
293			:param calle:
294			:param numero_exterior:
295			:param codigo_postal:
296			:param numero_interior:
297			"""
298
299	1		def __init__(
300			self,
301			colonia: str,
302			calle: str,
303			numero_exterior: str,
304			codigo_postal: str,
305			numero_interior: str = None,
306			):
307			super().__init__({
308			'Colonia': colonia,
309			'Calle': calle,
310			'NumeroExterior': numero_exterior,
311			'CodigoPostal': codigo_postal,
312			'NumeroInterior': numero_interior,
313			})
314
315
316	1		class TipoDomicilioType(ScalarMap):
317			"""
318
319			:param nacional:
320			:param extranjero:
321			"""
322
323	1		def __init__(
324			self,
325			nacional: NacionalType \| dict = None,
326			extranjero: ExtranjeroType \| dict = None,
327			):
328	1		super().__init__({
329			'Nacional': nacional,
330			'Extranjero': extranjero,
331			})
332
333
334	1		class RepresentanteApoderadoType(ScalarMap):
335			"""
336
337			:param nombre:
338			:param apellido_paterno:
339			:param apellido_materno:
340			:param fecha_nacimiento:
341			:param rfc:
342			:param curp:
343			"""
344
345	1		def __init__(
346			self,
347			nombre: str,
348			apellido_paterno: str,
349			apellido_materno: str,
350			fecha_nacimiento: date = None,
351			rfc: str = None,
352			curp: str = None,
353			):
354			super().__init__({
355			'Nombre': nombre,
356			'ApellidoPaterno': apellido_paterno,
357			'ApellidoMaterno': apellido_materno,
358			'FechaNacimiento': fecha_nacimiento,
359			'Rfc': rfc,
360			'Curp': curp,
361			})
362
363
364	1		class FideicomisoType(ScalarMap):
365			"""
366
367			:param denominacion_razon:
368			:param apoderado_delegado:
369			:param rfc:
370			:param identificador_fideicomiso:
371			"""
372
373	1		def __init__(
374			self,
375			denominacion_razon: str,
376			apoderado_delegado: RepresentanteApoderadoType \| dict,
377			rfc: str = None,
378			identificador_fideicomiso: str = None,
379			):
380			super().__init__({
381			'DenominacionRazon': denominacion_razon,
382			'ApoderadoDelegado': apoderado_delegado,
383			'Rfc': rfc,
384			'IdentificadorFideicomiso': identificador_fideicomiso,
385			})
386
387
388	1		class PersonaMoralType(ScalarMap):
389			"""
390
391			:param denominacion_razon:
392			:param pais_nacionalidad:
393			:param giro_mercantil:
394			:param representante_apoderado:
395			:param fecha_constitucion:
396			:param rfc:
397			"""
398
399	1		def __init__(
400			self,
401			denominacion_razon: str,
402			pais_nacionalidad: str,
403			giro_mercantil: str,
404			representante_apoderado: RepresentanteApoderadoType \| dict,
405			fecha_constitucion: date = None,
406			rfc: str = None,
407			):
408			super().__init__({
409			'DenominacionRazon': denominacion_razon,
410			'PaisNacionalidad': pais_nacionalidad,
411			'GiroMercantil': giro_mercantil,
412			'RepresentanteApoderado': representante_apoderado,
413			'FechaConstitucion': fecha_constitucion,
414			'Rfc': rfc,
415			})
416
417
418	1		class PersonaFisicaType(ScalarMap):
419			"""
420
421			:param nombre:
422			:param apellido_paterno:
423			:param apellido_materno:
424			:param pais_nacionalidad:
425			:param actividad_economica:
426			:param fecha_nacimiento:
427			:param rfc:
428			:param curp:
429			"""
430
431	1		def __init__(
432			self,
433			nombre: str,
434			apellido_paterno: str,
435			apellido_materno: str,
436			pais_nacionalidad: str,
437			actividad_economica: str,
438			fecha_nacimiento: date = None,
439			rfc: str = None,
440			curp: str = None,
441			):
442	1		super().__init__({
443			'Nombre': nombre,
444			'ApellidoPaterno': apellido_paterno,
445			'ApellidoMaterno': apellido_materno,
446			'PaisNacionalidad': pais_nacionalidad,
447			'ActividadEconomica': actividad_economica,
448			'FechaNacimiento': fecha_nacimiento,
449			'Rfc': rfc,
450			'Curp': curp,
451			})
452
453
454	1		class TipoPersonaType(ScalarMap):
455			"""
456
457			:param persona_fisica:
458			:param persona_moral:
459			:param fideicomiso:
460			"""
461
462	1		def __init__(
463			self,
464			persona_fisica: PersonaFisicaType \| dict = None,
465			persona_moral: PersonaMoralType \| dict = None,
466			fideicomiso: FideicomisoType \| dict = None,
467			):
468	1		super().__init__({
469			'PersonaFisica': persona_fisica,
470			'PersonaMoral': persona_moral,
471			'Fideicomiso': fideicomiso,
472			})
473
474
475	1		class PersonaAvisoType(ScalarMap):
476			"""
477
478			:param tipo_persona:
479			:param tipo_domicilio:
480			:param telefono:
481			"""
482
483	1		def __init__(
484			self,
485			tipo_persona: TipoPersonaType \| dict,
486			tipo_domicilio: TipoDomicilioType \| dict = None,
487			telefono: TelefonoType \| dict = None,
488			):
489	1		super().__init__({
490			'TipoPersona': tipo_persona,
491			'TipoDomicilio': tipo_domicilio,
492			'Telefono': telefono,
493			})
494
495
496	1		class AlertaType(ScalarMap):
497			"""
498
499			:param tipo_alerta:
500			:param descripcion_alerta:
501			"""
502
503	1		def __init__(
504			self,
505			tipo_alerta: str,
506			descripcion_alerta: str = None,
507			):
508	1		super().__init__({
509			'TipoAlerta': tipo_alerta,
510			'DescripcionAlerta': descripcion_alerta,
511			})
512
513
514	1		class ModificatorioType(ScalarMap):
515			"""
516
517			:param folio_modificacion:
518			:param descripcion_modificacion:
519			"""
520
521	1		def __init__(
522			self,
523			folio_modificacion: str,
524			descripcion_modificacion: str,
525			):
526			super().__init__({
527			'FolioModificacion': folio_modificacion,
528			'DescripcionModificacion': descripcion_modificacion,
529			})
530
531
532	1	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...
533			"""
534
535			:param referencia_aviso:
536			:param prioridad:
537			:param alerta:
538			:param persona_aviso:
539			:param detalle_operaciones:
540			:param modificatorio:
541			:param dueno_beneficiario:
542			"""
543
544	1		def __init__(
545			self,
546			referencia_aviso: str,
547			prioridad: str,
548			alerta: AlertaType \| dict,
549			persona_aviso: PersonaAvisoType \| dict \| Sequence[PersonaAvisoType \| dict],
550			detalle_operaciones: DetalleOperacionesType \| dict,
551			modificatorio: ModificatorioType \| dict = None,
552			dueno_beneficiario: DuenoBeneficiarioType \| dict \| Sequence[DuenoBeneficiarioType \| dict] = None,
553			):
554	1		super().__init__({
555			'ReferenciaAviso': referencia_aviso,
556			'Prioridad': prioridad,
557			'Alerta': alerta,
558			'PersonaAviso': persona_aviso,
559			'DetalleOperaciones': detalle_operaciones,
560			'Modificatorio': modificatorio,
561			'DuenoBeneficiario': dueno_beneficiario,
562			})
563
564
565	1		class SujetoObligadoType(ScalarMap):
566			"""
567
568			:param clave_sujeto_obligado:
569			:param clave_actividad:
570			:param clave_entidad_colegiada:
571			:param exento:
572			"""
573
574	1		def __init__(
575			self,
576			clave_sujeto_obligado: str,
577			clave_actividad: str,
578			clave_entidad_colegiada: str = None,
579			exento: str = None,
580			):
581	1		super().__init__({
582			'ClaveSujetoObligado': clave_sujeto_obligado,
583			'ClaveActividad': clave_actividad,
584			'ClaveEntidadColegiada': clave_entidad_colegiada,
585			'Exento': exento,
586			})
587
588
589	1	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...
590			"""
591
592			:param mes_reportado:
593			:param sujeto_obligado:
594			:param aviso:
595			"""
596
597	1		def __init__(
598			self,
599			mes_reportado: str,
600			sujeto_obligado: SujetoObligadoType \| dict,
601			aviso: AvisoType \| dict \| Sequence[AvisoType \| dict] = None,
602			):
603	1		super().__init__({
604			'MesReportado': mes_reportado,
605			'SujetoObligado': sujeto_obligado,
606			'Aviso': aviso,
607			})
608
609
610	1		class ArchivoType(ScalarMap):
611			"""
612
613			:param informe:
614			"""
615
616	1		def __init__(
617			self,
618			informe: InformeType \| dict \| Sequence[InformeType \| dict],
619			):
620	1		super().__init__({
621			'Informe': informe,
622			})
623
624
625	1		class Archivo(ArchivoType, XElement):
626	1		tag = '{http://www.uif.shcp.gob.mx/recepcion/ari}archivo'
627
628

SAT-CFDI / python-satcfdi

Push — main ( c89de9...8b8d32 )

satcfdi.create.pld.ari A

Complexity

Size/Duplication

Test Coverage

Importance

25 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like