Metadata-Version: 2.1
Name: divinegift
Version: 0.9.2
Summary: It is a Divine Gift
Home-page: https://github.com/Malanris/DivineGift.git
Author: Malanris
Author-email: admin@malanris.ru
License: MIT
Description: **The most useful package for you, young s7_it programer :)**
        
        # How to use it
        
        ## logging
        
        ```
        # Import necessary functions
        from divinegift.logger import log_info, log_err, log_warning, set_loglevel
        
        # info msg
        log_info('Your message')
        
        # error msg 
        log_err('Error msg',
        	    src='Error source',  # e.g. str(sys.argv[0])
        	    mode=['telegram', 'email']  # May be empty
        	    channel={ "telegram": -1001343660695, "email_to": ["youremail@s7.ru"]})  # You can add "email_cc" for add copy_to address
        
        # error msg with out sending problem to external system
        log_err('Error msg', src='Error src') 
        ```
        
        ## Pass log_level and log_name through cmd arguments
        
        To specify log_level and log_name to your app you can send it through arguments:
        ```
        if __name__ == '__main__':
        	# Get all args from cmd:
            args = get_args()
            # Get log_level and log_name:
            log_level, log_name = get_log_param(args)
            # Set log_level and log_name:
            set_loglevel(log_level, log_name)
        ```
        You should pass your args by pairs: key value, e.g. --log_level INFO
        Available variants for logging are:
        * --log_level or shortcut is -ll
        * --log_name or shortcut is -ln
        
        log_level could be DEBUG, INFO, WARNING, ERROR
        
        Example of start apps with arguments:
        ```
        python test.py -ll INFO -ln test.log
        ```
        
        ## Config parsing (json)
        
        ```
        from divinegift.smain import Settings  # Necessary imports
         
        settings = {} 
        
        # You should use divinegift.logger.set_loglevel before config parsing
        s = Settings()
        s.parse_settings('./settings.conf')
        settings = s.get_settings()
        ```
        
        ## Config example
        
        ```
        {
            "log_level": "INFO",
            "log_name": "YourAwesomeProject.log",
            "monitoring": [
                "telegram",
                "email"
            ],
            "monitoring_channel": {
                "telegram": -1001343660695,
                "email_to": [
                    "aims.control@s7.ru"
                ]
            }
         }
        ```
        
        ## Working with DB (sqlalchemy)
        
        You should define dict with db_conn creditional.
        For example:
        
        ### Oracle
        Install oracle driver:
        ```
        pip install cx_oracle
        ```
        ```
        db_conn = {
        	"db_user": "dbuser",		# username
        	"db_pass": "dbpass",		# password
        	"db_host": "dbhost",		# host (ip, fqdn). could be empty if we connect via tns
        	"db_port": "",				# port (string). could be empty if we connect via tns 
        	"db_name": "dbname",		# database name
        	"db_schm": "",				# db scheme if not equal username
        	"dialect": "oracle"	# 		# if use cx_Oracle or oracle+another_dialect
        }
        ```
        ### MSSQL
        Install mssql driver:
        ```
        pip install sqlalchemy-pytds
        ```
        ```
        db_conn = {
        	"db_user": "dbuser",		# username
        	"db_pass": "dbpass",		# password
        	"db_host": "",				# host (ip, fqdn). could be empty if we connect via tns
        	"db_port": "",				# port (string). could be empty if we connect via tns 
        	"db_name": "dbname",		# database name
        	"db_schm": "",				# db scheme if not equal username
        	"dialect": "mssql+pytds"	# mssql dialect
        }
        ```
        ### Postgres
        Install postgres driver:
        ```
        pip install psycopg2
        ```
        ```
        db_conn = {
            "db_user": "dbuser",		# username
        	"db_pass": "dbpass",		# password
        	"db_host": "",				# host (ip, fqdn). could be empty if we connect via tns
        	"db_port": "",				# port (string). could be empty if we connect via tns 
        	"db_name": "dbname",		# database name
        	"db_schm": "",				# db scheme if not equal username
            "dialect": "postgresql+psycopg2" # dialect
        }
        ```
        
        ### Create connect
        
        For create connect you should use function *divinegift.smain.get_conn*.
        ```
        from divinegift.smain import get_conn, close_conn
        engine, conn, metadata = get_conn(db_conn)  # db_conn - variable which was described above
        ```
        
        If you need to call stored procedure with db cursors you should use raw connection.
        ```
        from divinegift.smain import get_raw_conn
        conn = get_raw_conn(db_conn)  # db_conn - variable which was described above
        ```
        
        ### Get data from sript (file or just string)
        
        When you got "conn" variable you can  get data from file or from str variable directly.
        
        ```
        result = get_data('path/to/scripts/some_script.sql', db_conn)
        # or you can use str variable:
        script = 'select * from dual'
        result = get_data(script, db_conn)
        print(result)
        >>>[{'dummy': 'X'}]
        ```
        
        You can use specific encoding for your files (by default it's 'cp1251'). 
        Just put it into args:
        ```
        result = get_data('path/to/scripts/some_script.sql', db_conn, encoding='utf8')
        ```
        
        Also you can add some variables into your script (e.g. date) and then you can pass it into function:
        ```
        script = """select * from dual
        where dummy = '$param'"""
        parameters = {'param': 'X'}
        result = get_data(script, db_conn, **parameters)
        # Or another variant
        result = get_data(script, db_conn, param='X')
        print(result)
        >>>[{'dummy': 'X'}]
        ```
        
        ### Run script without getting data
        
        You can run script without recieving data.
        You should use *divinegift.smain.run_script* for this like get_data, e.g.:
        ```
        run_script('path/to/scripts/some_script.sql', db_conn)
        ```
        
        ## Sending email
        
        You can use function *divinegift.smain.send_email*
        
        You should set your msg, subject and list of recipients.
        Simple example:
        ```
        from divinegift.smain import send_email
        send_email('Test message', 'Test subject', TO=['your@domain.com'])
        ```
        
        You can specify TO, CC, BCC, HOST, FROM and attachments. Also you can send it like html-message or like text.
        
        You should pass list of attachments files with absolute path to it. You can use function *divinegift.smain.get_list_files* for get it.
        For sending email with attahment(s):
        ```
        from divinegift.smain import send_email, get_list_files
        attachment_list = get_list_files('/path/to/files', add_path=True)
        send_email('Hello! This are files in attach', 'Test sending attachments', ['your@domain.com'], attachments=attachment_list)
        # Also you can send only one file:
        attachment = '/path/to/file/file_name'
        send_email('Hello! There is file in attach', 'File', ['your@domain.com'], attachments=attachment)
        ```
        
        If you set IS_HTML to False (by default it is True), you could send an email like simple text message, not html
        
        ## Work with JSON
        
        You can simple parse and create JSONs
        
        To create json you should use *divinegift.smain.create_json*
        To parse it you shoul use *divinegift.smain.parse_json*
        
        For example:
        ```
        from divinegift.smain import create_json, parse_json
        A = {'key1': 'data1', 'key2': 'data2'}
        create_json('json_file_name.json', A)
        B = parse_json('json_file_name.json')
        
        print(B)
        >>> {'key1': 'data1', 'key2': 'data2'}
        ```
        
Keywords: s7_it
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
