PyDPEET 0.2.0__py3-none-any.whl

pydpeet/__init__.py

@@ -0,0 +1,56 @@
+"""
+Auto-generated __init__ file.
+Created: 2026-03-06 15:11:49
+"""
+
+# Re-export selected names from source modules
+
+from pydpeet.citations.citeme import print_references, write_to_bibtex
+from pydpeet.io.convert import convert
+from pydpeet.io.map import mapping
+from pydpeet.io.read import read
+from pydpeet.io.write import write
+from pydpeet.process.analyze.capacity import add_capacity
+from pydpeet.process.analyze.configs.battery_config import (
+    BatteryConfig,
+    battery_config_default,
+    hakadi_nmc_1500,
+    lgm50lt_nmc_4800,
+)
+from pydpeet.process.analyze.extract.ocv import extract_ocv_iocv
+from pydpeet.process.analyze.resistance import add_resistance_internal
+from pydpeet.process.analyze.soc import SocMethod, add_soc
+from pydpeet.process.merge.series import merge_into_series
+from pydpeet.process.sequence.step_analyzer import add_primitive_segments, extract_sequence_overview
+from pydpeet.process.sequence.utils.postprocessing.df_primitives_correction import df_primitives_correction
+from pydpeet.process.sequence.utils.postprocessing.filter_df import filter_and_split_df_by_blocks
+from pydpeet.process.sequence.utils.postprocessing.generate_instructions import generate_instructions
+from pydpeet.process.sequence.utils.visualize.visualize_data import visualize_phases
+from pydpeet.utils.logging_style import set_logging_style
+
+# Public API for this package
+__all__ = [
+    "BatteryConfig",
+    "SocMethod",
+    "add_capacity",
+    "add_primitive_segments",
+    "add_resistance_internal",
+    "add_soc",
+    "battery_config_default",
+    "convert",
+    "df_primitives_correction",
+    "extract_ocv_iocv",
+    "extract_sequence_overview",
+    "filter_and_split_df_by_blocks",
+    "generate_instructions",
+    "hakadi_nmc_1500",
+    "lgm50lt_nmc_4800",
+    "mapping",
+    "merge_into_series",
+    "print_references",
+    "read",
+    "set_logging_style",
+    "visualize_phases",
+    "write",
+    "write_to_bibtex",
+]

pydpeet/citations/__init__.py

@@ -0,0 +1,7 @@
+"""
+Auto-generated __init__ file.
+Created: 2026-03-06 15:11:49
+"""
+
+# Restrictive package init: start with no public API
+__all__ = []

pydpeet/citations/citeme.py

@@ -0,0 +1,397 @@
+"""
+TODO Code taken from : https://github.com/citation-file-format/citeme/tree/master
+"""
+
+import functools
+import json
+import pathlib
+
+from bibtexparser.bibdatabase import BibDatabase
+from bibtexparser.bwriter import BibTexWriter
+from six import iteritems
+
+from .html_writer import BibHtmlWriter
+
+
+# Singleton!
+class CiteMe:
+    # Class variable!
+    __instance = None
+    __check_fields = True
+    __pedantic = False
+
+    # Override new to make this a singleton class
+    # taken from http://python-3-patterns-idioms-test.readthedocs.io/en/latest/Singleton.html#id5
+    def __new__(cls):
+        if CiteMe.__instance is None:
+            CiteMe.__instance = object.__new__(cls)
+            # Initialization of class here, because
+            # __init__ gets called multiple times
+            CiteMe.__instance.references = {}
+        return CiteMe.__instance
+
+    def add_reference(self, citation):
+        if CiteMe.__check_fields:
+            citation.checkFields(CiteMe.__pedantic)
+
+        if citation.type not in self.references:
+            self.references[citation.type] = {}
+
+        if citation.handle not in self.references[citation.type]:
+            self.references[citation.type][citation.handle] = citation
+
+    def print_references(self):
+        for ref_type in self.references:
+            for _, citation in iteritems(self.references[ref_type]):
+                # print(ref_type, handle, citation.description)
+                print(citation.description)
+
+    def write_to_bibtex(self, filename):
+        db = BibDatabase()
+        db.entries = []
+        for ref_type in self.references:
+            for handle, citation in iteritems(self.references[ref_type]):
+                description = citation.description
+                description["ENTRYTYPE"] = citation.type
+                description["ID"] = handle
+                db.entries.append(description)
+        writer = BibTexWriter()
+        with open(filename, "w") as bibfile:
+            bibfile.write(writer.write(db))
+
+    def write_to_html(self, filename, full=False):
+        with open(filename, "w") as bibfile:
+            bibfile.write(self.get_html(full=full))
+
+    def get_html(self, full=False):
+        db = BibDatabase()
+        db.entries = []
+        for ref_type in self.references:
+            for handle, citation in iteritems(self.references[ref_type]):
+                description = citation.description
+                description["ENTRYTYPE"] = citation.type
+                description["ID"] = handle
+                db.entries.append(description)
+        writer = BibHtmlWriter()
+        return writer.write(db, full=full)
+
+    def references_by_type(self, ref_type):
+        if ref_type in self.references:
+            return self.references["ref_type"]
+        else:
+            return []
+
+    @staticmethod
+    def set_pedantic(value):
+        CiteMe.__pedantic = value
+
+    @staticmethod
+    def set_check_fields(value):
+        CiteMe.__check_fields = value
+
+
+class Citation:
+    def __init__(self, handle, description, the_type):
+        self.handle = handle
+        self.description = description
+        self.type = the_type
+
+        # optional and required field
+        # from https://en.wikipedia.org/wiki/BibTeX
+        self._required = []
+        self._optional = []
+        self._general_options = ["url", "doi"]
+
+    def __call__(self, f):
+        def wrapped_f(*args, **kwargs):
+            CiteMe().add_reference(self)
+            return f(*args, **kwargs)
+
+        return wrapped_f
+
+    def checkFields(self, pedantic):
+        missing = []
+        too_many = []
+        if self._required:
+            for field in self._required:
+                if isinstance(field, tuple):
+                    if not any(f in self.description for f in field):
+                        missing.append(field)
+                elif field not in self.description:
+                    missing.append(field)
+
+        if pedantic and self._optional:
+            self._optional.extend(self._general_options)
+            for field in self.description:
+                found = False
+                for option in self._optional:
+                    if isinstance(option, tuple):
+                        if field in option:
+                            found = True
+                    elif field == option:
+                        found = True
+                for option in self._required:
+                    if isinstance(option, tuple):
+                        if field in option:
+                            found = True
+                    elif field == option:
+                        found = True
+                if not found:
+                    too_many.append(field)
+
+        if missing or too_many:
+            raise Exception(
+                f"Fields for citation of type {self.type} is not correct:\n"
+                f"required fields: {self._required}\n"
+                f"optional fields: {self._optional}\n\n"
+                f"missing fields: {missing}\n"
+                f"non supported fields: {too_many}\n\n"
+                f"found fields: {self.description.keys()}"
+            )
+
+
+class article(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "article")
+        self._required = ["author", "title", "journal", "year", "volume"]
+        self._optional = ["number", "pages", "month", "note", "key"]
+
+
+class book(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "book")
+        self._required = [("author", "editor"), "title", "publisher", "year"]
+        self._optional = [("volume", "number"), "series", "address", "edition", "month", "note", "key"]
+
+
+class booklet(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "booklet")
+        self._required = ["title"]
+        self._optional = ["author", "howpublished", "address", "month", "year", "note", "key"]
+
+
+class inbook(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "inbook")
+        self._required = [("author", "editor"), "title", ("chapter", "pages"), "publisher", "year"]
+        self._optional = [("volume", "number"), "series", "type", "address", "edition", "month", "note", "key"]
+
+
+class incollection(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "incollection")
+        self._required = ["author", "title", "booktitle", "publisher", "year"]
+        self._optional = [
+            "editor",
+            ("volume", "number"),
+            "series",
+            "type",
+            "chapter",
+            "pages",
+            "address",
+            "edition",
+            "month",
+            "note",
+            "key",
+        ]
+
+
+class inproceedings(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "inproceedings")
+        self._required = ["author", "title", "booktitle", "year"]
+        self._optional = [
+            "editor",
+            ("volume", "number"),
+            "series",
+            "pages",
+            "address",
+            "month",
+            "organization",
+            "publisher",
+            "note",
+            "key",
+        ]
+
+
+# conference has the same fields as inproceedings
+class conference(inproceedings):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "conference")
+
+
+class manual(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "manual")
+        self._required = ["title"]
+        self._optional = ["author", "organization", "address", "edition", "month", "year", "note", "key"]
+
+
+class mastersthesis(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "mastersthesis")
+        self._required = ["author", "title", "school", "year"]
+        self._optional = ["type", "address", "month", "note", "key"]
+
+
+class bachelorthesis(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "bachelorthesis")
+        self._required = ["author", "title", "school", "year"]
+        self._optional = ["type", "address", "month", "note", "key"]
+
+
+class internship(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "internship")
+        self._required = ["author", "title", "school", "year"]
+        self._optional = ["type", "address", "month", "note", "key"]
+
+
+class misc(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "misc")
+        self._optional = ["author", "title", "howpublished", "month", "year", "note", "key"]
+
+
+class phdthesis(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "phdthesis")
+        self._required = ["author", "title", "school", "year"]
+        self._optional = ["type", "address", "month", "note", "key"]
+
+
+class proceedings(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "proceedings")
+        self._required = ["title", "year"]
+        self._optional = [
+            "editor",
+            ("volume", "number"),
+            "series",
+            "address",
+            "month",
+            "publisher",
+            "organization",
+            "note",
+            "key",
+        ]
+
+
+class techreport(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "techreport")
+        self._required = ["author", "title", "institution", "year"]
+        self._optional = ["type", "number", "address", "month", "note", "key"]
+
+
+class unpublished(Citation):
+    def __init__(self, handle, description):
+        super().__init__(handle, description, "unpublished")
+        self._required = ["author", "title", "note"]
+        self._optional = ["month", "year", "key"]
+
+
+_CITATION_TYPES = {
+    "article": article,
+    "book": book,
+    "booklet": booklet,
+    "inbook": inbook,
+    "incollection": incollection,
+    "inproceedings": inproceedings,
+    "conference": conference,
+    "manual": manual,
+    "mastersthesis": mastersthesis,
+    "bachelorthesis": bachelorthesis,
+    "internship": internship,
+    "misc": misc,
+    "phdthesis": phdthesis,
+    "proceedings": proceedings,
+    "techreport": techreport,
+    "unpublished": unpublished,
+}
+
+_REFERENCE_CACHE = None
+_REFERENCE_JSON_PATH = pathlib.Path(__file__).resolve().parent / "citations.json"
+
+
+def _load_reference_db():
+    global _REFERENCE_CACHE
+
+    if _REFERENCE_CACHE is None:
+        with open(_REFERENCE_JSON_PATH, encoding="utf-8") as f:
+            data = json.load(f)
+
+        _REFERENCE_CACHE = {entry["id"]: entry for entry in data}
+        _REFERENCE_CACHE["__source__"] = str(_REFERENCE_JSON_PATH)
+
+    return _REFERENCE_CACHE
+
+
+def from_id(ref_id):
+    """
+    Usage:
+        @citeme.from_id("Daniel_BA")
+        def foo():
+            ...
+    """
+
+    def _decorator(func):
+        db = _load_reference_db()
+
+        if ref_id not in db:
+            raise KeyError(f"Reference ID '{ref_id}' not found in {db.get('__source__')}")
+
+        entry = dict(db[ref_id])  # copy
+        ref_type = entry.pop("type")
+        handle = entry.pop("id")
+
+        if ref_type not in _CITATION_TYPES:
+            raise ValueError(f"Unsupported citation type '{ref_type}'")
+
+        citation_cls = _CITATION_TYPES[ref_type]
+        citation = citation_cls(handle, entry)
+
+        @functools.wraps(func)
+        def wrapped(*args, **kwargs):
+            CiteMe().add_reference(citation)
+            return func(*args, **kwargs)
+
+        return wrapped
+
+    return _decorator
+
+
+def set_pedantic(value):
+    CiteMe.set_pedantic(value)
+
+
+def set_check_fields(value):
+    CiteMe.set_check_fields(value)
+
+
+def print_references():
+    CiteMe().print_references()
+
+
+def write_to_bibtex(filename):
+    CiteMe().write_to_bibtex(filename)
+
+
+def write_to_html(filename, full=False):
+    CiteMe().write_to_html(filename, full=full)
+
+
+def get_html(full=False):
+    return CiteMe().get_html(full=full)
+
+
+try:
+    from IPython.core.display import HTML, display
+except ImportError:
+    pass
+else:
+
+    def display_bibliography():
+        display(HTML(get_html(full=False)))

pydpeet/citations/html_writer.py

@@ -0,0 +1,137 @@
+"""
+TODO Code taken from : https://github.com/citation-file-format/citeme/tree/master
+"""
+
+import logging
+
+from bibtexparser.bibdatabase import BibDatabase
+from bibtexparser.bwriter import BibTexWriter
+
+try:
+    import BeautifulSoup
+except ImportError:
+    bs = None
+    try:
+        from bs4 import BeautifulSoup
+    except ImportError:
+        bs4 = None
+    else:
+        bs4 = BeautifulSoup
+else:
+    bs = BeautifulSoup.BeautifulSoup
+
+logger = logging.getLogger(__name__)
+
+
+class BibHtmlWriter(BibTexWriter):
+    def __init__(self):
+        super().__init__()
+        self.display_order = [
+            "author",
+            "title",
+            "booktitle",
+            "journal",
+            "editor",
+            "volume",
+            "number",
+            "series",
+            "publisher",
+            "year",
+            "pages",
+            "url",
+            "doi",
+        ]
+        self.html_template = """
+<html>
+<head>
+    <link rel="stylesheet" href="css/bibstyle.css" />
+</head>
+</html>
+<body>
+    {0}
+</body>
+"""
+
+    def write(self, bib_database, full=False):
+        """
+        Converts a bibliographic database to a html-formatted string.
+        :param bib_database: bibliographic database to be converted to a BibTeX string
+        :type bib_database: BibDatabase
+        :return: BibTeX-formatted string
+        :rtype: str or unicode
+        """
+        html = super().write(bib_database)
+        if full:
+            html = self.html_template.format(html)
+
+        soup = None
+        if bs4:
+            soup = bs4(html, "html5lib")
+        if bs:
+            soup = bs(html)
+
+        if soup:
+            return soup.prettify()
+        else:
+            return html
+
+    def _entries_to_bibtex(self, bib_database):
+        html = '<fieldset class="the_bibliography">\n<legend>The Bibliography</legend>'
+        if self.order_entries_by:
+            # TODO: allow sort field does not exist for entry
+            entries = sorted(bib_database.entries, key=lambda x: BibDatabase.entry_sort_key(x, self.order_entries_by))
+        else:
+            entries = bib_database.entries
+
+        if self.align_values:
+            # determine maximum field width to be used
+            widths = [max(map(len, entry.keys())) for entry in entries]
+            self._max_field_width = max(widths)
+
+        html += '<ol class="references">'
+        for entry in entries:
+            html += "<li>" + self._entry_to_bibtex(entry) + "</li>"
+
+        html += "</ol>"
+        html += "</fieldset>"
+        return html
+
+    def _entry_to_bibtex(self, entry):
+        html = ""
+        # Write BibTeX key
+        html += '<cite id="' + entry["ID"] + '" class="bib-entry">'
+
+        # create display_order of fields for this entry
+        # only those keys which are both in self.display_order and in entry.keys
+        display_order = [i for i in self.display_order if i in entry]
+
+        # Write field = value lines
+        for field in [i for i in display_order if i not in ["ENTRYTYPE", "ID"]]:
+            try:
+                if field == "url":
+                    html += (
+                        "\n<span class='bib-entry-field bib-entry-url bib-entry-"
+                        + "{0:<{1}}".format(field, self._max_field_width)
+                        + f"'><a href='{entry[field]}'>{entry[field]}<a></span>"
+                    )
+                else:
+                    html += (
+                        "\n<span class='bib-entry-field bib-entry-"
+                        + "{0:<{1}}".format(field, self._max_field_width)
+                        + "'>"
+                        + entry[field]
+                        + "</span>"
+                    )
+            except TypeError as t:
+                raise TypeError("The field {} in entry {} must be a string".format(field, entry["ID"])) from t
+        html += "\n</cite>\n" + self.entry_separator
+
+        return html
+
+    def _comments_to_bibtex(self, bib_database):
+        return "".join(
+            [f'<div class="bib-comment">{comment}</div>\n{self.entry_separator}' for comment in bib_database.comments]
+        )
+
+    def _preambles_to_bibtex(self, bib_database):
+        return "".join([f"{preamble}\n{self.entry_separator}" for preamble in bib_database.preambles])

pydpeet/dev_utils/__init__.py

@@ -0,0 +1,7 @@
+"""
+Auto-generated __init__ file.
+Created: 2026-03-06 15:11:49
+"""
+
+# Restrictive package init: start with no public API
+__all__ = []

pydpeet/dev_utils/generate_inits/__init__.py

@@ -0,0 +1,7 @@
+"""
+Auto-generated __init__ file.
+Created: 2026-03-06 15:11:49
+"""
+
+# Restrictive package init: start with no public API
+__all__ = []