Issues in bli.py (main) - Issues in main - SAT-CFDI/python-satcfdi - Measure and Improve Code Quality continuously with Scrutinizer

Issues (158)

satcfdi/create/pld/bli.py (2 issues)

Labels

Duplication 2

Severity

Informational 2

"""bli http://www.uif.shcp.gob.mx/recepcion/bli"""
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 DatosParteBlindadaType(ScalarMap):
    """
    
    :param parte_blindada:
    :param nivel_blindaje:
    """
    
    def __init__(
            self,
            parte_blindada: str,
            nivel_blindaje: str,
    ): 
        super().__init__({
            'ParteBlindada': parte_blindada,
            'NivelBlindaje': nivel_blindaje,
        })
        

class DatosInmuebleType(ScalarMap):
    """
    
    :param tipo_inmueble:
    :param codigo_postal:
    :param datos_parte_blindada:
    """
    
    def __init__(
            self,
            tipo_inmueble: str,
            codigo_postal: str,
            datos_parte_blindada: DatosParteBlindadaType | dict | Sequence[DatosParteBlindadaType | dict],
    ): 
        super().__init__({
            'TipoInmueble': tipo_inmueble,
            'CodigoPostal': codigo_postal,
            'DatosParteBlindada': datos_parte_blindada,
        })
        

class DatosVehiculoTerrestreType(ScalarMap):
    """
    
    :param marca_fabricante:
    :param modelo:
    :param anio:
    :param estado_bien:
    :param nivel_blindaje:
    :param vin:
    :param repuve:
    :param placas:
    """
    
    def __init__(
            self,
            marca_fabricante: str,
            modelo: str,
            anio: str,
            estado_bien: str,
            nivel_blindaje: str,
            vin: str = None,
            repuve: str = None,
            placas: str = None,
    ): 
        super().__init__({
            'MarcaFabricante': marca_fabricante,
            'Modelo': modelo,
            'Anio': anio,
            'EstadoBien': estado_bien,
            'NivelBlindaje': nivel_blindaje,
            'Vin': vin,
            'Repuve': repuve,
            'Placas': placas,
        })
        

class TipoBienType(ScalarMap):
    """
    
    :param datos_vehiculo_terrestre:
    :param datos_inmueble:
    """
    
    def __init__(
            self,
            datos_vehiculo_terrestre: DatosVehiculoTerrestreType | dict = None,
            datos_inmueble: DatosInmuebleType | dict = None,
    ): 
        super().__init__({
            'DatosVehiculoTerrestre': datos_vehiculo_terrestre,
            'DatosInmueble': datos_inmueble,
        })
        

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



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

SAT-CFDI / python-satcfdi

Issues (158)

satcfdi/create/pld/bli.py (2 issues)

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like