baraqda-lib 0.0.18
Generator of real fake data for testing purpose using real distribution in society
License: MIT

# baraqda-lib
Generating data for testing using real distribution of person attributes in particular society.
For now data is generated only for Polish person. 

# How to run
Install library from pip

    pip install baraqda-lib

Check if everything is working by simple code below:

    from baraqdalib import Person
    from baraqdalib import Addresses
    from baraqdalib import Generator

    if __name__ == '__main__':
        abba = Addresses()
        print(abba.generate())  # print generated address
        abba = Person()
        abba.set()  # Generate person attributes
        print(abba.get())  # print generated person attributes
        abba = Generator()
        print(abba.generate('PL', 'male_first_name', 100, sep='\t'))  # generate one attribute from provided data

# How to use
For generating address use:

    Addresses.generate()
Library does not save generated data.

If you want to generate more addresses or change country, define these parameters when calling function.
    
    Addresses.generate(counter = 100, lang = 'PL')

For generating person attributes use:

    Person.set()
    Person.get()

If you want to generate more person attributes put above code in loop. You can also specify nationality of person using parameter lang ('PL', 'DE').

If you don't want to generate the whole person but only one attribute use Generator class.
Example:
    
    Generator.generate('PL', 'female_first_name', 100, sep='\t'))

This code provides list of 100 female first name. 

List of available attributes to generate for Polish person.
- age, 
- blood_type,
- cities_pops,
- eyes,
- female_first_name,
- female_second_name,
- female_surname,
- hair,
- male_first_name,
- male_second_name,
- male_surname


# Generating data

Generating data take place in class `Generator()`. Instance of this class provide function to read data, store data,
display data that was read from files and most import make a toss. Generating address and person took place in class Addresses and Person.


## Functions in `Generator()`

### Generator.draw(lang: str, data_type: str, count: int = 1, sep: str = ' ') -> List[str]

Drawing a results from given file, returning list with len(list) = counter

        Parameters:
        lang (str): Two letters shortcut for country.
        data_type (str): Name of file from which data should be generated.
        count (int):  How many records should be generated, Default is 1.
        sep (str): Set separators for columns in files. Default is single space.

        Returns:
        list: Returning list of generated data.

### Generator.search_files(path, sep, lang) -> None
Running this function erase all stored data and read it again. Use with caution!
        
    Parameters:
        sep (str): separator of columns in files
        lang (str): Two letters shortcut for country

    Returns: None

### Generator.read_files(filepath, separator, lang, filename) -> None
Reading files into class variable self._data

        Parameters:
        filepath (str): Filepath for a file
        separator (str): Separator of columns in files
        lang (str): Two letters shortcut for country
        filename (str): Filename

        Returns: None
        """

### Generator.generate(lang: str, data_type: str, counter: int = 1, sep: str = ' ') -> List[str]
Generating data with reading files. This is recommended way of using generator. 

    Parameters:
        lang (str): two letters shortcut for country
        data_type (str): name of file from which data should be generated
        counter (int): default is 1. How many records should be generated
        sep (str): default is single space. Set separators for columns in files

    Returns:
        list: Returning list of generated data.
        """


### Generator.access_data(lang: str, data_type: str) -> Dict[str, list]
Access data which are read from files. Helpful when you
        want to make sure that your files are in correct format

    Parameters:
        lang (str): Two letters shortcut for country
        data_type (str): Name of file from which data should be generated

    Returns:
        Dict: Returning dictionary with loaded data in class instance


## Generate polish person and address

To generate person and address we can use class Person and class Addresses 
This two class generate only fake polish person.

Library generate only person nat

## Functions in `Addresses()`
### Addresses._set_codes(self):
Get postal codes from file postal_codes.csv and save in self._postal_code list

    Parameters : None

    Returns: None

 ### Addresses._set_cities(self):
 Get cities names  from file cities.csv and save in self._cities list

    Parameters : None

    Returns: None

 ### Addresses._set_streets(self):
 Get street names from file streets.csv and save in self._streets list

    Parameters : None

    Returns: None


### Addresses.generate(self, counter: int = 1, lang: str = 'PL')
Generating address with city, street, street number,  and postal code

    Parameters:
        counter (int): Default is 1. You can specify how much addreses you want to generate
        lang (str): Default is 'PL'. By this argument you can choose from wchich country addresses should be generated.

    Returns:
        Dict(Dict()): returning generated addresses in nested dictionary for easy access


### Addresses.get_code(self, city: str)
Search and return postal code for a given city

    Parameters:
        city (str): Name of the city

    Returns:
        str: Returns postal code

### Addresses.get_sym_city(self, city: str)
Searching for city in cities and returning sym (identification)

    Parameters:
        city (str): name of city for searching

    Returns:
        str : return sym for searching city

### Addresses.get_streets(self, city_sym: int)
Generate random street for given city sym (identification) that is in this city.

    Parameters:
        city_sym (int): number of city syn

    Returns:
        str: returns random street


## Functions in `Person()`
Generating attributes for Polish person. For simple use set() and get() to generate one record,
for more make for loop with these two functions.
 

### Person.toss(self)
    Parameters: None

    Returns:
        int: return random value of 0 or 1 which determines gender

### Person.set_date_of_birth(self, nr_of_years)
Create date of brith using generated number of years.

    Parameters:
        nr_of_years (int): number of years of generated person

    Returns:
        str: returns calculated date of birth

### Person.set_pesel(self, date_of_birth, female_or_male)
Create polish identification number, PESEL

    Parameters:
        date_of_birth (str):
        female_or_male (int): determines gender

    Returns:
        str: returning calculated PESEL

### Person.set(self)
Generating parameters for a person based on

    Parameters: None

    Returns: None


### Person.get(self)
Print generated attributes

    Parameters: None

    Returns: None