labfreed 0.3.0a0__py3-none-any.whl → 0.3.0a1__py3-none-any.whl

labfreed/__init__.py

@@ -2,7 +2,7 @@
 Python implementation of LabFREED building blocks
 '''
 
-__version__ = "0.3.0a"
+__version__ = "0.3.0a1"
 
 from labfreed.pac_id import *  # noqa: F403
 from labfreed.pac_cat import * # noqa: F403

labfreed/labfreed_extended/app/app_infrastructure.py

@@ -0,0 +1,104 @@
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import requests
+
+from labfreed.pac_attributes.client.attribute_cache import MemoryAttributeCache
+from labfreed.pac_attributes.client.client import AttributeClient, attribute_request_default_callback_factory
+from labfreed.pac_attributes.well_knonw_attribute_keys import MetaAttributeKeys
+from labfreed.well_known_extensions.display_name_extension import DisplayNameExtension
+from labfreed_extended.app.pac_info import PacInfo
+from labfreed.pac_id.pac_id import PAC_ID
+from labfreed.pac_id_resolver.resolver import PAC_ID_Resolver, cit_from_str
+from labfreed.pac_id_resolver.services import ServiceGroup
+
+        
+
+
+
+class Labfreed_App_Infrastructure():
+    def __init__(self, markup = 'rich', language_preferences:list[str]|str='en', http_client:requests.Session|None=None):
+        if isinstance(language_preferences, str):
+            language_preferences = [language_preferences]
+        self._language_preferences = language_preferences
+        
+        self._resolver = PAC_ID_Resolver()
+        
+        if not http_client:
+            http_client = requests.Session()
+        self._http_client= http_client
+        callback = attribute_request_default_callback_factory(http_client)
+            
+        self._attribute_client = AttributeClient(http_post_callback=callback, cache_store=MemoryAttributeCache())
+
+
+    def add_cit(self, cit:str):
+        cit = cit_from_str(cit)
+        if not cit:
+            raise ValueError('the cit could not be parsed. Neither as v1 or v2')
+        self._resolver._cits.append(cit)
+        
+        
+    def process_pac(self, pac_url, markup=None):
+        if not isinstance(pac_url, PAC_ID):
+            pac = PAC_ID.from_url(pac_url)
+        else:
+            pac = pac_url
+        service_groups = self._resolver.resolve(pac, check_service_status=False)
+        
+        pac_info = PacInfo(pac_id=pac)
+                       
+        # update service states
+        (sg.update_states() for sg in service_groups)
+               
+        # Services
+        sg_user_handovers = []
+        for sg in service_groups:
+            user_handovers = [s  for s in sg.services if s.service_type == 'userhandover-generic']
+            
+            if user_handovers:
+                sg_user_handovers.append(ServiceGroup(origin=sg.origin, services=user_handovers))
+        pac_info.user_handovers = sg_user_handovers
+        
+        # Attributes
+        attribute_groups = []
+        for sg in service_groups:  
+            attributes_urls = [s.url  for s in sg.services if s.service_type == 'attributes-generic']
+            for url in attributes_urls:
+                ags = self._attribute_client.get_attributes(url, pac_id=pac.to_url(include_extensions=False), language_preferences=self._language_preferences)
+                if ags:
+                    attribute_groups.extend(ags)
+        pac_info.attributes = attribute_groups
+        
+        if dn := pac.get_extension('N'):
+            dn = DisplayNameExtension.from_extension(dn)
+            pac_info.display_name = dn.display_name or ""
+        # there can be a display name in attributes, too
+        if meta := [ag for ag in pac_info.attributes if ag.key == MetaAttributeKeys.GROUPKEY.value]:
+            dn_attr = [a for a in meta[0].attributes if a.key == MetaAttributeKeys.DISPLAYNAME.value]
+            if dn_attr: 
+                dn = dn_attr[0].value
+                pac_info.display_name += f'  ( aka {dn} )'
+              
+        return pac_info
+    
+    
+    
+    def update_user_handover_states(self, services, session:requests.Session = None):
+        '''Triggers each service to check if the url can be reached'''
+        if not _has_internet_connection():
+            raise ConnectionError("No Internet Connection")
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            futures = [executor.submit(s.check_service_status, session=session) for s in services]
+            for _ in as_completed(futures):
+                pass  # just wait for all to finish
+            
+            
+def _has_internet_connection():
+    try:
+        requests.head("https://1.1.1.1", timeout=3)
+        return True
+    except requests.RequestException:
+        return False
+                
+                

labfreed/labfreed_extended/app/pac_info.py

@@ -0,0 +1,79 @@
+
+
+from pydantic import BaseModel, Field
+from labfreed_extended.pac_attributes.py_attributes import pyAttribute, pyAttributes
+from labfreed.pac_cat.pac_cat import PAC_CAT
+from labfreed.pac_id.pac_id import PAC_ID
+from labfreed.pac_id_resolver.services import ServiceGroup
+from labfreed_extended.utilities.formatted_print import StringIOLineBreak
+
+
+class PacInfo(BaseModel):
+    """A convenient collection of information about a PAC-ID"""
+    pac_id:PAC_ID
+    display_name:str|None = None
+    user_handovers: list[ServiceGroup] = Field(default_factory=list)
+    attributes:pyAttributes = Field(default_factory=list)
+    
+    @property
+    def pac_url(self):
+        return self.pac_id.to_url(include_extensions=False)
+    
+    @property
+    def main_category(self):
+        if isinstance(self.pac_id, PAC_CAT):
+            return self.pac_id.categories[0]
+        else:
+            return None
+        
+    @property
+    def attached_data(self):
+        return self.pac_id.get_extension_of_type('TREX')
+    
+    @property
+    def summary(self):
+        return self.pac_id.get_extension('SUM')
+    
+    
+    
+    def format_for_print(self, markup:str='rich') -> str:
+        
+        printout = StringIOLineBreak(markup=markup)
+        
+        printout.write(f"for {self.pac_url}")
+        
+        printout.title1("Info")
+        printout.key_value("Display Name", self.display_name)
+        
+        if isinstance(self.pac_id, PAC_CAT):
+            printout.title1("Categories")
+            for c in self.pac_id.categories:
+                category_name = c.__class__.__name__
+                printout.title2(category_name)
+                for k,v in c.segments_as_dict().items():
+                    printout.key_value(k, v)
+                
+                    
+        printout.title1("Services")
+        for sg in self.user_handovers:           
+            printout.title2(f"(from {sg.origin})")
+            for s in sg.services:
+                printout.link(s.service_name, s.url)          
+        
+        
+        printout.title1("Attributes")
+        for ag in self.attributes:  
+            printout.title2(f'{ag.label} (from {ag.origin})')
+            attributes = pyAttributes.from_payload_attributes(ag.attributes)
+            for k, v in attributes.items():
+                v:pyAttribute
+                #print(f'{k}: ({v.label})           :: {v.value}  ')
+                printout.key_value(v.label, v.value)
+      
+        out =  printout.getvalue()
+
+        return out
+    
+        
+        
+        

labfreed/labfreed_extended/pac_attributes/py_attributes.py

@@ -0,0 +1,123 @@
+
+from datetime import date, datetime, time
+import json
+from typing import  Literal
+import warnings
+from pydantic import RootModel
+
+from labfreed.labfreed_infrastructure import LabFREED_BaseModel
+from labfreed.pac_attributes.api_data_models.response import AttributeBase, BoolAttribute, DateTimeAttribute,  NumericAttribute, NumericValue, ObjectAttribute, ReferenceAttribute, TextAttribute
+from labfreed.pac_id.pac_id import PAC_ID
+from labfreed.trex.python_convenience.quantity import Quantity
+
+
+class pyReference(RootModel[str]):
+    pass
+
+    def __str__(self):
+        return str(self.root)
+
+
+class pyAttribute(LabFREED_BaseModel):
+    key:str
+    label:str = ""
+    value: str|bool|datetime|pyReference|Quantity|int|float|dict|object
+    valid_until: datetime | Literal["forever"] | None = None
+    observed_at: datetime | None = None
+    
+          
+
+class pyAttributes(RootModel[list[pyAttribute]]):
+    def to_payload_attributes(self) -> list[AttributeBase]:
+        return [self._attribute_to_attribute_payload_type(e) for e in self.root]
+            
+    @staticmethod        
+    def _attribute_to_attribute_payload_type(attribute:pyAttribute) -> AttributeBase:
+        common_args = {
+            "key": attribute.key,
+            "label": attribute.label,
+            "observed_at": attribute.observed_at
+        }
+        value = attribute.value
+        
+        if isinstance(value, bool):
+            return  BoolAttribute(value=value, **common_args)
+            
+        elif isinstance(value, datetime | date | time):
+            if not value.tzinfo:
+                warnings.warn(f'No timezone given for {value}. Assuming it is in UTC.')
+            return DateTimeAttribute(value =value, **common_args)
+            # return DateTimeAttribute(value =_date_value_from_python_type(value).value, **common_args)
+            
+           
+        elif isinstance(attribute.value, Quantity|int|float):
+            if not isinstance(attribute.value, Quantity):
+                value = Quantity(value=attribute.value, unit='dimensionless')
+            num_attribute = NumericAttribute(value = NumericValue(magnitude=value.value_as_str(), 
+                                             unit = value.unit),
+                                              **common_args)
+            num_attribute.print_validation_messages()
+            return num_attribute
+        
+        elif isinstance(value, str):
+            # capture quantities in the form of "100.0e5 g/L"
+            if q := Quantity.from_str_with_unit(value):
+                return NumericAttribute(value = NumericValue(magnitude=q.value_as_str(), 
+                                             unit = q.unit),
+                                              **common_args)
+            else:
+                return TextAttribute(value = value, **common_args)
+            
+        elif isinstance(value, pyReference):
+            return ReferenceAttribute(value = value.root, **common_args)
+            
+        elif isinstance(value, PAC_ID):
+            return ReferenceAttribute(value = value.to_url(include_extensions=False), **common_args)
+        
+        
+        
+        else: #this covers the last resort case of arbitrary objects. Must be json serializable.
+            try :
+                value = json.loads(json.dumps(value))
+                return ObjectAttribute(value=value, **common_args)
+            except TypeError as e:  # noqa: F841
+                raise ValueError(f'Invalid Type: {type(value)} cannot be converted to attribute. You may want to use ObjectAttribute, but would have to implement the conversion from your python type yourself.')
+        
+        
+    @staticmethod
+    def from_payload_attributes(attributes:list[AttributeBase]) -> 'pyAttributes':
+        out = dict()
+        for a in attributes:
+            match a:
+                
+                case ReferenceAttribute():
+                    value =  pyReference(a.value)
+                    
+                case NumericAttribute():                                       
+                    value = Quantity.from_str_value(value=a.value.magnitude, unit=a.value.unit)
+
+                case BoolAttribute():
+                    value = a.value
+                    
+                case TextAttribute():
+                    value = a.value
+                    
+                case DateTimeAttribute():                    
+                    value = a.value
+                
+                case ObjectAttribute():
+                    value = a.value
+
+                       
+            attr = pyAttribute(key=a.key, 
+                               label=a.label,
+                               value=value,
+                               observed_at=a.observed_at
+                            #    valid_until=datetime(**_parse_date_time_str(a.valid_until)),
+                            #    observed_at=datetime(**_parse_date_time_str(a.value))
+            )
+            out.update( { a.key: attr } )
+        return out
+            
+            
+        

labfreed/labfreed_extended/pac_attributes/server/attribute_server_factory.py

@@ -0,0 +1,103 @@
+from enum import Enum
+from typing import Any, Callable, Protocol
+
+from flask import Blueprint
+from labfreed.pac_attributes.server.server import AttributeGroupDataSource, AttributeServerRequestHandler, InvalidRequestError, TranslationDataSource
+
+try:
+    from flask import Flask, Response, request
+except ImportError:
+    raise ImportError("Please install labfreed with the [extended] extra: pip install labfreed[extended]")
+
+
+# from fastapi import FastAPI, Request
+
+class Authenticator(Protocol):
+    def __call__(self, request) -> bool: ...
+    
+class NoAuthRequiredAuthenticator(Authenticator):
+    def __call__(self, request) -> bool:
+        return True
+
+class Webframework(Enum):
+    FLASK = "flask"
+    FASTAPI = 'fastapi'
+    
+
+class AttributeServerFactory():
+    @staticmethod
+    def create_server_app( datasources:list[AttributeGroupDataSource], 
+                           default_language:str,
+                           translation_data_sources:list[TranslationDataSource],
+                           authenticator: Authenticator|None,
+                           framework:Webframework=Webframework.FLASK
+                           ):
+        
+        if not authenticator:
+            raise ValueError("authenticator missing. Either define your own authenticator by implementing the 'Authenticator' Protocol, or - if you do not need authentication - explicitly pass a 'NoAuthRequiredAuthenticator' object")
+            
+        request_handler = AttributeServerRequestHandler(data_sources=datasources, 
+                                                        translation_data_sources= translation_data_sources, 
+                                                        default_language=default_language
+                                                        )
+            
+        match(framework):
+            case Webframework.FLASK:
+                app = AttributeFlaskApp(request_handler,authenticator=authenticator)
+                return app
+            case Webframework.FASTAPI:
+                raise NotImplementedError('FastAPI webapp not implemented')
+
+            
+
+
+            
+class AttributeFlaskApp(Flask):
+    def __init__(self, request_handler: AttributeServerRequestHandler, authenticator: Authenticator | None = None, **kwargs: Any):
+        super().__init__(__name__, **kwargs)
+        self.config['ATTRIBUTE_REQUEST_HANDLER'] = request_handler
+        self.config['AUTHENTICATOR'] = authenticator
+        
+        bp = self.create_attribute_blueprint(request_handler, authenticator)
+        self.register_blueprint(bp)
+
+    @staticmethod
+    def create_attribute_blueprint(
+        request_handler: AttributeServerRequestHandler,
+        authenticator: Authenticator | None = None
+    ) -> Blueprint:
+        bp = Blueprint("attribute", __name__)
+
+        @bp.route("/", methods=["POST"])
+        def handle_attribute_request():
+            if authenticator and not authenticator(request):
+                return Response(
+                    "Unauthorized", 401,
+                    {"WWW-Authenticate": 'Basic realm="Login required"'}
+                )
+            try:
+                json_request_body = request.get_data(as_text=True)
+                response_body = request_handler.handle_attribute_request(json_request_body)
+            except InvalidRequestError as e:
+                print(e)
+                return "Invalid request", 400
+            except Exception as e:
+                print(e)
+                return "The request was valid, but the server encountered an error", 500
+            return response_body
+
+        @bp.route("/capabilities", methods=["GET"])
+        def capabilities():
+            return request_handler.capabilities()
+
+        return bp
+    
+    
+
+
+
+    
+
+    
+    
+    

labfreed/labfreed_extended/pac_attributes/server/excel_attribute_data_source.py

@@ -0,0 +1,128 @@
+from datetime import datetime
+
+import os
+from urllib.parse import urlparse
+from cachetools import TTLCache, cached
+
+from labfreed.pac_attributes.api_data_models.response import AttributeGroup
+from labfreed_extended.pac_attributes.py_attributes import pyAttribute, pyAttributes
+from labfreed.pac_attributes.server.server import AttributeGroupDataSource
+
+try:
+    from openpyxl import load_workbook
+except ImportError:
+    raise ImportError("Please install labfreed with the [extended] extra: pip install labfreed[extended]")
+
+
+cache = TTLCache(maxsize=128, ttl=0)
+
+
+class ExcelAttributeDataSource(AttributeGroupDataSource):
+    '''
+    Demonstrates how to analyze the PAC-ID and it's extensions to provide some data
+    '''
+    def __init__(self, file_path:str, cache_duration_seconds:int=0, base_url:str="", *args, **kwargs):
+        self._file_path = file_path
+        self._base_url = base_url
+
+        
+        if is_sharepoint_url(file_path):
+            self._file_location = "sharepoint"
+        else: 
+            self._file_location = "local"
+            
+        super().__init__(*args, **kwargs)
+            
+         
+    def is_static(self) -> bool:
+        return False
+    
+    @property
+    def provides_attributes(self):
+        if self._file_location == "local":
+            rows, last_changed = read_excel_openpyxl(self._file_path)
+            headers = [self._base_url + r for r in rows[0][1:] ]
+        elif self._file_location == "sharepoint":
+            raise NotImplementedError('Sharepoint Access not implemented')
+        return headers
+    
+    
+    def attributes(self, pac_url: str) -> AttributeGroup:
+        if not self._include_extensions:
+            pac_url = pac_url.split('*')[0]
+        
+        if self._file_location == "local":
+            rows, last_changed = read_excel_openpyxl(self._file_path)
+        elif self._file_location == "sharepoint":
+            raise NotImplementedError('Sharepoint Access not implemented')
+        
+        d = get_row_by_first_cell(rows, pac_url, self._base_url)
+        if not d:
+            return None
+        
+        attributes = [pyAttribute(key=k, value=v) for k,v in d.items()]
+        
+            
+        return AttributeGroup(key=self._attribute_group_key, 
+                              attributes=pyAttributes(attributes).to_payload_attributes(),
+                              state_of=last_changed)
+    
+    
+    
+@cached(cache)
+def read_excel_openpyxl(path: str, worksheet: str = None) -> list[tuple]:
+    """
+    Read and cache Excel worksheet as list of rows (including headers),
+    then close the workbook.
+    """
+    wb = load_workbook(filename=path, read_only=True, data_only=True)
+    ws = wb[worksheet] if worksheet else wb.active
+
+    rows = list(ws.iter_rows(values_only=True))
+    
+    last_changed: datetime | None = wb.properties.modified
+    wb.close()  # immediately release the file
+
+    return rows, last_changed  # list of tuples (header + data rows)
+
+
+def get_row_by_first_cell(sheet_rows: list[tuple], match_value: str, base_url:str) -> dict | None:
+    """
+    Takes list of rows and returns the first row where the first cell == match_value,
+    as a dict using headers from the first row.
+    """
+    if not sheet_rows:
+        return None
+
+    headers = sheet_rows[0]
+    for row in sheet_rows[1:]:
+        if not row:
+            continue
+        first = str(row[0]).strip() if row[0] is not None else ""
+        if first == match_value:
+            return {
+                base_url + str(headers[i]).strip(): row[i]
+                for i in range(1, len(headers))
+                if headers[i] is not None
+            }
+
+    return None
+
+        
+        
+def is_sharepoint_url(s: str) -> bool:
+    try:
+        parsed = urlparse(s)
+        if parsed.scheme not in {"http", "https"}:
+            return False
+        if "sharepoint.com" in parsed.netloc or "1drv.ms" in parsed.netloc:
+            return True
+        return False
+    except Exception:
+        return False
+
+def is_local_path(s: str) -> bool:
+    if is_sharepoint_url(s):
+        return False
+    # Treat anything that's not a URL and points to an existing file as a local path
+    return os.path.exists(s)

labfreed/labfreed_extended/utilities/formatted_print.py

@@ -0,0 +1,64 @@
+          
+from io import StringIO
+
+class StringIOLineBreak(StringIO):
+    def __init__(self, *args, markup=None,  **kwargs):
+        self._markup = markup
+        super().__init__(*args, **kwargs)
+    
+    def write(self, s:str):
+        s = s + '\n'
+        super().write(s)
+        
+    def write_indented(self, s:str):
+        s = '    ' + s + '\n'
+        super().write(s)
+        
+    def title1(self, s):
+        if self._markup == 'rich':
+            s = f'[bold][underline]{s}[/underline][/bold]'
+        elif self._markup == 'kivy':
+            s = f'[b][u]{s}[/u][/b]'
+        elif self._markup == 'html':
+            s = f'<h1>{s}</h1>'
+        self.new_section()
+        self.write(s)  
+        
+    def title2(self, s):
+        if self._markup == 'rich':
+            s = f'[bold]{s}[/bold]'
+        elif self._markup == 'kivy':
+            s = f'[b]{s}[/b]'
+        elif self._markup == 'html':
+            s = f'<h2>{s}</h2>'
+        self.new_paragraph()
+        self.write(s) 
+        
+    def key_value(self, k, v):
+        if not k:
+            self.write_indented(v)
+            return
+            
+        if self._markup == 'rich':
+            s = f'[bold]{k}[/bold]:  {v}'
+        elif self._markup == 'kivy':
+            s = f'[b]{k}[/b]:  {v}'
+        elif self._markup == 'html':
+            s = f'<b>{k}</b>:  {v}'
+        self.write_indented(s)
+        
+    def link(self, s, link):
+        if self._markup == 'rich':
+            s = f'[bold]{s}[/bold]:  [link={link}]{link}[/link] '
+        elif self._markup == 'kivy':
+            s = f'[b]{s}[/b]:  [ref={link}]{link}[/ref]'
+        elif self._markup == 'html':
+            s = f'<b>{s}</b>: <a href={link}>{link}</a>' 
+        self.write_indented(s)
+        
+    
+    def new_paragraph(self):
+        super().write('\n')    
+    
+    def new_section(self):
+        super().write('\n\n')

{labfreed-0.3.0a0.dist-info → labfreed-0.3.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labfreed
-Version: 0.3.0a0
+Version: 0.3.0a1
 Summary: Python implementation of LabFREED building blocks
 Author-email: Reto Thürer <thuerer.r@buchi.com>
 Requires-Python: >=3.11

{labfreed-0.3.0a0.dist-info → labfreed-0.3.0a1.dist-info}/RECORD

@@ -1,5 +1,11 @@
-labfreed/__init__.py,sha256=NXi5VbeTAbNd98NSoKvzjqrmIRUlYv0SdoaalKH_8XM,337
+labfreed/__init__.py,sha256=IYsUcim01YjjUCrNxMPI1Sg-waYsQ2jOFpSLVA0XB7E,338
 labfreed/labfreed_infrastructure.py,sha256=YZmU-kgopyB1tvpTR_k_uIt1Q2ezexMrWvu-HaP65IE,10104
+labfreed/labfreed_extended/app/app_infrastructure.py,sha256=fy6eEp1PkHuZoVPT4E3JRziJwoslvl7NC9K6WQRn1Fs,4383
+labfreed/labfreed_extended/app/pac_info.py,sha256=WbjV4oY7aAxLRF__jijmsLoM-SW-mv9x_rR9gS6n4_Y,2598
+labfreed/labfreed_extended/pac_attributes/py_attributes.py,sha256=5VA1NUTJA1L9Su6Rj7dhkAZaW0ZcUR8sI50qbHfY4fc,5138
+labfreed/labfreed_extended/pac_attributes/server/attribute_server_factory.py,sha256=88cV80Yyt459YUkDffnOiuPXQCjKK982YQA6uvc-TaU,3853
+labfreed/labfreed_extended/pac_attributes/server/excel_attribute_data_source.py,sha256=EN9fgzu4hP_1GxhShFet8FYFY-bXgVYG2_r63-HJpME,4317
+labfreed/labfreed_extended/utilities/formatted_print.py,sha256=DcwWP0ix1e_wYNIdceIp6cETkJdG2DqpU8Gs3aZAL40,1930
 labfreed/pac_attributes/well_knonw_attribute_keys.py,sha256=ruHawnr1AffuhdKz1j1Nx67QphvcpmWsObgZhkuwkH0,318
 labfreed/pac_attributes/api_data_models/request.py,sha256=x-GuFYhCIpqAKa1AHs968OfD8O2cJKg14YUw2hTKVg4,1871
 labfreed/pac_attributes/api_data_models/response.py,sha256=czqQ59myLsN4WNgCdI_dnxRG8hSw4YI062XOPydfePU,5715
@@ -50,7 +56,7 @@ labfreed/well_known_keys/labfreed/well_known_keys.py,sha256=p-hXwEEIs7p2SKn9DQeL
 labfreed/well_known_keys/unece/UneceUnits.json,sha256=kwfQSp_nTuWbADfBBgqTWrvPl6XtM5SedEVLbMJrM7M,898953
 labfreed/well_known_keys/unece/__init__.py,sha256=MSP9lmjg9_D9iqG9Yq2_ajYfQSNS9wIT7FXA1c--59M,122
 labfreed/well_known_keys/unece/unece_units.py,sha256=J20d64H69qKDE3XlGdJoXIIh0G-d0jKoiIDsg9an5pk,1655
-labfreed-0.3.0a0.dist-info/licenses/LICENSE,sha256=gHFOv9FRKHxO8cInP3YXyPoJnuNeqrvcHjaE_wPSsQ8,1100
-labfreed-0.3.0a0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-labfreed-0.3.0a0.dist-info/METADATA,sha256=0Fl6mtbyjD7ihk836WY79Shb-hsUXfw-HTbk9cSjYcU,19707
-labfreed-0.3.0a0.dist-info/RECORD,,
+labfreed-0.3.0a1.dist-info/licenses/LICENSE,sha256=gHFOv9FRKHxO8cInP3YXyPoJnuNeqrvcHjaE_wPSsQ8,1100
+labfreed-0.3.0a1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+labfreed-0.3.0a1.dist-info/METADATA,sha256=D-5o498iIUfdmlBvxCx9ErKj_HX5CPu7fpKaeCAmadI,19707
+labfreed-0.3.0a1.dist-info/RECORD,,