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

Issues (158)

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

Labels

Duplication 2

Severity

Informational 2

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

class FideicomisoGaranteType(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 PersonaMoralGaranteType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param fecha_constitucion:
    :param rfc:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            fecha_constitucion: date = None,
            rfc: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'FechaConstitucion': fecha_constitucion,
            'Rfc': rfc,
        })
        

class PersonaFisicaGaranteType(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 TipoGaranteType(ScalarMap):
    """
    
    :param persona_fisica:
    :param persona_moral:
    :param fideicomiso:
    """
    
    def __init__(
            self,
            persona_fisica: PersonaFisicaGaranteType | dict = None,
            persona_moral: PersonaMoralGaranteType | dict = None,
            fideicomiso: FideicomisoGaranteType | dict = None,
    ): 
        super().__init__({
            'PersonaFisica': persona_fisica,
            'PersonaMoral': persona_moral,
            'Fideicomiso': fideicomiso,
        })
        

class DatosOtroType(ScalarMap):
    """
    
    :param descripcion_garantia:
    """
    
    def __init__(
            self,
            descripcion_garantia: str,
    ): 
        super().__init__({
            'DescripcionGarantia': descripcion_garantia,
        })
        

class DatosInmuebleType(ScalarMap):
    """
    
    :param tipo_inmueble:
    :param valor_referencia:
    :param codigo_postal:
    :param folio_real:
    """
    
    def __init__(
            self,
            tipo_inmueble: str,
            valor_referencia: str,
            codigo_postal: str,
            folio_real: str,
    ): 
        super().__init__({
            'TipoInmueble': tipo_inmueble,
            'ValorReferencia': valor_referencia,
            'CodigoPostal': codigo_postal,
            'FolioReal': folio_real,
        })
        

class DatosBienMutuoType(ScalarMap):
    """
    
    :param datos_inmueble:
    :param datos_otro:
    """
    
    def __init__(
            self,
            datos_inmueble: DatosInmuebleType | dict = None,
            datos_otro: DatosOtroType | dict = None,
    ): 
        super().__init__({
            'DatosInmueble': datos_inmueble,
            'DatosOtro': datos_otro,
        })
        

class DatosGarantiaType(ScalarMap):
    """
    
    :param tipo_garantia:
    :param datos_bien_mutuo:
    :param tipo_persona:
    """
    
    def __init__(
            self,
            tipo_garantia: str,
            datos_bien_mutuo: DatosBienMutuoType | dict = None,
            tipo_persona: TipoGaranteType | dict = None,
    ): 
        super().__init__({
            'TipoGarantia': tipo_garantia,
            'DatosBienMutuo': datos_bien_mutuo,
            'TipoPersona': tipo_persona,
        })
        

class DatosOperacionType(ScalarMap):
    """
    
    :param fecha_operacion:
    :param codigo_postal:
    :param tipo_operacion:
    :param datos_liquidacion:
    :param datos_garantia:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            codigo_postal: str,
            tipo_operacion: str,
            datos_liquidacion: DatosLiquidacionType | dict | Sequence[DatosLiquidacionType | dict],
            datos_garantia: DatosGarantiaType | dict | Sequence[DatosGarantiaType | dict] = None,
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'CodigoPostal': codigo_postal,
            'TipoOperacion': tipo_operacion,
            'DatosLiquidacion': datos_liquidacion,
            'DatosGarantia': datos_garantia,
        })
        

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



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

SAT-CFDI / python-satcfdi

Issues (158)

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

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like