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

Issues (158)

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

Labels

Duplication 2

Severity

Informational 2

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


class DatosLiquidacionType(ScalarMap):
    """
    
    :param fecha_pago:
    :param forma_pago:
    :param moneda:
    :param monto_operacion:
    :param instrumento_monetario:
    """
    
    def __init__(
            self,
            fecha_pago: date,
            forma_pago: str,
            moneda: str,
            monto_operacion: str,
            instrumento_monetario: str = None,
    ): 
        super().__init__({
            'FechaPago': fecha_pago,
            'FormaPago': forma_pago,
            'Moneda': moneda,
            'MontoOperacion': monto_operacion,
            'InstrumentoMonetario': instrumento_monetario,
        })
        

class DatosContratoType(ScalarMap):
    """
    
    :param fecha_contrato:
    """
    
    def __init__(
            self,
            fecha_contrato: date,
    ): 
        super().__init__({
            'FechaContrato': fecha_contrato,
        })
        

class DatosInstrumentoType(ScalarMap):
    """
    
    :param numero_instrumento_publico:
    :param fecha_instrumento_publico:
    :param notario_instrumento_publico:
    :param entidad_instrumento_publico:
    :param valor_avaluo_catastral:
    """
    
    def __init__(
            self,
            numero_instrumento_publico: str,
            fecha_instrumento_publico: date,
            notario_instrumento_publico: str,
            entidad_instrumento_publico: str,
            valor_avaluo_catastral: str,
    ): 
        super().__init__({
            'NumeroInstrumentoPublico': numero_instrumento_publico,
            'FechaInstrumentoPublico': fecha_instrumento_publico,
            'NotarioInstrumentoPublico': notario_instrumento_publico,
            'EntidadInstrumentoPublico': entidad_instrumento_publico,
            'ValorAvaluoCatastral': valor_avaluo_catastral,
        })
        

class ContratoInstrumentoType(ScalarMap):
    """
    
    :param datos_instrumento_publico:
    :param datos_contrato:
    """
    
    def __init__(
            self,
            datos_instrumento_publico: DatosInstrumentoType | dict = None,
            datos_contrato: DatosContratoType | dict = None,
    ): 
        super().__init__({
            'DatosInstrumentoPublico': datos_instrumento_publico,
            'DatosContrato': datos_contrato,
        })
        

class CaracteristicasInmuebleType(ScalarMap):
    """
    
    :param tipo_inmueble:
    :param valor_pactado:
    :param colonia:
    :param calle:
    :param numero_exterior:
    :param codigo_postal:
    :param dimension_terreno:
    :param dimension_construido:
    :param folio_real:
    :param numero_interior:
    """
    
    def __init__(
            self,
            tipo_inmueble: str,
            valor_pactado: str,
            colonia: str,
            calle: str,
            numero_exterior: str,
            codigo_postal: str,
            dimension_terreno: str,
            dimension_construido: str,
            folio_real: str,
            numero_interior: str = None,
    ): 
        super().__init__({
            'TipoInmueble': tipo_inmueble,
            'ValorPactado': valor_pactado,
            'Colonia': colonia,
            'Calle': calle,
            'NumeroExterior': numero_exterior,
            'CodigoPostal': codigo_postal,
            'DimensionTerreno': dimension_terreno,
            'DimensionConstruido': dimension_construido,
            'FolioReal': folio_real,
            'NumeroInterior': numero_interior,
        })
        

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

class DatosOperacionType(ScalarMap):
    """
    
    :param fecha_operacion:
    :param tipo_operacion:
    :param figura_cliente:
    :param figura_so:
    :param caracteristicas_inmueble:
    :param contrato_instrumento_publico:
    :param datos_contraparte:
    :param datos_liquidacion:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            tipo_operacion: str,
            figura_cliente: str,
            figura_so: str,
            caracteristicas_inmueble: CaracteristicasInmuebleType | dict | Sequence[CaracteristicasInmuebleType | dict],
            contrato_instrumento_publico: ContratoInstrumentoType | dict,
            datos_contraparte: DatosContraparteType | dict | Sequence[DatosContraparteType | dict] = None,
            datos_liquidacion: DatosLiquidacionType | dict | Sequence[DatosLiquidacionType | dict] = None,
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'TipoOperacion': tipo_operacion,
            'FiguraCliente': figura_cliente,
            'FiguraSo': figura_so,
            'CaracteristicasInmueble': caracteristicas_inmueble,
            'ContratoInstrumentoPublico': contrato_instrumento_publico,
            'DatosContraparte': datos_contraparte,
            '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/inm}archivo'



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

SAT-CFDI / python-satcfdi

Issues (158)

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

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like