sfrs-element-loader 0.1.0__tar.gz

sfrs_element_loader-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: sfrs_element_loader
+Version: 0.1.0
+Summary: A tool to load and inspect SFRS elements from a database using SQLAlchemy
+Author: Achim Andres
+Author-email: Achim Andres <a.andres@gsi.de>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: SQLAlchemy>=1.4
+Requires-Dist: python-dotenv
+Requires-Dist: tabulate

sfrs_element_loader-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "sfrs_element_loader"
+version = "0.1.0"
+description = "A tool to load and inspect SFRS elements from a database using SQLAlchemy"
+authors = [{ name = "Achim Andres", email = "a.andres@gsi.de" }]
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.8"
+dependencies = [
+    "SQLAlchemy>=1.4",
+    "python-dotenv",
+    "tabulate"
+]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

sfrs_element_loader-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sfrs_element_loader-0.1.0/setup.py

@@ -0,0 +1,20 @@
+# setup.py
+from setuptools import setup, find_packages
+
+setup(
+    name='sfrs-element-loader',           # PyPI package name (dashes are fine here)
+    version='0.2.0',
+    description='A tool to load and inspect SFRS elements from a database using SQLAlchemy. First working development.',
+    author='Achim Andres',
+    author_email='a.andres@gsi.de',
+    packages=find_packages(),            # Automatically includes all packages with __init__.py
+    install_requires=[
+        'SQLAlchemy',
+        'tabulate',
+        'python-dotenv'
+    ],
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'Operating System :: OS Independent',
+    ],
+)

sfrs_element_loader-0.1.0/sfrs_element_loader/access_database.py

@@ -0,0 +1,152 @@
+import os
+from dotenv import load_dotenv
+from tabulate import tabulate
+import inspect
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from .model import (
+    Element, Dipole, Quadrupole, Sextupole, Octupole, Steerer, Drift,
+    ExperimentalChamber, EmptyDetector, BeamStopper, ProfileGrid,
+    HorizontalSlit, PlasticScintillator, RotaryWedgeDegrader,
+    SlidableWedgeDegrader, LadderSystemDegrader
+)
+
+class ElementLoader:
+    def __init__(self, env_path: str = '.env'):
+        self._load_env(env_path)
+        self._setup_database()
+        
+    def _load_env(self, env_path: str):
+        load_dotenv(env_path)
+        self.database_uri = os.getenv('SQLALCHEMY_DATABASE_URI')
+        if not self.database_uri:
+            raise ValueError("Database URI not found in environment variables")
+
+    def _setup_database(self):
+        engine = create_engine(self.database_uri)
+        Session = sessionmaker(bind=engine)
+        self.session = Session()
+
+    def load_element_data(self, element_name: str) -> dict:
+        element = self.session.query(Element).filter(Element.element_name == element_name).first()
+        if not element:
+            raise ValueError(f"Element '{element_name}' not found in the database")
+
+        # Dynamically collect fields for the specific subclass of the element
+        model_class = type(element)
+        columns = model_class.__mapper__.column_attrs
+        data = {col.key: getattr(element, col.key) for col in columns}
+
+        # Optional: Add related objects dynamically (like experimental_chamber)
+        # You can inspect relationships using `__mapper__.relationships`
+        for rel in model_class.__mapper__.relationships:
+            related_obj = getattr(element, rel.key)
+            if related_obj:
+                data[rel.key] = {
+                    col.key: getattr(related_obj, col.key)
+                    for col in type(related_obj).__mapper__.column_attrs
+                }
+
+        return data
+    
+    def list_all_optical_elements(self):
+        elements = self.session.query(Element).all()
+        return [element.element_name for element in elements]
+
+
+    def list_all_drifts(self, pprint = False):
+        """
+        Retrieve all Drift elements from the database and optionally print them in a table.
+        Args: pprint (bool, optional): If True, prints the drift data in a fancy grid table. Defaults to False.
+        Returns: List[str]: A list of all drift element names.\n
+        """
+        drifts = self.session.query(Drift).all()
+        drift_data = []
+
+        for drift in drifts:
+            drift_data.append({
+                'element_name': drift.element_name,
+                'location': drift.loc,
+                'high_energy_branch': drift.high_energy_branch,
+                'low_energy_branch': drift.low_energy_branch,
+                'ring_branch': drift.ring_branch,
+            })
+
+        headers = ["Element Name", "High Energy Branch", "Low Energy Branch", "Ring Branch"]
+        table = [
+            [
+                d['element_name'],
+                d['high_energy_branch'],
+                d['low_energy_branch'],
+                d['ring_branch']
+            ]
+            for d in drift_data
+        ]
+        if pprint: print(tabulate(table, headers=headers, tablefmt="fancy_grid"))
+        return [d['element_name'] for d in drift_data]
+    
+    def list_all_dipoles(self, pprint = False):
+        """
+        Retrieve all Dipoles elements from the database and optionally print them in a table.
+        Args: pprint (bool, optional): If True, prints the drift data in a fancy grid table. Defaults to False.
+        Returns: List[str]: A list of all dipole element names.\n
+        """
+        dipoles = self.session.query(Dipole).all()
+        dipole_data = []
+
+        for dipole in dipoles:
+            dipole_data.append({
+                'element_name': dipole.element_name,
+                'location': dipole.loc,
+                'high_energy_branch': dipole.high_energy_branch,
+                'low_energy_branch': dipole.low_energy_branch,
+                'ring_branch': dipole.ring_branch,
+            })
+
+        headers = ["Element Name", "High Energy Branch", "Low Energy Branch", "Ring Branch"]
+        table = [
+            [
+                d['element_name'],
+                d['high_energy_branch'],
+                d['low_energy_branch'],
+                d['ring_branch']
+            ]
+            for d in dipole_data
+        ]
+        if pprint: print(tabulate(table, headers=headers, tablefmt="fancy_grid"))
+        return [d['element_name'] for d in dipole_data]
+
+    def list_all_quadrupoles(self, pprint = False):
+        pass
+
+    def list_all_sextupoles(self, pprint = False):
+        pass
+
+    def list_all_octupoles(self, pprint = False):
+        pass
+
+    def list_all_multipletts(self, pprint = False):
+        """"""
+        pass
+
+    def help(self):
+        print("Available methods:\n")
+        for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
+            if not name.startswith('_') and name != "help":
+                doc = inspect.getdoc(method) or "No description"
+                print(f"{name}:\n{doc}\n")
+
+
+# Example usage
+if __name__ == "__main__":                                                                                                                                                                                                                                                                                                                                                                                              
+    loader = ElementLoader(env_path = '../../.env')
+    element_name = 'FTF1QT21'  # adjust as needed
+    data = loader.load_element_data(element_name)
+    data = loader.list_all_drifts(pprint = False)
+    data = loader.list_all_dipoles(pprint = False)
+    data = loader.list_all_optical_elements()
+    print(data)
+    #loader.help()
+

sfrs_element_loader-0.1.0/sfrs_element_loader/model.py

@@ -0,0 +1,301 @@
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+
+# Base class for all elements
+class Element(db.Model):
+    __tablename__ = 'elements'
+    __table_args__ = {'schema': 'sfrs_component_database'}  
+    id = db.Column(db.Integer, primary_key=True)
+    element_name = db.Column(db.String(100), nullable=False)
+    is_detector = db.Column(db.Boolean, default=False)
+    high_energy_branch = db.Column(db.Boolean, nullable=False, default=False)
+    low_energy_branch = db.Column(db.Boolean, nullable=False, default=False)
+    ring_branch = db.Column(db.Boolean, nullable=False, default=False)
+    loc = db.Column(db.JSON, nullable=True)
+    length = db.Column(db.Float, nullable=True)
+    type = db.Column(db.String(25), nullable=False)  # Discriminator column
+    __mapper_args__ = {
+        'polymorphic_identity': 'element',
+        'polymorphic_on': type
+    }
+
+class ExperimentalChamber(Element):
+    __tablename__ = 'experimental_chambers'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    number_of_detectors = db.Column(db.Integer, nullable=False) 
+    focal_plane = db.Column(db.String(4), nullable = False)
+    __mapper_args__ = {
+        'polymorphic_identity': 'experimental_chamber'
+    }
+
+class EmptyDetector(Element):
+    __tablename__ = 'empty_detectors'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    slot_number = db.Column(db.Integer, nullable=True)
+
+    # Foreign key to the experimental chamber
+    experimental_chamber_id = db.Column(
+        db.Integer, 
+        db.ForeignKey('sfrs_component_database.experimental_chambers.id'), 
+        nullable=True
+    )
+
+    # Disambiguated relationship
+    experimental_chamber = db.relationship(
+        'ExperimentalChamber',
+        backref='empty_detectors',
+        foreign_keys=[experimental_chamber_id]  # this is the fix
+    )
+
+    __mapper_args__ = {
+        'polymorphic_identity': 'empty_detector'
+    }
+
+class BeamStopper(Element):
+    __tablename__ = 'beam_stoppers'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    slot_number = db.Column(db.Integer, nullable=True)
+    pneumatic_actuator_name = db.Column(db.String(15), nullable=False)
+
+    # Foreign key to the experimental chamber
+    experimental_chamber_id = db.Column(
+        db.Integer, 
+        db.ForeignKey('sfrs_component_database.experimental_chambers.id'), 
+        nullable=True
+    )
+
+    # Disambiguated relationship
+    experimental_chamber = db.relationship(
+        'ExperimentalChamber',
+        backref='beam_stoppers',
+        foreign_keys=[experimental_chamber_id]  # this is the fix
+    )
+
+    __mapper_args__ = {
+        'polymorphic_identity': 'beam_stopper'
+    }
+
+class ProfileGrid(Element):
+    __tablename__ = 'profile_grids'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    slot_number = db.Column(db.Integer, nullable=True)
+    grid_name = db.Column(db.String(15), nullable=False) 
+    stepper_motor_name = db.Column(db.String(15), nullable=False) 
+    # Foreign key to the experimental chamber
+    experimental_chamber_id = db.Column(
+        db.Integer, 
+        db.ForeignKey('sfrs_component_database.experimental_chambers.id'), 
+        nullable=True
+    )
+
+    # Disambiguated relationship
+    experimental_chamber = db.relationship(
+        'ExperimentalChamber',
+        backref='profile_grids',
+        foreign_keys=[experimental_chamber_id]  # this is the fix
+    )
+    __mapper_args__ = {
+        'polymorphic_identity': 'profile_grid'
+    }
+
+class HorizontalSlit(Element):
+    __tablename__ = 'horizontal_slits'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    slot_number = db.Column(db.Integer, nullable=True)
+    left_slit_name = db.Column(db.String(15), nullable=False) 
+    right_slit_name = db.Column(db.String(15), nullable=False) 
+    # Foreign key to the experimental chamber
+    experimental_chamber_id = db.Column(
+        db.Integer, 
+        db.ForeignKey('sfrs_component_database.experimental_chambers.id'), 
+        nullable=True
+    )
+
+    # Disambiguated relationship
+    experimental_chamber = db.relationship(
+        'ExperimentalChamber',
+        backref='horizontal_slits',
+        foreign_keys=[experimental_chamber_id]  # this is the fix
+    )
+    __mapper_args__ = {
+        'polymorphic_identity': 'horizontal_slit'
+    }
+
+class PlasticScintillator(Element):
+    __tablename__ = 'plastic_scintillators'
+    __table_args__ = {'schema': 'sfrs_component_database'}  
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    slot_number = db.Column(db.Integer, nullable=True)
+    pneumatic_actuator = db.Column(db.String(15), nullable=False) 
+    # Foreign key to the experimental chamber
+    experimental_chamber_id = db.Column(
+        db.Integer, 
+        db.ForeignKey('sfrs_component_database.experimental_chambers.id'), 
+        nullable=True
+    )
+
+    # Disambiguated relationship
+    experimental_chamber = db.relationship(
+        'ExperimentalChamber',
+        backref='plastic_scintillators',
+        foreign_keys=[experimental_chamber_id]  # this is the fix
+    )
+    __mapper_args__ = {
+        'polymorphic_identity': 'plastic_scintillator'
+    }
+
+class RotaryWedgeDegrader(Element):
+    __tablename__ = 'rotary_wedge_degraders'
+    __table_args__ = {'schema': 'sfrs_component_database'}
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    slot_number = db.Column(db.Integer, nullable=True)
+    stepper_motor = db.Column(db.String(15), nullable=False) 
+    pneumatic_actuator = db.Column(db.String(15), nullable=False) 
+    # Foreign key to the experimental chamber
+    experimental_chamber_id = db.Column(
+        db.Integer, 
+        db.ForeignKey('sfrs_component_database.experimental_chambers.id'), 
+        nullable=True
+    )
+
+    # Disambiguated relationship
+    experimental_chamber = db.relationship(
+        'ExperimentalChamber',
+        backref='rotary_wedge_degraders',
+        foreign_keys=[experimental_chamber_id]  # this is the fix
+    )
+    __mapper_args__ = {
+        'polymorphic_identity': 'rotary_wedge_degrader'
+    }
+
+class SlidableWedgeDegrader(Element):
+    __tablename__ = 'slidable_wedge_degraders'
+    __table_args__ = {'schema': 'sfrs_component_database'}  
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    slot_number = db.Column(db.Integer, nullable=True)
+    stepper_motor = db.Column(db.String(15), nullable=False)
+    # Foreign key to the experimental chamber
+    experimental_chamber_id = db.Column(
+        db.Integer, 
+        db.ForeignKey('sfrs_component_database.experimental_chambers.id'), 
+        nullable=True
+    )
+
+    # Disambiguated relationship
+    experimental_chamber = db.relationship(
+        'ExperimentalChamber',
+        backref='slidable_wedge_degraders',
+        foreign_keys=[experimental_chamber_id]  # this is the fix
+    )
+    __mapper_args__ = {
+        'polymorphic_identity': 'slidable_wedge_degrader'
+    }
+
+class LadderSystemDegrader(Element):
+    __tablename__ = 'ladder_system_degraders'
+    __table_args__ = {'schema': 'sfrs_component_database'}
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    slot_number = db.Column(db.Integer, nullable=True)
+    stepper_motor = db.Column(db.String(15), nullable=False)
+    # Foreign key to the experimental chamber
+    experimental_chamber_id = db.Column(
+        db.Integer, 
+        db.ForeignKey('sfrs_component_database.experimental_chambers.id'), 
+        nullable=True
+    )
+
+    # Disambiguated relationship
+    experimental_chamber = db.relationship(
+        'ExperimentalChamber',
+        backref='ladder_system_degraders',
+        foreign_keys=[experimental_chamber_id]  # this is the fix
+    )
+    __mapper_args__ = {
+        'polymorphic_identity': 'ladder_system_degrader'
+    }
+
+# Derived class for Dipole
+class Dipole(Element):
+    __tablename__ = 'dipoles'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    is_superconducting = db.Column(db.Boolean, nullable = False)
+    __mapper_args__ = {
+        'polymorphic_identity': 'dipole'
+    }
+
+# Derived class for Quadrupole
+class Quadrupole(Element):
+    __tablename__ = 'quadrupoles'
+    __table_args__ = {'schema': 'sfrs_component_database'}  
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    multiplett_name = db.Column(db.String(10), nullable=True)
+    multiplett_company_name = db.Column(db.String(9), nullable=True)
+    multiplett_type = db.Column(db.String(10), nullable=True)
+    is_superconducting = db.Column(db.Boolean, nullable = False)
+    is_horizontal_focusing = db.Column(db.Boolean, nullable=False)
+    loadline_data = db.Column(db.PickleType, nullable=True)
+    position_in_multiplett = db.Column(db.Integer, nullable = True)
+    __mapper_args__ = {
+        'polymorphic_identity': 'quadrupole'
+    }
+
+# Derived class for Sextupoles
+class Sextupole(Element):
+    __tablename__ = 'sextupoles'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    multiplett_name = db.Column(db.String(10), nullable=True)
+    multiplett_company_name = db.Column(db.String(9), nullable=True)
+    multiplett_type = db.Column(db.String(10), nullable=True)
+    is_superconducting = db.Column(db.Boolean, nullable = False)
+    position_in_multiplett = db.Column(db.Integer, nullable = True)
+    __mapper_args__ = {
+        'polymorphic_identity': 'sextupole'
+    }
+
+# Derived class for Octupole
+class Octupole(Element):
+    __tablename__ = 'octupoles'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    multiplett_name = db.Column(db.String(10), nullable=True)
+    multiplett_company_name = db.Column(db.String(9), nullable=True)
+    multiplett_type = db.Column(db.String(10), nullable=True)
+    is_superconducting = db.Column(db.Boolean, nullable = False)
+    position_in_multiplett = db.Column(db.Integer, nullable = True)
+    __mapper_args__ = {
+        'polymorphic_identity': 'octupole'
+    }
+
+# Derived class for Steerer
+class Steerer(Element):
+    __tablename__ = 'steerer'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    multiplett_name = db.Column(db.String(10), nullable=True)
+    multiplett_company_name = db.Column(db.String(9), nullable=True)
+    multiplett_type = db.Column(db.String(10), nullable=True)
+    is_superconducting = db.Column(db.Boolean, nullable = False)
+    is_vertical_bending = db.Column(db.Boolean, nullable=False)
+    position_in_multiplett = db.Column(db.Integer, nullable = True)
+    total_number_of_elements_in_multiplett = db.Column(db.Integer, nullable = True)
+    __mapper_args__ = {
+        'polymorphic_identity': 'steerer'
+    }
+
+# Derived class for Drifts
+class Drift(Element):
+    __tablename__ = 'beamlines'
+    __table_args__ = {'schema': 'sfrs_component_database'} 
+    id = db.Column(db.Integer, db.ForeignKey('sfrs_component_database.elements.id'), primary_key=True)
+    __mapper_args__ = {
+        'polymorphic_identity': 'drift'
+    }
+

sfrs_element_loader-0.1.0/sfrs_element_loader.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: sfrs_element_loader
+Version: 0.1.0
+Summary: A tool to load and inspect SFRS elements from a database using SQLAlchemy
+Author: Achim Andres
+Author-email: Achim Andres <a.andres@gsi.de>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: SQLAlchemy>=1.4
+Requires-Dist: python-dotenv
+Requires-Dist: tabulate

sfrs_element_loader-0.1.0/sfrs_element_loader.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+sfrs_element_loader/__init__.py
+sfrs_element_loader/access_database.py
+sfrs_element_loader/model.py
+sfrs_element_loader.egg-info/PKG-INFO
+sfrs_element_loader.egg-info/SOURCES.txt
+sfrs_element_loader.egg-info/dependency_links.txt
+sfrs_element_loader.egg-info/requires.txt
+sfrs_element_loader.egg-info/top_level.txt

sfrs_element_loader-0.1.0/sfrs_element_loader.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sfrs_element_loader-0.1.0/sfrs_element_loader.egg-info/requires.txt

@@ -0,0 +1,3 @@
+SQLAlchemy>=1.4
+python-dotenv
+tabulate

sfrs_element_loader-0.1.0/sfrs_element_loader.egg-info/top_level.txt

@@ -0,0 +1 @@
+sfrs_element_loader