vcon 0.2__tar.gz → 0.3.0__tar.gz

vcon-0.2/LICENSE → vcon-0.3.0/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 vcon-dev
+Copyright (c) [2024] [StrolidInc]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

vcon-0.3.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.1
+Name: vcon
+Version: 0.3.0
+Summary: The vCon library
+License: MIT
+Author: pair
+Author-email: dev_team@strolid.com
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: authlib (>=1.3.2,<2.0.0)
+Requires-Dist: pydash (>=8.0.3,<9.0.0)
+Requires-Dist: pytest (>=8.3.2,<9.0.0)
+Requires-Dist: pytest-cov (>=5.0.0,<6.0.0)
+Requires-Dist: pytest-mock (>=3.14.0,<4.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: uuid6 (>=2024.7.10,<2025.0.0)
+Description-Content-Type: text/markdown
+
+# vCon Python Library
+
+This Python library provides a convenient way to work with vCon (Virtualized Conversation) objects. vCon is a standard for representing conversation data, including metadata, dialog, analysis, and attachments.
+
+## Features
+
+- Create and manipulate vCon objects
+- Add parties, dialogs, attachments, and analysis to vCons
+- Sign and verify vCons using JWS (JSON Web Signature)
+- Generate UUID8 identifiers
+- Pack and unpack dialogs
+- Add and retrieve tags
+
+## Installation
+
+To install the vCon library, use pip:
+
+```
+pip install vcon
+```
+
+## Usage
+from vcon import Vcon
+from vcon.party import Party
+
+# Create a new vcon
+vcon = Vcon.build_new()
+
+# Add a party to the vcon
+party = Party(mailto="example@example.com")
+vcon.add_party(party)
+
+# Add a dialog to the vcon
+dialog = {
+    "id": "dialog1",
+    "type": "text",
+    "start": "2024-05-03T20:13:48.414984",
+    "parties": [0],
+    "body": "Hello, world!",
+    "encoding": "none"
+}
+vcon.add_dialog(dialog)
+
+# Add an attachment to the vcon
+attachment = {
+    "type": "tags",
+    "body": ["tag1:value1", "tag2:value2"],
+    "encoding": "json"
+}
+vcon.add_attachment(attachment)
+
+# Add analysis to the vcon
+analysis = {
+    "type": "transcript",
+    "dialog": 0,
+    "vendor": "openai",
+    "body": {"key": "value"},
+    "encoding": "json"
+}
+vcon.add_analysis(analysis)
+
+# Serialize the vcon to JSON
+json_string = vcon.to_json()
+print(json_string)
+
+# Create a new vcon from the JSON string
+new_vcon = Vcon.build_from_json(json_string)
+
+# Print the new vcon's UUID
+print(new_vcon.uuid)
+
+
+## API Reference
+
+For detailed information about the available methods and their usage, please refer to the docstrings in the source code.
+
+## Contributing
+
+Contributions to the vCon library are welcome! Please submit pull requests or open issues on the GitHub repository.
+
+## License
+
+This project is licensed under the MIT License:
+
+MIT License
+
+Copyright (c) 2023 Thomas McCarthy-Howe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## Contact
+
+For questions or support, please contact:
+
+Thomas McCarthy-Howe
+Email: ghostofbasho@gmail.com

vcon-0.3.0/README.md

@@ -0,0 +1,112 @@
+# vCon Python Library
+
+This Python library provides a convenient way to work with vCon (Virtualized Conversation) objects. vCon is a standard for representing conversation data, including metadata, dialog, analysis, and attachments.
+
+## Features
+
+- Create and manipulate vCon objects
+- Add parties, dialogs, attachments, and analysis to vCons
+- Sign and verify vCons using JWS (JSON Web Signature)
+- Generate UUID8 identifiers
+- Pack and unpack dialogs
+- Add and retrieve tags
+
+## Installation
+
+To install the vCon library, use pip:
+
+```
+pip install vcon
+```
+
+## Usage
+from vcon import Vcon
+from vcon.party import Party
+
+# Create a new vcon
+vcon = Vcon.build_new()
+
+# Add a party to the vcon
+party = Party(mailto="example@example.com")
+vcon.add_party(party)
+
+# Add a dialog to the vcon
+dialog = {
+    "id": "dialog1",
+    "type": "text",
+    "start": "2024-05-03T20:13:48.414984",
+    "parties": [0],
+    "body": "Hello, world!",
+    "encoding": "none"
+}
+vcon.add_dialog(dialog)
+
+# Add an attachment to the vcon
+attachment = {
+    "type": "tags",
+    "body": ["tag1:value1", "tag2:value2"],
+    "encoding": "json"
+}
+vcon.add_attachment(attachment)
+
+# Add analysis to the vcon
+analysis = {
+    "type": "transcript",
+    "dialog": 0,
+    "vendor": "openai",
+    "body": {"key": "value"},
+    "encoding": "json"
+}
+vcon.add_analysis(analysis)
+
+# Serialize the vcon to JSON
+json_string = vcon.to_json()
+print(json_string)
+
+# Create a new vcon from the JSON string
+new_vcon = Vcon.build_from_json(json_string)
+
+# Print the new vcon's UUID
+print(new_vcon.uuid)
+
+
+## API Reference
+
+For detailed information about the available methods and their usage, please refer to the docstrings in the source code.
+
+## Contributing
+
+Contributions to the vCon library are welcome! Please submit pull requests or open issues on the GitHub repository.
+
+## License
+
+This project is licensed under the MIT License:
+
+MIT License
+
+Copyright (c) 2023 Thomas McCarthy-Howe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## Contact
+
+For questions or support, please contact:
+
+Thomas McCarthy-Howe
+Email: ghostofbasho@gmail.com

vcon-0.3.0/pyproject.toml

@@ -0,0 +1,34 @@
+[tool.poetry]
+name = "vcon"
+version = "0.3.0"
+description = "The vCon library"
+authors = ["pair <dev_team@strolid.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [
+    { include = "vcon", from = "src" }
+]
+
+[[tool.poetry.source]]
+name = "testpypi"
+url = "https://test.pypi.org/legacy/"
+priority = "primary"
+
+
+[[tool.poetry.source]]
+name = "PyPI"
+priority = "primary"
+
+[tool.poetry.dependencies]
+python = "^3.8"
+authlib = "^1.3.2"
+pytest = "^8.3.2"
+uuid6 = "^2024.7.10"
+requests = "^2.32.3"
+pydash = "^8.0.3"
+pytest-cov = "^5.0.0"
+pytest-mock = "^3.14.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

vcon-0.3.0/src/vcon/__init__.py

@@ -0,0 +1,3 @@
+from .vcon import Vcon
+
+__all__ = ["Vcon"]

vcon-0.3.0/src/vcon/civic_address.py

@@ -0,0 +1,90 @@
+from typing import Optional
+from typing import Optional
+
+class CivicAddress:
+    def __init__(self,
+                 country: Optional[str] = None,
+                 a1: Optional[str] = None,
+                 a2: Optional[str] = None,
+                 a3: Optional[str] = None,
+                 a4: Optional[str] = None,
+                 a5: Optional[str] = None,
+                 a6: Optional[str] = None,
+                 prd: Optional[str] = None,
+                 pod: Optional[str] = None,
+                 sts: Optional[str] = None,
+                 hno: Optional[str] = None,
+                 hns: Optional[str] = None,
+                 lmk: Optional[str] = None,
+                 loc: Optional[str] = None,
+                 flr: Optional[str] = None,
+                 nam: Optional[str] = None,
+                 pc: Optional[str] = None):
+        """
+        Initialize a new CivicAddress object.
+
+        :param country: Country code (ISO 3166-1 alpha-2)
+        :type country: str
+        :param a1: Administrative area 1 (e.g. state or province)
+        :type a1: str
+        :param a2: Administrative area 2 (e.g. county or municipality)
+        :type a2: str
+        :param a3: Administrative area 3 (e.g. city or town)
+        :type a3: str
+        :param a4: Administrative area 4 (e.g. neighborhood or district)
+        :type a4: str
+        :param a5: Administrative area 5 (e.g. postal code)
+        :type a5: str
+        :param a6: Administrative area 6 (e.g. building or floor)
+        :type a6: str
+        :param prd: Premier (e.g. department or suite number)
+        :type prd: str
+        :param pod: Post office box identifier
+        :type pod: str
+        :param sts: Street name
+        :type sts: str
+        :param hno: House number
+        :type hno: str
+        :param hns: House name
+        :type hns: str
+        :param lmk: Landmark name
+        :type lmk: str
+        :param loc: Location name
+        :type loc: str
+        :param flr: Floor
+        :type flr: str
+        :param nam: Name of the location
+        :type nam: str
+        :param pc: Postal code
+        :type pc: str
+        """
+        self.country = country
+        self.a1 = a1
+        self.a2 = a2
+        self.a3 = a3
+        self.a4 = a4
+        self.a5 = a5
+        self.a6 = a6
+        self.prd = prd
+        self.pod = pod
+        self.sts = sts
+        self.hno = hno
+        self.hns = hns
+        self.lmk = lmk
+        self.loc = loc
+        self.flr = flr
+        self.nam = nam
+        self.pc = pc
+
+    def to_dict(self) -> dict[str, Optional[str]]:
+        """
+        Convert the CivicAddress object to a dictionary.
+
+        The dictionary keys are the attribute names of the object, and the
+        values are the attribute values.
+
+        :return: A dictionary of the object's attributes
+        :rtype: dict[str, Optional[str]]
+        """
+        return {attr: getattr(self, attr) for attr in dir(self) if not attr.startswith("_") and getattr(self, attr) is not None and not callable(getattr(self, attr))}
+

vcon-0.3.0/src/vcon/dialog.py

@@ -0,0 +1,277 @@
+import requests
+import hashlib
+import base64
+from datetime import datetime
+from typing import Optional, List
+from .party import PartyHistory
+
+
+MIME_TYPES = [
+    "text/plain",
+    "audio/x-wav",
+    "audio/x-mp3",
+    "audio/x-mp4",
+    "audio/ogg",
+    "video/x-mp4",
+    "video/ogg",
+    "multipart/mixed",
+    "message/external-body",
+]
+
+
+class Dialog:
+    def __init__(self, 
+                 type: str, 
+                 start: datetime, 
+                 parties: List[int], 
+                 originator: Optional[int] = None, 
+                 mimetype: Optional[str] = None, 
+                 filename: Optional[str] = None, 
+                 body: Optional[str] = None, 
+                 encoding: Optional[str] = None, 
+                 url: Optional[str] = None, 
+                 alg: Optional[str] = None, 
+                 signature: Optional[str] = None, 
+                 disposition: Optional[str] = None, 
+                 party_history: Optional[List[PartyHistory]] = None, 
+                 transferee: Optional[int] = None, 
+                 transferor: Optional[int] = None, 
+                 transfer_target: Optional[int] = None, 
+                 original: Optional[int] = None, 
+                 consultation: Optional[int] = None, 
+                 target_dialog: Optional[int] = None, 
+                 campaign: Optional[str] = None, 
+                 interaction: Optional[str] = None, 
+                 skill: Optional[str] = None, 
+                 duration: Optional[float] = None) -> None:
+        """
+        Initialize a Dialog object.
+
+        :param type: the type of the dialog (e.g. "text", "audio", etc.)
+        :type type: str
+        :param start: the start time of the dialog
+        :type start: datetime
+        :param parties: the parties involved in the dialog
+        :type parties: List[int]
+        :param originator: the party that originated the dialog
+        :type originator: int or None
+        :param mimetype: the MIME type of the dialog body
+        :type mimetype: str or None
+        :param filename: the filename of the dialog body
+        :type filename: str or None
+        :param body: the body of the dialog
+        :type body: str or None
+        :param encoding: the encoding of the dialog body
+        :type encoding: str or None
+        :param url: the URL of the dialog
+        :type url: str or None
+        :param alg: the algorithm used to sign the dialog
+        :type alg: str or None
+        :param signature: the signature of the dialog
+        :type signature: str or None
+        :param disposition: the disposition of the dialog
+        :type disposition: str or None
+        :param party_history: the history of parties involved in the dialog
+        :type party_history: List[PartyHistory] or None
+        :param transferee: the party that the dialog was transferred to
+        :type transferee: int or None
+        :param transferor: the party that transferred the dialog
+        :type transferor: int or None
+        :param transfer_target: the target of the transfer
+        :type transfer_target: int or None
+        :param original: the original dialog
+        :type original: int or None
+        :param consultation: the consultation dialog
+        :type consultation: int or None
+        :param target_dialog: the target dialog
+        :type target_dialog: int or None
+        :param campaign: the campaign that the dialog is associated with
+        :type campaign: str or None
+        :param interaction: the interaction that the dialog is associated with
+        :type interaction: str or None
+        :param skill: the skill that the dialog is associated with
+        :type skill: str or None
+        :param duration: the duration of the dialog
+        :type duration: float or None
+        """
+        self.type = type
+        self.start = start
+        self.parties = parties
+        self.originator = originator
+        self.mimetype = mimetype
+        self.filename = filename
+        self.body = body
+        self.encoding = encoding
+        self.url = url
+        self.alg = alg
+        self.signature = signature
+        self.disposition = disposition
+        self.party_history = party_history
+        self.transferee = transferee
+        self.transferor = transferor
+        self.transfer_target = transfer_target
+        self.original = original
+        self.consultation = consultation
+        self.target_dialog = target_dialog
+        self.campaign = campaign
+        self.interaction = interaction
+        self.skill = skill
+        self.duration = duration
+
+    def to_dict(self):
+        """
+        Returns a dictionary representation of the Dialog object.
+
+        :return: a dictionary containing the Dialog object's attributes
+        :rtype: dict
+        """
+        dialog_dict = {
+            "type": self.type,
+            "start": self.start.isoformat(),
+            "duration": self.duration,
+            "parties": self.parties,
+            "originator": self.originator,
+            "mimetype": self.mimetype,
+            "filename": self.filename,
+            "body": self.body,
+            "encoding": self.encoding,
+            "url": self.url,
+            "alg": self.alg,
+            "signature": self.signature,
+            "disposition": self.disposition,
+            "party_history": (
+                [party_history.to_dict() for party_history in self.party_history]
+                if self.party_history
+                else None
+            ),
+            "transferee": self.transferee,
+            "transferor": self.transferor,
+            "transfer_target": self.transfer_target,
+            "original": self.original,
+            "consultation": self.consultation,
+            "target_dialog": self.target_dialog,
+            "campaign": self.campaign,
+            "interaction": self.interaction,
+            "skill": self.skill
+        }
+        return {k: v for k, v in dialog_dict.items() if v is not None} 
+    
+    def add_external_data(self, url: str, filename: str, mimetype: str) -> None:
+        """
+        Add external data to the dialog.
+
+        :param url: the URL of the external data
+        :type url: str
+        :return: None
+        :rtype: None
+        """
+        response = requests.get(url)
+        if response.status_code == 200:
+            self.body = response.text
+            self.mimetype = response.headers["Content-Type"]
+        else:
+            raise Exception(f"Failed to fetch external data: {response.status_code}")
+        
+        # Overide the filename if provided, otherwise use the filename from the URL
+        if filename:
+            self.filename = filename
+        else:
+            self.filename = url.split("/")[-1]
+
+        # Overide the mimetype if provided, otherwise use the mimetype from the URL
+        if mimetype:
+            self.mimetype = mimetype
+            
+        # Calculate the SHA-256 hash of the body as the signature
+        self.alg = "sha256"
+        self.encoding = "base64url"
+        self.signature = base64.urlsafe_b64encode(hashlib.sha256(self.body.encode()).digest()).decode()
+
+    def add_inline_data(self, body: str, filename: str, mimetype: str) -> None:
+        """
+        Add inline data to the dialog.
+
+        :param body: the body of the inline data
+        :type body: str
+        :param filename: the filename of the inline data
+        :type filename: str
+        :param mimetype: the mimetype of the inline data
+        :type mimetype: str
+        :return: None
+        :rtype: None
+        """
+        self.body = body
+        self.mimetype = mimetype
+        self.filename = filename
+        self.alg = "sha256"
+        self.encoding = "base64url"
+        self.signature = base64.urlsafe_b64encode(
+            hashlib.sha256(self.body.encode()).digest()).decode()
+        
+    # Check if the dialog is an external data dialog
+    def is_external_data(self) -> bool:
+        return self.url is not None
+      
+    # Check if the dialog is an inline data dialog
+    def is_inline_data(self) -> bool:
+        return self.body is not None
+    
+    
+    # Check if the dialog is a text dialog
+    def is_text(self) -> bool:
+        return self.mimetype == "text/plain"
+    
+    
+    # Check if the dialog is an audio dialog
+    def is_audio(self) -> bool:
+        return self.mimetype in ["audio/x-wav", "audio/x-mp3", "audio/x-mp4", "audio/ogg"]
+    
+    
+    # Check if the dialog is a video dialog
+    def is_video(self) -> bool:
+        return self.mimetype in ["video/x-mp4", "video/ogg"]
+    
+    # Check if the dialog is an email dialog
+    def is_email(self) -> bool:
+        return self.mimetype == "message/rfc822"
+    
+    # Check to see if it's an external data dialog, that the contents are valid by 
+    # checking the hash of the body against the signature
+    def is_external_data_changed(self) -> bool:
+        if not self.is_external_data():
+            return False
+        try:
+            body_hash = base64.urlsafe_b64decode(self.signature.encode())
+            return hashlib.sha256(self.body.encode()).digest() != body_hash
+        except Exception as e:
+            print(e)
+            return True
+        
+    # Convert the dialog from an external data dialog to an inline data dialog
+    # by reading the contents from the URL then adding the contents to the body
+    def to_inline_data(self) -> None:
+        # Read the contents from the URL
+        response = requests.get(self.url)
+        if response.status_code == 200:
+            self.body = response.text
+            self.mimetype = response.headers["Content-Type"]
+        else:
+            raise Exception(f"Failed to fetch external data: {response.status_code}")
+
+        # Calculate the SHA-256 hash of the body as the signature
+        self.alg = "sha256"
+        self.encoding = "base64url"
+        self.signature = base64.urlsafe_b64encode(hashlib.sha256(self.body.encode()).digest()).decode()
+        
+        # Overide the filename if provided, otherwise use the filename from the URL
+        if self.filename:
+            self.filename = self.filename
+        else:
+            self.filename = self.url.split("/")[-1]
+
+        # Overide the mimetype if provided, otherwise use the mimetype from the URL
+        if self.mimetype:
+            self.mimetype = self.mimetype
+
+        # Add the body to the dialog
+        self.add_inline_data(self.body, self.filename, self.mimetype)