Skip to main content
Help the Python Software Foundation raise $60,000 USD by December 31st!  Building the PSF Q4 Fundraiser

A Python utility package written by Yuval Arbel

Project description

Yutils

A Python utility package written by Yuval Arbel

module base

yutils.base

module conn

yutils.conn

module exceptions

yutils.exceptions

module ml

yutils.ml

module queries

yutils.queries

module tools

yutils.tools

function match_arabic_nls_lang

yutils.match_arabic_nls_lang

module attribute_dict

yutils.base.attribute_dict

module generic_object

yutils.base.generic_object

module input_checker

yutils.base.input_checker

module list_container

yutils.base.list_container

module pretty_printer

yutils.base.pretty_printer

module updating_dict

yutils.base.updating_dict

object AttributeDict

yutils.base.attribute_dict.AttributeDict

object GenericObject

yutils.base.generic_object.GenericObject

A generic object you can easily use for your scripts, with a pprint and a str/repr for easy printing


    :param object_name: The name for your object!
    :type object_name: str

function dict_to_generic_object

yutils.base.generic_object.dict_to_generic_object

Converts a dictionary (recursively) to a GenericObject, with keys as attributes.

:param dictionary: dictionary to convert (key-values will be converted to attribute-values)
:type dictionary: dict
:param object_name: a name for your new object's type
:type object_name: str
:return: GenericObject object

object InputChecker

yutils.base.input_checker.InputChecker

    Base object for making a Python object more static-typed.
    It is useful for checking __init__ argument inputs (type and content).

    Type check is defined by _INPUT_TYPES class constant. (see yutils.tools.check_object_type for usage)
    Option check is defined by _INPUT_OPTIONS class constant.

    This also:
        - creates self._inputs as the inputs dict given, as an AttributeDict.
        - adds each input in inputs as an attribute to your object.

    :param inputs: your __init__ inputs, can be anything you wish to check

    :raises: yutils.exceptions.WrongDatatype if any input is not of the specified type, defined by _INPUT_TYPES
             yutils.exceptions.InputError if any input is not one of the options, defined by _INPUT_OPTIONS

object ListContainer

yutils.base.list_container.ListContainer

An object that wraps a list, allowing you to use your object as a list and configure it as you wish.


    :param _list: the original list you wish to keep in the backbone of your object
    :type _list: list
    :param _objects_type: a plural name for your objects in your ListContainer! This is for printing your object.
                          For Example:
                          >>> class Students(ListContainer):
                          >>>     def __init__(self):
                          >>>         super(Students, self).__init__([], 'students')
    :type _objects_type: str

object PrintableObject

yutils.base.pretty_printer.PrintableObject

An object you can derive from, that has a pprint method - printing all set attributes

object DictValueList

yutils.base.updating_dict.DictValueList

Initialize self. See help(type(self)) for accurate signature.

object UpdatingDict

yutils.base.updating_dict.UpdatingDict

Initialize self. See help(type(self)) for accurate signature.

module sql_connection_details

yutils.conn.sql_connection_details

object ConnectionDetails

yutils.conn.sql_connection_details.ConnectionDetails

Initialize self. See help(type(self)) for accurate signature.

object ElasticConnectionDetails

yutils.conn.sql_connection_details.ElasticConnectionDetails

Initialize self. See help(type(self)) for accurate signature.

object MSSQLConnectionDetails

yutils.conn.sql_connection_details.MSSQLConnectionDetails

Initialize self. See help(type(self)) for accurate signature.

object MySQLConnectionDetails

yutils.conn.sql_connection_details.MySQLConnectionDetails

Initialize self. See help(type(self)) for accurate signature.

object OracleConnectionDetails

yutils.conn.sql_connection_details.OracleConnectionDetails

Initialize self. See help(type(self)) for accurate signature.

module exceptions

yutils.exceptions.exceptions

object CodeMistake

yutils.exceptions.exceptions.CodeMistake

Gets raised to find mistakes when writing code


    :param mistake_string: an error message explaining why this was raised
    :type mistake_string: str

object InputError

yutils.exceptions.exceptions.InputError

Gets raised when the input wasn't as expected (e.g. isn't a valid option)


    :param error_string: an error message explaining the InputError
    :type error_string: str

object MissingAttribute

yutils.exceptions.exceptions.MissingAttribute

Gets raised when an attribute was expected in a certain class


    :param class_object: the object itself that is missing an attribute
    :type class_object: object
    :param attribute_name: the name of the attribute that is missing
    :type attribute_name: str

object MissingInput

yutils.exceptions.exceptions.MissingInput

Gets raised when an input was expected in a certain class but not received


    :param class_object: the object itself that is missing an attribute
    :type class_object: object
    :param attribute_name: the name of the attribute that is missing
    :type attribute_name: str

object UncaughtEndCase

yutils.exceptions.exceptions.UncaughtEndCase

Gets raised to catch unexpected cases in the future


    :param explanation: an optional string to explain the end case.
                        Default: 'An uncaught end case was found. Check it out!'
    :type explanation: str

object UserCancellation

yutils.exceptions.exceptions.UserCancellation

Gets raised when a user chooses to cancel an operation, and you wish the program to abort.


    :param operation_name: (optional) the operation the user chose to cancel
    :type operation_name: (optional) str

object WrongDatatype

yutils.exceptions.exceptions.WrongDatatype

Gets raised when something isn't the right datatype as was expected


    :param name: object name
    :type name: str
    :param expectation: expected type
    :type expectation: type or str
    :param reality: the object's actual type
    :type reality: type or str

object WrongInputDatatype

yutils.exceptions.exceptions.WrongInputDatatype

Gets raised when an input argument isn't the right datatype as was expected


    :param name: object name
    :type name: str
    :param expectation: expected type
    :type expectation: type or str
    :param reality: the object's actual type
    :type reality: type or str

object YutilsException

yutils.exceptions.exceptions.YutilsException

Initialize self. See help(type(self)) for accurate signature.

module classification

yutils.ml.classification

module features

yutils.ml.features

module linear_regression

yutils.ml.linear_regression

module ml_base

yutils.ml.ml_base

module regression

yutils.ml.regression

object LogisticRegression

yutils.ml.classification.LogisticRegression

object LogisticRegressionOptimizedClassifier

yutils.ml.classification.LogisticRegressionOptimizedClassifier

object MultiClassClassification

yutils.ml.classification.MultiClassClassification

object FeatureNormalizer

yutils.ml.features.FeatureNormalizer

    Normalizes features for a ML object

    :param info: info to normalize, across column axis (normalizes each column by different normalization data)
    :type info:

object LinearRegression

yutils.ml.linear_regression.LinearRegression

    Not written yet...

    :param training_data:
    :param training_results:
    :param learning_rate:
    :param iterations:
    :param normalize_data:
    :param verbose:

object NormalEquation

yutils.ml.linear_regression.NormalEquation

    Not explained yet...

    :param training_data:
    :param training_results:
    :param assess_for_warning:
    :param verbose:

object MLObject

yutils.ml.ml_base.MLObject

    Base object for making a Python object more static-typed.
    It is useful for checking __init__ argument inputs (type and content).

    Type check is defined by _INPUT_TYPES class constant. (see yutils.tools.check_object_type for usage)
    Option check is defined by _INPUT_OPTIONS class constant.

    This also:
        - creates self._inputs as the inputs dict given, as an AttributeDict.
        - adds each input in inputs as an attribute to your object.

    :param inputs: your __init__ inputs, can be anything you wish to check

    :raises: yutils.exceptions.WrongDatatype if any input is not of the specified type, defined by _INPUT_TYPES
             yutils.exceptions.InputError if any input is not one of the options, defined by _INPUT_OPTIONS

function create_data_from_text_file

yutils.ml.ml_base.create_data_from_text_file

object Regression

yutils.ml.regression.Regression

module db_connection

yutils.queries.db_connection

module oracle_field_list_format

yutils.queries.oracle_field_list_format

module db_connection

yutils.queries.db_connection.db_connection

module fetchers

yutils.queries.db_connection.fetchers

object DBConnection

yutils.queries.db_connection.db_connection.DBConnection

Wraps a connection to a DB, for executing SQL queries, using given connection_details.


    :param connection_details: Details for connection to the wanted DB
    :type: connection_details: yutils.conn.sql_connection_details.ConnectionDetails
    :param verbose: If to print warnings or not
    :type verbose: bool
module base_fetcher

yutils.queries.db_connection.fetchers.base_fetcher

module elastic

yutils.queries.db_connection.fetchers.elastic

module mssql

yutils.queries.db_connection.fetchers.mssql

module mysql

yutils.queries.db_connection.fetchers.mysql

module oracle

yutils.queries.db_connection.fetchers.oracle

object ElasticSearchFetcher

yutils.queries.db_connection.fetchers.elastic.ElasticSearchFetcher

object MSSQLFetcher

yutils.queries.db_connection.fetchers.mssql.MSSQLFetcher

object MySQLFetcher

yutils.queries.db_connection.fetchers.mysql.MySQLFetcher

object OracleFetcher

yutils.queries.db_connection.fetchers.oracle.OracleFetcher

function format_oracle_field_list

yutils.queries.oracle_field_list_format.format_oracle_field_list

Takes a list that can be more than 999 values long, and wraps them in SQL OR clauses.
This is useful because Oracle can only accept lists 1000 values long.

:param field_name: the name of the column you are querying
:type field_name: str
:param value_list: list of your values to format into the query
:type value_list: list of str

:return: formatted string containing your new WHERE clause
:rtype: unicode

module case_conversions

yutils.tools.case_conversions

module files

yutils.tools.files

module list

yutils.tools.list

module numpy_tools

yutils.tools.numpy_tools

module pretty_print

yutils.tools.pretty_print

module str

yutils.tools.str

module xlsx_creator

yutils.tools.xlsx_creator

function check_object_type

yutils.tools.check_object_type

This checks the types of an object using a certain syntax:
Lets say we have an object_to_check and the types_to_validate.
The object_to_check is the object

:param object_to_check: the object you wish to check its type, and raise an exception should its type not be correct
:type object_to_check: ....that's what we're here for....
:param types_to_validate: defines the wanted types for the object to check:
:type types_to_validate:
            type - checks that object_to_check is of that type
                    Example: float will make sure object_to_check is a float
            list of types - checks that object_to_check is one of the types in the list
                    Example: [int, float] will make sure object_to_check is either an int or a float
            tuple of types - checks hierarchically:
                                checks that object_to_check is of the type of the first item,
                                then checks that each item in object_to_check is of the type of the second item,
                                etc.
                             Remember, all types in the tuple except the last must support indexing.
                    Example: (list, str) will make sure object_to_check is a list of strings
                             (tuple, [int, float]) will make sure object_to_check is a tuple of either ints or floats
            dict - checks that object_to_check is an object. It's type is defined by key 'type',
                   with other keys to be checked as the object's attributes.
                    Example: {'type': Person, 'age': int} will make sure object_to_check is a Person object,
                             with an 'age' attribute that is an int.
            All values can have as many recursive dimensions as wanted.
:param input_name: Do not use, this is for recursive inner use.

More examples
Lets say we create:

integer = 13
unicode_str = u'foo'
int_list = list(range(10))
input_object = MyObject()
input_object.num = 3
input_object.lis = [1, 'bar']
input_object.3dlist = [[(1, 2, 3), (1, 1, 1)], [('a', 'b', 'c'), [7, 8, 9]]]

We can send:
check_object_type(integer, int)
check_object_type(unicode_str, unicode)
check_object_type(int_list, (list, int))
check_object_type(input_object, {'type': MyObject,
                                 'num': int,
                                 'lis': (list, [int, str]),
                                 '3dlist': (list, list, [tuple, list], [int, str, unicode])
                                 })

:raises:
         Because of invalid inputs:
            yutils.exceptions.CodeMistake - When no 'type' key is found (for when types_to_validate is a dict)
            yutils.exceptions.WrongDatatype - When no type type is found when isinstance-ing an object's type
         Exceptions raised by check:
            yutils.exceptions.WrongInputDatatype - When the type is not correct during validation
            yutils.exceptions.MissingInput - When an attribute is missing (for when types_to_validate is a dict)

function equivilence

yutils.tools.equivilence

Divides an iterator to groups, based on the function's result of every item in the iterator.
Returns dict of lists.

Example:
    >>> equivilence(range(10), lambda x: x % 3)
    >>>out>>> {0: [0, 3, 6, 9],
    >>>out>>>  1: [1, 4, 7],
    >>>out>>>  2: [2, 5, 8]}

:param iterator: an iterator you wish to run on and divide into groups
:type iterator: iterator
:param func: a function to activate on each iterator item - its result decides the return dict's keys.
:type func: function

:rtype: dict of lists (lists are groups of original iterator)

function camel_back_to_snake_case

yutils.tools.case_conversions.camel_back_to_snake_case

Turns a camelBack word to a snake_case word

:param camel_back_word: wordInCamelCase
:return: a_word_in_snake_case

function camel_case_to_snake_case

yutils.tools.case_conversions.camel_case_to_snake_case

Turns a CamelCase word to a snake_case word

:param camel_case_word: AWordInCamelCase
:return: a_word_in_snake_case

function snake_case_to_camel_back

yutils.tools.case_conversions.snake_case_to_camel_back

Turns a snake_case word to a camelBack word

:param snake_case_word: a_word_in_snake_case
:return: wordInCamelCase

function snake_case_to_camel_case

yutils.tools.case_conversions.snake_case_to_camel_case

Turns a snake_case word to a CamelCase word

:param snake_case_word: a_word_in_snake_case
:return: AWordInCamelCase

function get_file_length

yutils.tools.files.get_file_length

This function gets a file path and returns its length without reading it

:param file_path: path to return length of
:type file_path: str
:return: file length (in bytes)
:rtype: int

function recursive_glob

yutils.tools.files.recursive_glob

Returns a list of all files in directory including sub-directories.

:param dir_name: Dir name to glob recursively on
:type dir_name: str
:param ignore_hidden: if to ignore hidden files (that start with '.')
:type ignore_hidden: bool

:return: list of all files in the dir_name
:rtype: list of str

function save_file

yutils.tools.files.save_file

This function saves the file content to the destination dir (defaulted to ".") as base_name + extension,
but adds a counter if needed.

:param content: the content of the file
:type content: str
:param file_base_name: the future file name without extension
:type file_base_name: str
:param extension: the file name extension (for example: 'xlsx')
:type extension: str
:param dest_dir: where to save the file
                 Default: current directory
:type dest_dir: str

:return: full file path file was saved to
:rtype: unicode

function make_list

yutils.tools.list.make_list

function repr_list

yutils.tools.list.repr_list

Returns an iterator as a string, representing the list.
:param iterator: the iterator you wish to represent as a list
:type iterator: iterator
:return: representation of your iterator as a list
:rtype: unicode

function get_indices_containing_all_substrings

yutils.tools.numpy_tools.get_indices_containing_all_substrings

function is_iterable

yutils.tools.numpy_tools.is_iterable

function magic

yutils.tools.numpy_tools.magic

Implementation taken from https://stackoverflow.com/questions/47834140/numpy-equivalent-of-matlabs-magic
from user: user6655984

function normalize_array

yutils.tools.numpy_tools.normalize_array

function r2c

yutils.tools.numpy_tools.r2c

function to_array

yutils.tools.numpy_tools.to_array

function pprint_dict

yutils.tools.pretty_print.pprint_dict

Prints a dict in a very pretty way!

:param dictionary: your dict to print
:type dictionary: dict
:param long_value_limit: when a dict value exceeds this limit, it won't be printed
                         Default: 120
:type long_value_limit: int
:param long_value_filler: A filler to print instead of a long value, must have {type} and {length} fields!
                          Default: '<Long {type} object with repr length {length}>'
:type long_value_filler: str
:return: None

function pprint_list

yutils.tools.pretty_print.pprint_list

Prints a list in an easy, short way.

:param list_to_print: the list you wish to print
:type list_to_print: list
:return: None

function turn_numeric

yutils.tools.str.turn_numeric

Turns a string into either an int or a float

:param string: a string to assess
:type string: str

:rtype: str or float

:raises: TypeError if no type was found

object XLSXCreator

yutils.tools.xlsx_creator.XLSXCreator

    A class to create an XLSX file from a table.
    It will format the table inside an actual excel's table, according to each field's width.

    :param headers: The fields of the table (headers)
    :type headers: list of unicode
    :param table: The table
    :type table: matrix - list of lists of the same lengths (cells may be any datatype)
    :param output_path: The path where to save the excel
    :type output_path: unicode

function create_xlsx

yutils.tools.xlsx_creator.create_xlsx

Creates an XLSX file from a table.
It will format the table inside an actual excel's table, according to each field's width.

:param headers: The fields of the table (headers)
:type headers: list of unicode
:param table: The table
:type table: matrix - list of lists of the same lengths (cells may be any datatype)
:param output_path: The path where to save the excel
:type output_path: unicode

function get_next_column

yutils.tools.xlsx_creator.get_next_column

function get_next_letter

yutils.tools.xlsx_creator.get_next_letter

function table_to_str

yutils.tools.xlsx_creator.table_to_str

matrix good for the function xlsxwriter.Worksheet.add_table(['data': table))
:param table: matrix - list of lists of the same lengths (cells may be any datatype)
:return: fully string matrix

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for yutils, version 1.3.2
Filename, size File type Python version Upload date Hashes
Filename, size yutils-1.3.2.tar.gz (67.9 kB) File type Source Python version None Upload date Hashes View

Supported by

Pingdom Pingdom Monitoring Google Google Object Storage and Download Analytics Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page