iklobato · October 9, 2024 15:59 · iklobato · Oct 9, 2024 · iklobato · Oct 9, 2024
diff --git a/taqtic_client.py b/taqtic_client.py
 """
 Tag Manager for Tactiq

 This script manages tags and their associated values for the Tactiq application.
 It provides functionality to create tags and add values to them using the Tactiq API.

 Usage:
    python tag_manager.py --token=<your_token> --tags_file=<path_to_tags_file>

    --token: Your Tactiq API bearer token (required)
    --tags_file: Path to the JSON file containing tag groups (default: groups.json)

 The tags file should be a JSON file with the following structure:
 {
    "tag_name_1": ["value1", "value2", ...],
    "tag_name_2": ["value3", "value4", ...],
    ...
 }

 Example:
    python tag_manager.py --token=abc123... --tags_file=my_tags.json

 """

 import argparse
 import json
 import re
 import requests
 from dataclasses import dataclass
 from typing import Dict, List, Optional


 @dataclass
 class Config:
    """
    Configuration class for the Tag Manager.

    Attributes:
        token (str): The bearer token for API authentication.
        tags_file (str): The path to the JSON file containing tag groups.
        api_url (str): The URL of the Tactiq API (default: "https://api2.tactiq.io/api/2/graphql").
    """

    token: str
    tags_file: str
    api_url: str = "https://api2.tactiq.io/api/2/graphql"

    @property
    def headers(self) -> Dict[str, str]:
        """
        Generate the headers for API requests.

        Returns:
            Dict[str, str]: A dictionary of HTTP headers for API requests.
        """
        return {
            'accept': '*/*',
            'accept-language': 'en;q=0.8',
            'authorization': f'Bearer {self.token}',
            'content-type': 'application/json',
            'origin': 'https://app.tactiq.io',
            'referer': 'https://app.tactiq.io/',
            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36',
        }


 @dataclass
 class APIClient:
    """
    API client for making requests to the Tactiq API.

    Attributes:
        config (Config): The configuration object containing API settings.
    """

    config: Config

    def post_request(self, payload: Dict) -> Optional[Dict]:
        """
        Send a POST request to the Tactiq API.

        Args:
            payload (Dict): The request payload.

        Returns:
            Optional[Dict]: The JSON response from the API, or None if the request failed.
        """
        try:
            response = requests.post(
                self.config.api_url, headers=self.config.headers, json=payload
            )
            response.raise_for_status()
            return response.json()
        except requests.RequestException as e:
            print(f"API request failed: {e}")
            return None


 class TagManager:
    """
    Manages tag operations for the Tactiq application.

    Attributes:
        api_client (APIClient): The API client for making requests to the Tactiq API.
    """

    def __init__(self, api_client: APIClient):
        """
        Initialize the TagManager.

        Args:
            api_client (APIClient): The API client for making requests to the Tactiq API.
        """
        self.api_client = api_client

    @staticmethod
    def sanitize_field_name(name: str) -> str:
        """
        Sanitize a field name to make it suitable for use in GraphQL queries.

        Args:
            name (str): The original field name.

        Returns:
            str: The sanitized field name.
        """
        sanitized = re.sub(r'\W+', '_', name)
        return f'tag_{sanitized}' if not sanitized[0].isalpha() else sanitized

    def create_tags(self, tags_dict: Dict[str, List[str]]) -> Optional[Dict]:
        """
        Create tags using the Tactiq API.

        Args:
            tags_dict (Dict[str, List[str]]): A dictionary of tag names and their associated values.

        Returns:
            Optional[Dict]: The API response containing created tags, or None if the request failed.
        """
        create_tag_mutations = [
            f"""{self.sanitize_field_name(tag_name)}: createTag(input: {{name: "{tag_name}", icon: "{tag_name[0]}"}}) {{
                tag {{
                    icon
                    name
                    __typename
                }}
                __typename
            }}"""
            for tag_name in tags_dict.keys()
        ]

        mutation_string = "\n".join(create_tag_mutations)
        payload = {
            "operationName": "CreateTags",
            "variables": {},
            "query": f"mutation CreateTags {{{mutation_string}}}",
        }

        return self.api_client.post_request(payload)

    def add_values_to_tags(self, tags_dict: Dict[str, List[str]]) -> Optional[Dict]:
        """
        Add values to tags using the Tactiq API.

        Args:
            tags_dict (Dict[str, List[str]]): A dictionary of tag names and their associated values.

        Returns:
            Optional[Dict]: The API response confirming the addition of values, or None if the request failed.
        """
        auto_highlights = [
            {"searchValue": value, "autoTag": tag_name}
            for tag_name, values in tags_dict.items()
            for value in values
        ]

        payload = {
            "operationName": "UpdateUserSetting",
            "variables": {"input": {"autoHighlights": auto_highlights}},
            "query": """
            mutation UpdateUserSetting($input: UpdateUserSettingInput!) {
              updateUserSetting(input: $input) {
                success
                __typename
              }
            }
            """,
        }

        return self.api_client.post_request(payload)

    def process_tags(self, tags_dict: Dict[str, List[str]]) -> bool:
        """
        Process tags by creating them and adding associated values.

        Args:
            tags_dict (Dict[str, List[str]]): A dictionary of tag names and their associated values.

        Returns:
            bool: True if both creating tags and adding values were successful, False otherwise.
        """
        create_response = self.create_tags(tags_dict)
        if not create_response:
            print("Failed to create tags.")
            return False

        print("Created tags:")
        print(json.dumps(create_response, indent=2))
        print("---")

        update_response = self.add_values_to_tags(tags_dict)
        if not update_response:
            print("Failed to add values to tags.")
            return False

        print("Added values to tags:")
        print(json.dumps(update_response, indent=2))
        return True


 def parse_arguments() -> argparse.Namespace:
    """
    Parse command-line arguments.

    Returns:
        argparse.Namespace: An object containing the parsed arguments.
    """
    parser = argparse.ArgumentParser(description="Tag Manager for Tactiq")
    parser.add_argument(
        "--token", required=True, help="Bearer token for authentication"
    )
    parser.add_argument(
        "--tags_file", default="groups.json", help="JSON file containing tag groups"
    )
    return parser.parse_args()


 def load_tags_dict(file_path: str) -> Optional[Dict[str, List[str]]]:
    """
    Load the tags dictionary from a JSON file.

    Args:
        file_path (str): The path to the JSON file containing tag groups.

    Returns:
        Optional[Dict[str, List[str]]]: The loaded tags dictionary, or None if loading failed.
    """
    try:
        with open(file_path) as json_file:
            return json.load(json_file)
    except FileNotFoundError:
        print(f"Error: The file {file_path} was not found.")
    except json.JSONDecodeError:
        print(f"Error: The file {file_path} is not a valid JSON file.")
    return None


 def main() -> None:
    """
    The main function that orchestrates the tag management process.
    """
    args = parse_arguments()
    config = Config(token=args.token, tags_file=args.tags_file)

    tags_dict = load_tags_dict(config.tags_file)
    if not tags_dict:
        return

    api_client = APIClient(config)
    tag_manager = TagManager(api_client)

    if tag_manager.process_tags(tags_dict):
        print("Tag processing completed successfully.")
    else:
        print("Tag processing failed.")


 if __name__ == '__main__':
    """
    This script manages tags for the Tactiq application.

    To use this script:

    1. Ensure you have the required dependencies installed:
       pip install requests

    2. Prepare a JSON file (e.g., 'groups.json') with your tag groups. The file should have this structure:
       {
           "Tag Name 1": ["value1", "value2", "value3"],
           "Tag Name 2": ["value4", "value5", "value6"],
           ...
       }

    3. Obtain your Tactiq API bearer token.

    4. Run the script from the command line:
       python tag_manager.py --token=your_bearer_token --tags_file=path_to_your_tags_file.json

    Example:
       python tag_manager.py --token=abc123... --tags_file=my_tags.json

    The script will:
    - Create the specified tags in your Tactiq account
    - Add the associated values to each tag
    - Print the results of each operation

    If any errors occur during the process, they will be printed to the console.
    """
    main()
	"""
	Tag Manager for Tactiq

	This script manages tags and their associated values for the Tactiq application.
	It provides functionality to create tags and add values to them using the Tactiq API.

	Usage:
	python tag_manager.py --token=<your_token> --tags_file=<path_to_tags_file>

	--token: Your Tactiq API bearer token (required)
	--tags_file: Path to the JSON file containing tag groups (default: groups.json)

	The tags file should be a JSON file with the following structure:
	{
	"tag_name_1": ["value1", "value2", ...],
	"tag_name_2": ["value3", "value4", ...],
	...
	}

	Example:
	python tag_manager.py --token=abc123... --tags_file=my_tags.json

	"""

	import argparse
	import json
	import re
	import requests
	from dataclasses import dataclass
	from typing import Dict, List, Optional


	@dataclass
	class Config:
	"""
	Configuration class for the Tag Manager.

	Attributes:
	token (str): The bearer token for API authentication.
	tags_file (str): The path to the JSON file containing tag groups.
	api_url (str): The URL of the Tactiq API (default: "https://api2.tactiq.io/api/2/graphql").
	"""

	token: str
	tags_file: str
	api_url: str = "https://api2.tactiq.io/api/2/graphql"

	@property
	def headers(self) -> Dict[str, str]:
	"""
	Generate the headers for API requests.

	Returns:
	Dict[str, str]: A dictionary of HTTP headers for API requests.
	"""
	return {
	'accept': '/',
	'accept-language': 'en;q=0.8',
	'authorization': f'Bearer {self.token}',
	'content-type': 'application/json',
	'origin': 'https://app.tactiq.io',
	'referer': 'https://app.tactiq.io/',
	'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36',
	}


	@dataclass
	class APIClient:
	"""
	API client for making requests to the Tactiq API.

	Attributes:
	config (Config): The configuration object containing API settings.
	"""

	config: Config

	def post_request(self, payload: Dict) -> Optional[Dict]:
	"""
	Send a POST request to the Tactiq API.

	Args:
	payload (Dict): The request payload.

	Returns:
	Optional[Dict]: The JSON response from the API, or None if the request failed.
	"""
	try:
	response = requests.post(
	self.config.api_url, headers=self.config.headers, json=payload
	)
	response.raise_for_status()
	return response.json()
	except requests.RequestException as e:
	print(f"API request failed: {e}")
	return None


	class TagManager:
	"""
	Manages tag operations for the Tactiq application.

	Attributes:
	api_client (APIClient): The API client for making requests to the Tactiq API.
	"""

	def __init__(self, api_client: APIClient):
	"""
	Initialize the TagManager.

	Args:
	api_client (APIClient): The API client for making requests to the Tactiq API.
	"""
	self.api_client = api_client

	@staticmethod
	def sanitize_field_name(name: str) -> str:
	"""
	Sanitize a field name to make it suitable for use in GraphQL queries.

	Args:
	name (str): The original field name.

	Returns:
	str: The sanitized field name.
	"""
	sanitized = re.sub(r'\W+', '_', name)
	return f'tag_{sanitized}' if not sanitized[0].isalpha() else sanitized

	def create_tags(self, tags_dict: Dict[str, List[str]]) -> Optional[Dict]:
	"""
	Create tags using the Tactiq API.

	Args:
	tags_dict (Dict[str, List[str]]): A dictionary of tag names and their associated values.

	Returns:
	Optional[Dict]: The API response containing created tags, or None if the request failed.
	"""
	create_tag_mutations = [
	f"""{self.sanitize_field_name(tag_name)}: createTag(input: {{name: "{tag_name}", icon: "{tag_name[0]}"}}) {{
	tag {{
	icon
	name
	__typename
	}}
	__typename
	}}"""
	for tag_name in tags_dict.keys()
	]

	mutation_string = "\n".join(create_tag_mutations)
	payload = {
	"operationName": "CreateTags",
	"variables": {},
	"query": f"mutation CreateTags {{{mutation_string}}}",
	}

	return self.api_client.post_request(payload)

	def add_values_to_tags(self, tags_dict: Dict[str, List[str]]) -> Optional[Dict]:
	"""
	Add values to tags using the Tactiq API.

	Args:
	tags_dict (Dict[str, List[str]]): A dictionary of tag names and their associated values.

	Returns:
	Optional[Dict]: The API response confirming the addition of values, or None if the request failed.
	"""
	auto_highlights = [
	{"searchValue": value, "autoTag": tag_name}
	for tag_name, values in tags_dict.items()
	for value in values
	]

	payload = {
	"operationName": "UpdateUserSetting",
	"variables": {"input": {"autoHighlights": auto_highlights}},
	"query": """
	mutation UpdateUserSetting($input: UpdateUserSettingInput!) {
	updateUserSetting(input: $input) {
	success
	__typename
	}
	}
	""",
	}

	return self.api_client.post_request(payload)

	def process_tags(self, tags_dict: Dict[str, List[str]]) -> bool:
	"""
	Process tags by creating them and adding associated values.

	Args:
	tags_dict (Dict[str, List[str]]): A dictionary of tag names and their associated values.

	Returns:
	bool: True if both creating tags and adding values were successful, False otherwise.
	"""
	create_response = self.create_tags(tags_dict)
	if not create_response:
	print("Failed to create tags.")
	return False

	print("Created tags:")
	print(json.dumps(create_response, indent=2))
	print("---")

	update_response = self.add_values_to_tags(tags_dict)
	if not update_response:
	print("Failed to add values to tags.")
	return False

	print("Added values to tags:")
	print(json.dumps(update_response, indent=2))
	return True


	def parse_arguments() -> argparse.Namespace:
	"""
	Parse command-line arguments.

	Returns:
	argparse.Namespace: An object containing the parsed arguments.
	"""
	parser = argparse.ArgumentParser(description="Tag Manager for Tactiq")
	parser.add_argument(
	"--token", required=True, help="Bearer token for authentication"
	)
	parser.add_argument(
	"--tags_file", default="groups.json", help="JSON file containing tag groups"
	)
	return parser.parse_args()


	def load_tags_dict(file_path: str) -> Optional[Dict[str, List[str]]]:
	"""
	Load the tags dictionary from a JSON file.

	Args:
	file_path (str): The path to the JSON file containing tag groups.

	Returns:
	Optional[Dict[str, List[str]]]: The loaded tags dictionary, or None if loading failed.
	"""
	try:
	with open(file_path) as json_file:
	return json.load(json_file)
	except FileNotFoundError:
	print(f"Error: The file {file_path} was not found.")
	except json.JSONDecodeError:
	print(f"Error: The file {file_path} is not a valid JSON file.")
	return None


	def main() -> None:
	"""
	The main function that orchestrates the tag management process.
	"""
	args = parse_arguments()
	config = Config(token=args.token, tags_file=args.tags_file)

	tags_dict = load_tags_dict(config.tags_file)
	if not tags_dict:
	return

	api_client = APIClient(config)
	tag_manager = TagManager(api_client)

	if tag_manager.process_tags(tags_dict):
	print("Tag processing completed successfully.")
	else:
	print("Tag processing failed.")


	if __name__ == '__main__':
	"""
	This script manages tags for the Tactiq application.

	To use this script:

	1. Ensure you have the required dependencies installed:
	pip install requests

	2. Prepare a JSON file (e.g., 'groups.json') with your tag groups. The file should have this structure:
	{
	"Tag Name 1": ["value1", "value2", "value3"],
	"Tag Name 2": ["value4", "value5", "value6"],
	...
	}

	3. Obtain your Tactiq API bearer token.

	4. Run the script from the command line:
	python tag_manager.py --token=your_bearer_token --tags_file=path_to_your_tags_file.json

	Example:
	python tag_manager.py --token=abc123... --tags_file=my_tags.json

	The script will:
	- Create the specified tags in your Tactiq account
	- Add the associated values to each tag
	- Print the results of each operation

	If any errors occur during the process, they will be printed to the console.
	"""
	main()