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

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

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	603
Duplicated Lines	7.96 %

Importance

Changes

Metric	Value
eloc	303
dl	48
loc	603
rs	10
c	0
b	0
f	0
wmc	25

25 Methods

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

How to fix Duplicated Code

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

class DatosChequeType(ScalarMap):
    """
    
    :param numero_cheques:
    :param moneda_cheques:
    """
    
    def __init__(
            self,
            numero_cheques: str,
            moneda_cheques: str,
    ): 
        super().__init__({
            'NumeroCheques': numero_cheques,
            'MonedaCheques': moneda_cheques,
        })
        

class DatosOperacionType(ScalarMap):
    """
    
    :param fecha_operacion:
    :param codigo_postal:
    :param tipo_operacion:
    :param datos_cheque:
    :param datos_liquidacion:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            codigo_postal: str,
            tipo_operacion: str,
            datos_cheque: DatosChequeType | dict | Sequence[DatosChequeType | dict],
            datos_liquidacion: DatosLiquidacionType | dict | Sequence[DatosLiquidacionType | dict],
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'CodigoPostal': codigo_postal,
            'TipoOperacion': tipo_operacion,
            'DatosCheque': datos_cheque,
            '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/chv}archivo'



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

SAT-CFDI / python-satcfdi

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

Complexity

Size/Duplication

Importance

25 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like

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