Duplicate from huggingface/Model_Cards_Writing_Tool

Co-authored-by: Ezi Ozoani <[email protected]>

.gitattributes

@@ -0,0 +1,31 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

1_📝_form.py

@@ -0,0 +1,302 @@
+from yaml import load
+from persist import persist, load_widget_state
+import streamlit as st
+from io import StringIO 
+import tempfile
+from pathlib import Path
+import requests
+from huggingface_hub import hf_hub_download, upload_file
+import pandas as pd
+from huggingface_hub import create_repo
+import os
+from middleMan import parse_into_jinja_markdown as pj
+
+
+
+@st.cache
+def get_cached_data():
+    languages_df = pd.read_html("https://hf.co/languages")[0]
+    languages_map = pd.Series(languages_df["Language"].values, index=languages_df["ISO code"]).to_dict()
+
+    license_df = pd.read_html("https://huggingface.co/docs/hub/repositories-licenses")[0]
+    license_map = pd.Series(
+        license_df["License identifier (to use in model card)"].values, index=license_df.Fullname
+    ).to_dict()
+
+    available_metrics = [x['id'] for x in requests.get('https://huggingface.co/api/metrics').json()]
+
+    r = requests.get('https://huggingface.co/api/models-tags-by-type')
+    tags_data = r.json()
+    libraries = [x['id'] for x in tags_data['library']]
+    tasks = [x['id'] for x in tags_data['pipeline_tag']]
+    return languages_map, license_map, available_metrics, libraries, tasks
+
+
+def card_upload(card_info,repo_id,token):
+    #commit_message=None,
+    repo_type = "space"
+    commit_description=None,
+    revision=None,
+    create_pr=None
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = Path(tmpdir) / "README.md"
+        tmp_path.write_text(str(card_info))
+        url = upload_file(
+                    path_or_fileobj=str(tmp_path),
+                    path_in_repo="README.md",
+                    repo_id=repo_id,
+                    token=token,
+                    repo_type=repo_type,
+                    identical_ok=True,
+                    revision=revision,
+                )
+    return url
+
+def validate(self, repo_type="model"):
+    """Validates card against Hugging Face Hub's model card validation logic.
+    Using this function requires access to the internet, so it is only called
+    internally by `modelcards.ModelCard.push_to_hub`.
+    Args:
+        repo_type (`str`, *optional*):
+            The type of Hugging Face repo to push to. Defaults to None, which will use
+            use "model". Other options are "dataset" and "space".
+    """
+    if repo_type is None:
+        repo_type = "model"
+
+    # TODO - compare against repo types constant in huggingface_hub if we move this object there.
+    if repo_type not in ["model", "space", "dataset"]:
+        raise RuntimeError(
+            "Provided repo_type '{repo_type}' should be one of ['model', 'space',"
+            " 'dataset']."
+        )
+
+    body = {
+        "repoType": repo_type,
+        "content": str(self),
+    }
+    headers = {"Accept": "text/plain"}
+
+    try:
+        r = requests.post(
+            "https://huggingface.co/api/validate-yaml", body, headers=headers
+        )
+        r.raise_for_status()
+    except requests.exceptions.HTTPError as exc:
+        if r.status_code == 400:
+            raise RuntimeError(r.text)
+        else:
+            raise exc
+
+
+## Save uploaded [markdown] file to directory to be used by jinja parser function 
+def save_uploadedfile(uploadedfile):
+    with open(os.path.join("temp_uploaded_filed_Dir",uploadedfile.name),"wb") as f:
+        f.write(uploadedfile.getbuffer())
+    st.success("Saved File:{} to temp_uploaded_filed_Dir".format(uploadedfile.name))
+    return uploadedfile.name 
+
+
+def main_page():
+
+   
+    if "model_name" not in st.session_state:
+        # Initialize session state.
+        st.session_state.update({
+            "input_model_name": "",
+            "languages": [],
+            "license": "",
+            "library_name": "",
+            "datasets": "",
+            "metrics": [],
+            "task": "",
+            "tags": "",
+            "model_description": "Some cool model...",
+            "the_authors":"",
+            "Shared_by":"",
+            "Model_details_text": "",
+            "Model_developers": "",
+            "blog_url":"",
+            "Parent_Model_url":"",
+            "Parent_Model_name":"",
+
+            "Model_how_to": "",
+            
+            "Model_uses": "",
+            "Direct_Use": "",
+            "Downstream_Use":"",
+            "Out-of-Scope_Use":"",
+
+            "Model_Limits_n_Risks": "",
+            "Recommendations":"",
+
+            "training_Data": "",
+            "model_preprocessing":"",
+            "Speeds_Sizes_Times":"",
+
+
+
+            "Model_Eval": "",
+            "Testing_Data":"",
+            "Factors":"",
+            "Metrics":"",
+            "Model_Results":"",
+
+            "Model_c02_emitted": "",
+            "Model_hardware":"",
+            "hours_used":"",
+            "Model_cloud_provider":"",
+            "Model_cloud_region":"",
+
+            "Model_cite": "",
+            "paper_url": "",
+            "github_url": "",
+            "bibtex_citation": "",
+            "APA_citation":"",
+
+            "Model_examin":"",
+            "Model_card_contact":"",
+            "Model_card_authors":"",
+            "Glossary":"",
+            "More_info":"",
+
+            "Model_specs":"",
+            "compute_infrastructure":"",
+            "technical_specs_software":"",
+
+            "check_box": bool,
+            "markdown_upload":" ",
+            "legal_view":bool,
+            "researcher_view":bool,
+            "beginner_technical_view":bool,
+            "markdown_state":"",
+        })
+    ## getting cache for each warnings 
+    languages_map, license_map, available_metrics, libraries, tasks = get_cached_data()
+
+    ## form UI setting 
+    st.header("Model Card Form")
+
+    warning_placeholder = st.empty()
+
+    st.text_input("Model Name", key=persist("model_name"))
+    st.text_area("Model Description", help="The model description provides basic details about the model. This includes the architecture, version, if it was introduced in a paper, if an original implementation is available, the author, and general information about the model. Any copyright should be attributed here. General information about training procedures, parameters, and important disclaimers can also be mentioned in this section.", key=persist('model_description'))
+    st.multiselect("Language(s)", list(languages_map), format_func=lambda x: languages_map[x], help="The language(s) associated with this model. If this is not a text-based model, you should specify whatever language that is used in the dataset. For instance, if the dataset's labels are in english, you should select English here.", key=persist("languages"))
+    st.selectbox("License", [""] + list(license_map.values()), help="The license associated with this model.", key=persist("license"))
+    st.selectbox("Library Name", [""] + libraries, help="The name of the library this model came from (Ex. pytorch, timm, spacy, keras, etc.). This is usually automatically detected in model repos, so it is not required.", key=persist('library_name'))
+    st.text_input("Parent Model (URL)", help="If this model has another model as its base, please provide the URL link to the parent model", key=persist("Parent_Model_name"))
+    st.text_input("Datasets (comma separated)", help="The dataset(s) used to train this model. Use dataset id from https://hf.co/datasets.", key=persist("datasets"))
+    st.multiselect("Metrics", available_metrics, help="Metrics used in the training/evaluation of this model. Use metric id from https://hf.co/metrics.", key=persist("metrics"))
+    st.selectbox("Task", [""] + tasks, help="What task does this model aim to solve?", key=persist('task'))
+    st.text_input("Tags (comma separated)", help="Additional tags to add which will be filterable on https://hf.co/models. (Ex. image-classification, vision, resnet)", key=persist("tags"))
+    st.text_input("Author(s) (comma separated)", help="The authors who developed this model. If you trained this model, the author is you.", key=persist("the_authors"))
+    st.text_input("Related Research Paper", help="Research paper related to this model.", key=persist("paper_url"))
+    st.text_input("Related GitHub Repository", help="Link to a GitHub repository used in the development of this model", key=persist("github_url"))
+    st.text_area("Bibtex Citation", help="Bibtex citations for related work", key=persist("bibtex_citations"))
+    st.text_input("Carbon Emitted:", help="You can estimate carbon emissions using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700)", key=persist("Model_c02_emitted"))
+   
+   
+    
+    # warnings setting
+    languages=st.session_state.languages or None
+    license=st.session_state.license or None
+    task = st.session_state.task or None
+    markdown_upload = st.session_state.markdown_upload
+    #uploaded_model_card = st.session_state.uploaded_model 
+    # Handle any warnings...
+    do_warn = False
+    warning_msg = "Warning: The following fields are required but have not been filled in: "
+    if not languages:
+        warning_msg += "\n- Languages"
+        do_warn = True
+    if not license:
+        warning_msg += "\n- License"
+        do_warn = True
+    if not task or not markdown_upload:
+        warning_msg += "\n- Please choose a task or upload a model card"
+        do_warn = True
+    if do_warn:
+        warning_placeholder.error(warning_msg)
+
+    with st.sidebar:
+
+        ######################################################
+        ### Uploading a model card from local drive
+        ######################################################
+        st.markdown("## Upload Model Card")
+       
+        st.markdown("#### Model Card must be in markdown (.md) format.") 
+
+        # Read a single file 
+        uploaded_file = st.file_uploader("Choose a file", type = ['md'], help = 'Please choose a markdown (.md) file type to upload')
+        if uploaded_file is not None:
+           
+            file_details = {"FileName":uploaded_file.name,"FileType":uploaded_file.type} 
+            name_of_uploaded_file = save_uploadedfile(uploaded_file)
+           
+            st.session_state.markdown_upload = name_of_uploaded_file ## uploaded model card
+
+        elif st.session_state.task =='fill-mask' or 'translation' or 'token-classification' or ' sentence-similarity' or 'summarization' or 'question-answering' or 'text2text-generation' or 'text-classification' or 'text-generation' or 'conversational':
+            #st.session_state.markdown_upload = open(
+             #   "language_model_template1.md", "r+"
+            #).read() 
+            st.session_state.markdown_upload = "language_model_template1.md" ## language model template
+        
+        elif st.session_state.task:
+            
+            st.session_state.markdown_upload =  "current_card.md" ## default non language model template
+       
+        #########################################
+        ### Uploading model card to HUB
+        #########################################
+        out_markdown =open( st.session_state.markdown_upload, "r+"
+            ).read() 
+        print_out_final = f"{out_markdown}"
+        st.markdown("## Export Loaded Model Card to Hub")
+        with st.form("Upload to 🤗 Hub"):
+            st.markdown("Use a token with write access from [here](https://hf.co/settings/tokens)")
+            token = st.text_input("Token", type='password')
+            repo_id = st.text_input("Repo ID")
+            submit = st.form_submit_button('Upload to 🤗 Hub', help='The current model card will be uploaded to a branch in the supplied repo ')
+
+        if submit:
+            if len(repo_id.split('/')) == 2:
+                repo_url = create_repo(repo_id, exist_ok=True, token=token)
+                new_url = card_upload(pj(),repo_id, token=token)
+                st.success(f"Pushed the card to the repo [here]({new_url})!") # note: was repo_url
+            else:
+                st.error("Repo ID invalid. It should be username/repo-name. For example: nateraw/food")
+        
+
+        #########################################
+        ### Download model card
+        #########################################
+
+
+        st.markdown("## Download current Model Card")
+
+        if st.session_state.model_name is None or st.session_state.model_name== ' ':
+            downloaded_file_name = 'current_model_card.md'
+        else: 
+            downloaded_file_name = st.session_state.model_name+'_'+'model_card.md'
+        download_status = st.download_button(label = 'Download Model Card', data = pj(), file_name = downloaded_file_name, help = "The current model card will be downloaded as a markdown (.md) file")
+        if download_status == True:
+            st.success("Your current model card, successfully downloaded 🤗")
+
+
+def page_switcher(page):
+    st.session_state.runpage = page    
+
+def main():
+    
+    st.header("About Model Cards")
+    st.markdown(Path('about.md').read_text(), unsafe_allow_html=True)
+    btn = st.button('Create a Model Card 📝',on_click=page_switcher,args=(main_page,))
+    if btn:
+        st.experimental_rerun() # rerun is needed to clear the page
+
+if __name__ == '__main__':
+    load_widget_state()
+    if 'runpage' not in st.session_state :
+        st.session_state.runpage = main
+    st.session_state.runpage()

README.md

@@ -0,0 +1,14 @@
+---
+title: Modelcard Creator
+emoji: ⚡
+colorFrom: red
+colorTo: yellow
+sdk: streamlit
+sdk_version: 1.10.0
+app_file: 1_📝_form.py
+pinned: false
+license: mit
+duplicated_from: huggingface/Model_Cards_Writing_Tool
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

about.md

@@ -0,0 +1,4 @@
+
+This is a tool to generate Model Cards. It aims to provide a simple interface to build from scratch a new model card or to edit an existing one. The generated model card can be downloaded or directly pushed to your model hosted on the Hub. Please use [the Community tab](https://huggingface.co/spaces/huggingface/Model_Cards_Writing_Tool/discussions) to give us some feedback 🤗
+
+

combined.md

@@ -0,0 +1,141 @@
+---
+language:
+- es
+license: apache-2.0
+library_name: keras
+tags:
+- autogenerated-modelcard
+---
+
+# MyModelName
+
+## Table of Contents
+- [MyModelName](#-model_id--defaultmymodelname-true)
+  - [Table of Contents](#table-of-contents)
+  - [Model Details](#model-details)
+  - [How to Get Started with the Model](#how-to-get-started-with-the-model)
+  - [Uses](#uses)
+      - [Direct Use](#direct-use)
+      - [Downstream Use](#downstream-use)
+      - [Misuse and Out-of-scope Use](#misuse-and-out-of-scope-use)
+  - [Limitations and Biases](#limitations-and-biases)
+  - [Training](#training)
+      - [Training Data](#training-data)
+      - [Training Procedure](#training-procedure)
+  - [Evaluation Results](#evaluation-results)
+  - [Environmental Impact](#environmental-impact)
+  - [Citation Information](#citation-information)
+
+ 
+<model_details>
+## Model Details
+
+<!-- Give an overview of your model, the relevant research paper, who trained it, etc.  -->
+
+Some cool model...
+
+- Developed by: 
+- Language(s): 
+- License: This model is licensed under the apache-2.0 license
+- Resources for more information:
+
+
+
+</model_details>
+
+<how_to_start>
+## How to Get Started with the Model 
+
+Use the code below to get started with the model.
+
+```python
+# A nice code snippet here that describes how to use the model...
+```
+</how_to_start>
+
+<uses>
+
+## Uses
+
+#### Direct Use
+
+<!-- Describe what kind of tasks this model can be used for directly or problems it can solve. -->
+
+[More Information Needed]
+
+#### Downstream Use
+
+<!-- Describe how this model could be leveraged by a downstream model (if applicable) -->
+
+[More Information Needed]
+
+#### Misuse and Out-of-scope Use
+
+<!-- Describe ways in which this model ***should not*** be used. -->
+
+[More Information Needed]
+</uses>
+
+<Limitations_and_Biases>
+
+## Limitations and Biases
+
+<!-- Describe limitations and biases of this model or models of it's type. -->
+
+**CONTENT WARNING: Readers should be aware this section contains content that is disturbing, offensive, and can propogate historical and current stereotypes.**
+
+[More Information Needed]
+
+</Limitations_and_Biases>
+
+<Training>
+
+## Training
+
+#### Training Data
+
+<!-- Describe the dataset used to train this model. -->
+<!-- Refer to data card if dataset is provided and exists on the hub -->
+
+See the data card for additional information.
+
+#### Training Procedure
+
+<!-- Describe the preprocessing, hardware used, training hyperparameters, etc. -->
+
+[More Information Needed]
+
+</Training>
+
+<Eval_Results>
+## Evaluation Results
+
+<!-- Describe evaluation results of this model across any datasets it was evaluated on. -->
+
+[More Information Needed]
+
+</Eval_Results>
+
+<E_Impact>
+## Environmental Impact
+
+<!-- Provide information to document the environmental impact of this model -->
+
+You can estimate carbon emissions using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700)
+
+- **Hardware Type:** 
+- **Hours used:** 
+- **Cloud Provider:** 
+- **Compute Region:** 
+- **Carbon Emitted:** 
+
+</E_Impact>
+
+<Cite>
+
+## Citation Information
+
+```bibtex
+
+```
+</Cite>

current_card.md

@@ -0,0 +1,222 @@
+---
+{{card_data}}
+---
+
+# {{ model_id }}
+
+<!--> Provide a quick summary of what the model is/does. <!-->
+
+#  Table of Contents
+
+- [{{ model_id }}](#-model_id-)
+- [Table of Contents](#table-of-contents)
+- [Model Details](#model-details)
+  - [Model Description](#model-description)
+- [Uses](#uses)
+  - [Direct Use](#direct-use)
+  - [Downstream Use [Optional]](#downstream-use-optional)
+  - [Out-of-Scope Use](#out-of-scope-use)
+- [Bias, Risks, and Limitations](#bias-risks-and-limitations)
+  - [Recommendations](#recommendations)
+- [Training Details](#training-details)
+  - [Training Data](#training-data)
+  - [Training Procedure](#training-procedure)
+    - [Preprocessing](#preprocessing)
+    - [Speeds, Sizes, Times](#speeds-sizes-times)
+- [Evaluation](#evaluation)
+  - [Testing Data, Factors & Metrics](#testing-data-factors--metrics)
+    - [Testing Data](#testing-data)
+    - [Factors](#factors)
+    - [Metrics](#metrics)
+  - [Results](#results)
+- [Model Examination](#model-examination)
+- [Environmental Impact](#environmental-impact)
+- [Technical Specifications [optional]](#technical-specifications-optional)
+  - [Model Architecture and Objective](#model-architecture-and-objective)
+  - [Compute Infrastructure](#compute-infrastructure)
+    - [Hardware](#hardware)
+    - [Software](#software)
+- [Citation](#citation)
+- [Glossary [optional]](#glossary-optional)
+- [More Information [optional]](#more-information-optional)
+- [Model Card Authors [optional]](#model-card-authors-optional)
+- [Model Card Contact](#model-card-contact)
+- [How to Get Started with the Model](#how-to-get-started-with-the-model)
+
+
+# Model Details
+
+## Model Description
+
+<!--> This section provides basic information about what the model is, its current status, and where it came from.. <!-->
+{{ the_model_description | default("More information needed", true)}}
+
+- **Developed by:** {{ developers | default("More information needed", true)}}
+- **Shared by [Optional]:** {{ shared_by | default("More information needed", true)}}
+- **Model type:** Language model
+- **Language(s) (NLP):** {{ language | default("More information needed", true)}}
+- **License:** {{ license | default("More information needed", true)}}
+- **Related Models:** {{ related_models | default("More information needed", true)}}
+    - **Parent Model:** {{ parent_model | default("More information needed", true)}}
+- **Resources for more information:** {{ more_resources | default("More information needed", true)}}
+
+# Uses
+
+<!--> Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. <!-->
+
+## Direct Use
+
+<!--> This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. <!-->
+
+{{ direct_use | default("More information needed", true)}}
+
+## Downstream Use [Optional]
+
+<!--> This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app <!-->
+
+{{ downstream_use | default("More information needed", true)}}
+
+## Out-of-Scope Use
+
+<!--> This section addresses misuse, malicious use, and uses that the model will not work well for. <!-->
+
+{{ out_of_scope_use | default("More information needed", true)}}
+
+# Bias, Risks, and Limitations
+
+<!--> This section is meant to convey both technical and sociotechnical limitations. <!-->
+
+{{ bias_risks_limitations | default("More information needed", true)}}
+
+## Recommendations
+
+<!--> This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. <!-->
+
+{{ bias_recommendations | default("Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recomendations.", true)}}
+
+# Training Details
+
+## Training Data
+
+<!--> This should link to a Data Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. <!-->
+
+{{ training_data | default("More information needed", true)}}
+
+## Training Procedure
+
+<!--> This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. <!-->
+
+### Preprocessing
+
+{{ preprocessing | default("More information needed", true)}}
+
+### Speeds, Sizes, Times
+
+<!--> This section provides information about throughput, start/end time, checkpoint size if relevant, etc. <!-->
+
+{{ speeds_sizes_times | default("More information needed", true)}}
+ 
+# Evaluation
+
+<!--> This section describes the evaluation protocols and provides the results. <!-->
+
+## Testing Data, Factors & Metrics
+
+### Testing Data
+
+<!--> This should link to a Data Card if possible. <!-->
+
+{{ testing_data | default("More information needed", true)}}
+
+### Factors
+
+<!--> These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. <!-->
+
+{{ testing_factors | default("More information needed", true)}}
+
+### Metrics
+
+<!--> These are the evaluation metrics being used, ideally with a description of why. <!-->
+
+{{ testing_metrics | default("More information needed", true)}}
+
+## Results 
+
+{{ results | default("More information needed", true)}}
+
+# Model Examination
+
+{{ model_examination | default("More information needed", true)}}
+
+# Environmental Impact
+
+<!--> Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly <!-->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** {{ hardware | default("More information needed", true)}}
+- **Hours used:** {{ hours_used | default("More information needed", true)}}
+- **Cloud Provider:** {{ cloud_provider | default("More information needed", true)}}
+- **Compute Region:** {{ cloud_region | default("More information needed", true)}}
+- **Carbon Emitted:** {{ co2_emitted | default("More information needed", true)}}
+
+# Technical Specifications [optional]
+
+## Model Architecture and Objective
+
+{{ model_specs | default("More information needed", true)}}
+
+## Compute Infrastructure
+
+{{ compute_infrastructure | default("More information needed", true)}}
+
+### Hardware
+
+{{ hardware | default("More information needed", true)}}
+
+### Software
+
+{{ software | default("More information needed", true)}}
+
+# Citation
+
+<!--> If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. <!-->
+
+**BibTeX:**
+
+{{ citation_bibtex | default("More information needed", true)}}
+
+**APA:**
+
+{{ citation_apa | default("More information needed", true)}}
+
+# Glossary [optional]
+
+<!--> If relevant, include terms and calculations in this section that can help readers understand the model or model card. <!-->
+
+{{ glossary | default("More information needed", true)}}
+
+# More Information [optional]
+
+{{ more_information | default("More information needed", true)}}
+
+# Model Card Authors [optional]
+
+{{ model_card_authors | default("More information needed", true)}}
+
+# Model Card Contact
+
+{{ model_card_contact | default("More information needed", true)}}
+
+# How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+<details>
+<summary> Click to expand </summary>
+
+{{ get_started_code | default("More information needed", true)}}
+
+</details>
+
+

current_editable.md

@@ -0,0 +1,141 @@
+---
+language:
+- de
+license: bigscience-bloom-rail-1.0
+library_name: keras
+tags:
+- autogenerated-modelcard
+---
+
+# tethre
+
+## Table of Contents
+- [tethre](#-model_id--defaultmymodelname-true)
+  - [Table of Contents](#table-of-contents)
+  - [Model Details](#model-details)
+  - [How to Get Started with the Model](#how-to-get-started-with-the-model)
+  - [Uses](#uses)
+      - [Direct Use](#direct-use)
+      - [Downstream Use](#downstream-use)
+      - [Misuse and Out-of-scope Use](#misuse-and-out-of-scope-use)
+  - [Limitations and Biases](#limitations-and-biases)
+  - [Training](#training)
+      - [Training Data](#training-data)
+      - [Training Procedure](#training-procedure)
+  - [Evaluation Results](#evaluation-results)
+  - [Environmental Impact](#environmental-impact)
+  - [Citation Information](#citation-information)
+
+ 
+<model_details>
+## Model Details
+
+<!-- Give an overview of your model, the relevant research paper, who trained it, etc.  -->
+
+ hhrirergenjfngdg
+
+- Developed by: 
+- Language(s): 
+- License: This model is licensed under the bigscience-bloom-rail-1.0 license
+- Resources for more information:
+
+
+
+</model_details>
+
+<how_to_start>
+## How to Get Started with the Model 
+
+Use the code below to get started with the model.
+
+```python
+# A nice code snippet here that describes how to use the model...
+```
+</how_to_start>
+
+<uses>
+
+## Uses
+
+#### Direct Use
+
+<!-- Describe what kind of tasks this model can be used for directly or problems it can solve. -->
+
+[More Information Needed]
+
+#### Downstream Use
+
+<!-- Describe how this model could be leveraged by a downstream model (if applicable) -->
+
+[More Information Needed]
+
+#### Misuse and Out-of-scope Use
+
+<!-- Describe ways in which this model ***should not*** be used. -->
+
+[More Information Needed]
+</uses>
+
+<Limitations_and_Biases>
+
+## Limitations and Biases
+
+<!-- Describe limitations and biases of this model or models of it's type. -->
+
+**CONTENT WARNING: Readers should be aware this section contains content that is disturbing, offensive, and can propogate historical and current stereotypes.**
+
+[More Information Needed]
+
+</Limitations_and_Biases>
+
+<Training>
+
+## Training
+
+#### Training Data
+
+<!-- Describe the dataset used to train this model. -->
+<!-- Refer to data card if dataset is provided and exists on the hub -->
+
+See the data card for additional information.
+
+#### Training Procedure
+
+<!-- Describe the preprocessing, hardware used, training hyperparameters, etc. -->
+
+[More Information Needed]
+
+</Training>
+
+<Eval_Results>
+## Evaluation Results
+
+<!-- Describe evaluation results of this model across any datasets it was evaluated on. -->
+
+[More Information Needed]
+
+</Eval_Results>
+
+<E_Impact>
+## Environmental Impact
+
+<!-- Provide information to document the environmental impact of this model -->
+
+You can estimate carbon emissions using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700)
+
+- **Hardware Type:** 
+- **Hours used:** 
+- **Cloud Provider:** 
+- **Compute Region:** 
+- **Carbon Emitted:** 
+
+</E_Impact>
+
+<Cite>
+
+## Citation Information
+
+```bibtex
+
+```
+</Cite>

extract_code.py

@@ -0,0 +1,532 @@
+#!/usr/bin/env python3
+
+import re
+
+"""
+Extracts code from the file "./Libraries.ts".
+(Note that "Libraries.ts", must be in the same directory as 
+this script).
+"""
+
+file = None
+
+def read_file(library: str, model_name: str) -> str:
+    text = file
+
+    match = re.search('const ' + library + '.*', text, re.DOTALL).group()
+    if match:
+        text = match[match.index('`') + 1:match.index('`;')].replace('${model.id}', model_name)
+
+    return text
+
+file = """
+import type { ModelData } from "./Types";
+/**
+ * Add your new library here.
+ */
+export enum ModelLibrary {
+	"adapter-transformers"   = "Adapter Transformers",
+	"allennlp"               = "allenNLP",
+	"asteroid"               = "Asteroid",
+	"diffusers"              = "Diffusers",
+	"espnet"                 = "ESPnet",
+	"fairseq"                = "Fairseq",
+	"flair"                  = "Flair",
+	"keras"                  = "Keras",
+	"nemo"                   = "NeMo",
+	"pyannote-audio"         = "pyannote.audio",
+	"sentence-transformers"  = "Sentence Transformers",
+	"sklearn"                = "Scikit-learn",
+	"spacy"                  = "spaCy",
+	"speechbrain"            = "speechbrain",
+	"tensorflowtts"          = "TensorFlowTTS",
+	"timm"                   = "Timm",
+	"fastai"                 = "fastai",
+	"transformers"           = "Transformers",
+	"stanza"                 = "Stanza",
+	"fasttext"               = "fastText",
+	"stable-baselines3"      = "Stable-Baselines3",
+	"ml-agents"              = "ML-Agents",
+}
+
+export const ALL_MODEL_LIBRARY_KEYS = Object.keys(ModelLibrary) as (keyof typeof ModelLibrary)[];
+
+
+/**
+ * Elements configurable by a model library.
+ */
+export interface LibraryUiElement {
+	/**
+	 * Name displayed on the main
+	 * call-to-action button on the model page.
+	 */
+	btnLabel:  string;
+	/**
+	 * Repo name
+	 */
+	repoName: string;
+	/**
+	 * URL to library's repo
+	 */
+	repoUrl:   string;
+	/**
+	 * Code snippet displayed on model page
+	 */
+	snippet:   (model: ModelData) => string;
+}
+
+function nameWithoutNamespace(modelId: string): string {
+	const splitted = modelId.split("/");
+	return splitted.length === 1 ? splitted[0] : splitted[1];
+}
+
+//#region snippets
+
+const adapter_transformers = (model: ModelData) =>
+	`from transformers import ${model.config?.adapter_transformers?.model_class}
+
+model = ${model.config?.adapter_transformers?.model_class}.from_pretrained("${model.config?.adapter_transformers?.{model.id}}")
+model.load_adapter("${model.id}", source="hf")`;
+
+const allennlpUnknown = (model: ModelData) =>
+	`import allennlp_models
+from allennlp.predictors.predictor import Predictor
+
+predictor = Predictor.from_path("hf://${model.id}")`;
+
+const allennlpQuestionAnswering = (model: ModelData) =>
+	`import allennlp_models
+from allennlp.predictors.predictor import Predictor
+
+predictor = Predictor.from_path("hf://${model.id}")
+predictor_input = {"passage": "My name is Wolfgang and I live in Berlin", "question": "Where do I live?"}
+predictions = predictor.predict_json(predictor_input)`;
+
+const allennlp = (model: ModelData) => {
+	if (model.tags?.includes("question-answering")) {
+		return allennlpQuestionAnswering(model);
+	}
+	return allennlpUnknown(model);
+};
+
+const asteroid = (model: ModelData) =>
+	`from asteroid.models import BaseModel
+
+model = BaseModel.from_pretrained("${model.id}")`;
+
+const diffusers = (model: ModelData) =>
+	`from diffusers import DiffusionPipeline
+
+pipeline = DiffusionPipeline.from_pretrained("${model.id}"${model.private ? ", use_auth_token=True" : ""})`;
+
+const espnetTTS = (model: ModelData) =>
+	`from espnet2.bin.tts_inference import Text2Speech
+
+model = Text2Speech.from_pretrained("${model.id}")
+
+speech, *_ = model("text to generate speech from")`;
+
+const espnetASR = (model: ModelData) =>
+	`from espnet2.bin.asr_inference import Speech2Text
+
+model = Speech2Text.from_pretrained(
+  "${model.id}"
+)
+
+speech, rate = soundfile.read("speech.wav")
+text, *_ = model(speech)`;
+
+const espnetUnknown = () =>
+	`unknown model type (must be text-to-speech or automatic-speech-recognition)`;
+
+const espnet = (model: ModelData) => {
+	if (model.tags?.includes("text-to-speech")) {
+		return espnetTTS(model);
+	} else if (model.tags?.includes("automatic-speech-recognition")) {
+		return espnetASR(model);
+	}
+	return espnetUnknown();
+};
+
+const fairseq = (model: ModelData) =>
+	`from fairseq.checkpoint_utils import load_model_ensemble_and_task_from_hf_hub
+
+models, cfg, task = load_model_ensemble_and_task_from_hf_hub(
+    "${model.id}"
+)`;
+
+
+const flair = (model: ModelData) =>
+	`from flair.models import SequenceTagger
+
+tagger = SequenceTagger.load("${model.id}")`;
+
+const keras = (model: ModelData) =>
+	`from huggingface_hub import from_pretrained_keras
+
+model = from_pretrained_keras("${model.id}")
+`;
+
+const pyannote_audio_pipeline = (model: ModelData) =>
+	`from pyannote.audio import Pipeline
+  
+pipeline = Pipeline.from_pretrained("${model.id}")
+
+# inference on the whole file
+pipeline("file.wav")
+
+# inference on an excerpt
+from pyannote.core import Segment
+excerpt = Segment(start=2.0, end=5.0)
+
+from pyannote.audio import Audio
+waveform, sample_rate = Audio().crop("file.wav", excerpt)
+pipeline({"waveform": waveform, "sample_rate": sample_rate})`;
+
+const pyannote_audio_model = (model: ModelData) =>
+	`from pyannote.audio import Model, Inference
+
+model = Model.from_pretrained("${model.id}")
+inference = Inference(model)
+
+# inference on the whole file
+inference("file.wav")
+
+# inference on an excerpt
+from pyannote.core import Segment
+excerpt = Segment(start=2.0, end=5.0)
+inference.crop("file.wav", excerpt)`;
+
+const pyannote_audio = (model: ModelData) => {
+	if (model.tags?.includes("pyannote-audio-pipeline")) {
+		return pyannote_audio_pipeline(model);
+	}
+	return pyannote_audio_model(model);
+};
+
+const tensorflowttsTextToMel = (model: ModelData) =>
+	`from tensorflow_tts.inference import AutoProcessor, TFAutoModel
+
+processor = AutoProcessor.from_pretrained("${model.id}")
+model = TFAutoModel.from_pretrained("${model.id}")
+`;
+
+const tensorflowttsMelToWav = (model: ModelData) =>
+	`from tensorflow_tts.inference import TFAutoModel
+
+model = TFAutoModel.from_pretrained("${model.id}")
+audios = model.inference(mels)
+`;
+
+const tensorflowttsUnknown = (model: ModelData) =>
+	`from tensorflow_tts.inference import TFAutoModel
+
+model = TFAutoModel.from_pretrained("${model.id}")
+`;
+
+const tensorflowtts = (model: ModelData) => {
+	if (model.tags?.includes("text-to-mel")) {
+		return tensorflowttsTextToMel(model);
+	} else if (model.tags?.includes("mel-to-wav")) {
+		return tensorflowttsMelToWav(model);
+	}
+	return tensorflowttsUnknown(model);
+};
+
+const timm = (model: ModelData) =>
+	`import timm
+
+model = timm.create_model("hf_hub:${model.id}", pretrained=True)`;
+
+const sklearn = (model: ModelData) =>
+	`from huggingface_hub import hf_hub_download
+import joblib
+
+model = joblib.load(
+	hf_hub_download("${model.id}", "sklearn_model.joblib")
+)`;
+
+const fastai = (model: ModelData) =>
+	`from huggingface_hub import from_pretrained_fastai
+
+learn = from_pretrained_fastai("${model.id}")`;
+
+const sentenceTransformers = (model: ModelData) =>
+	`from sentence_transformers import SentenceTransformer
+
+model = SentenceTransformer("${model.id}")`;
+
+const spacy = (model: ModelData) =>
+	`!pip install https://huggingface.co/${model.id}/resolve/main/${nameWithoutNamespace(model.id)}-any-py3-none-any.whl
+
+# Using spacy.load().
+import spacy
+nlp = spacy.load("${nameWithoutNamespace(model.id)}")
+
+# Importing as module.
+import ${nameWithoutNamespace(model.id)}
+nlp = ${nameWithoutNamespace(model.id)}.load()`;
+
+const stanza = (model: ModelData) =>
+	`import stanza
+
+stanza.download("${nameWithoutNamespace(model.id).replace("stanza-", "")}")
+nlp = stanza.Pipeline("${nameWithoutNamespace(model.id).replace("stanza-", "")}")`;
+
+
+const speechBrainMethod = (speechbrainInterface: string) => {
+	switch (speechbrainInterface) {
+		case "EncoderClassifier":
+		   return "classify_file";
+		case "EncoderDecoderASR":
+		case "EncoderASR":
+			return "transcribe_file";
+		case "SpectralMaskEnhancement":
+			return "enhance_file";
+		case "SepformerSeparation":
+			return "separate_file";
+		default:
+			return undefined;
+	}
+};
+
+const speechbrain = (model: ModelData) => {
+	const speechbrainInterface = model.config?.speechbrain?.interface;
+	if (speechbrainInterface === undefined) {
+		return `# interface not specified in config.json`;
+	}
+
+	const speechbrainMethod = speechBrainMethod(speechbrainInterface);
+	if (speechbrainMethod === undefined) {
+		return `# interface in config.json invalid`;
+	}
+
+	return `from speechbrain.pretrained import ${speechbrainInterface}
+model = ${speechbrainInterface}.from_hparams(
+  "${model.id}"
+)
+model.${speechbrainMethod}("file.wav")`;
+};
+
+const transformers = (model: ModelData) => {
+	const info = model.transformersInfo;
+	if (!info) {
+		return `# ⚠️ Type of model unknown`;
+	}
+	if (info.processor) {
+		const varName = info.processor === "AutoTokenizer" ? "tokenizer"
+			: info.processor === "AutoFeatureExtractor" ? "extractor"
+				: "processor"
+		;
+		return [
+			`from transformers import ${info.processor}, ${info.auto_model}`,
+			"",
+			`${varName} = ${info.processor}.from_pretrained("${model.id}"${model.private ? ", use_auth_token=True" : ""})`,
+			"",
+			`model = ${info.auto_model}.from_pretrained("${model.id}"${model.private ? ", use_auth_token=True" : ""})`,
+		].join("\n");
+	} else {
+		return [
+			`from transformers import ${info.auto_model}`,
+			"",
+			`model = ${info.auto_model}.from_pretrained("${model.id}"${model.private ? ", use_auth_token=True" : ""})`,
+		].join("\n");
+	}
+};
+
+const fasttext = (model: ModelData) =>
+	`from huggingface_hub import hf_hub_download
+import fasttext
+
+model = fasttext.load_model(hf_hub_download("${model.id}", "model.bin"))`;
+
+const stableBaselines3 = (model: ModelData) =>
+	`from huggingface_sb3 import load_from_hub
+checkpoint = load_from_hub(
+	repo_id="${model.id}",
+	filename="{MODEL FILENAME}.zip",
+)`;
+
+const nemoDomainResolver = (domain: string, model: ModelData): string | undefined => {
+	const modelName = `${nameWithoutNamespace(model.id)}.nemo`;
+
+	switch (domain) {
+		case "ASR":
+			return `import nemo.collections.asr as nemo_asr
+asr_model = nemo_asr.models.ASRModel.from_pretrained("${model.id}")
+
+transcriptions = asr_model.transcribe(["file.wav"])`;
+		default:
+			return undefined;
+	}
+};
+
+const mlAgents = (model: ModelData) =>
+	`mlagents-load-from-hf --repo-id="${model.id}" --local-dir="./downloads"`;
+	
+const nemo = (model: ModelData) => {
+	let command: string | undefined = undefined;
+	// Resolve the tag to a nemo domain/sub-domain 
+	if (model.tags?.includes("automatic-speech-recognition")) {
+		command = nemoDomainResolver("ASR", model);
+	}
+	
+	return command ?? `# tag did not correspond to a valid NeMo domain.`;
+};
+
+//#endregion
+
+
+
+export const MODEL_LIBRARIES_UI_ELEMENTS: { [key in keyof typeof ModelLibrary]?: LibraryUiElement } = {
+	// ^^ TODO(remove the optional ? marker when Stanza snippet is available)
+	"adapter-transformers": {
+		btnLabel: "Adapter Transformers",
+		repoName: "adapter-transformers",
+		repoUrl:  "https://github.com/Adapter-Hub/adapter-transformers",
+		snippet:  adapter_transformers,
+	},
+	"allennlp": {
+		btnLabel: "AllenNLP",
+		repoName: "AllenNLP",
+		repoUrl:  "https://github.com/allenai/allennlp",
+		snippet:  allennlp,
+	},
+	"asteroid": {
+		btnLabel: "Asteroid",
+		repoName: "Asteroid",
+		repoUrl:  "https://github.com/asteroid-team/asteroid",
+		snippet:  asteroid,
+	},
+	"diffusers": {
+		btnLabel: "Diffusers",
+		repoName: "🤗/diffusers",
+		repoUrl:  "https://github.com/huggingface/diffusers",
+		snippet:  diffusers,
+	},
+	"espnet": {
+		btnLabel: "ESPnet",
+		repoName: "ESPnet",
+		repoUrl:  "https://github.com/espnet/espnet",
+		snippet:  espnet,
+	},
+	"fairseq": {
+		btnLabel: "Fairseq",
+		repoName: "fairseq",
+		repoUrl:  "https://github.com/pytorch/fairseq",
+		snippet:  fairseq,
+	},
+	"flair": {
+		btnLabel: "Flair",
+		repoName: "Flair",
+		repoUrl:  "https://github.com/flairNLP/flair",
+		snippet:  flair,
+	},
+	"keras": {
+		btnLabel: "Keras",
+		repoName: "Keras",
+		repoUrl:  "https://github.com/keras-team/keras",
+		snippet:  keras,
+	},
+	"nemo": {
+		btnLabel: "NeMo",
+		repoName: "NeMo",
+		repoUrl:  "https://github.com/NVIDIA/NeMo",
+		snippet:  nemo,
+	},
+	"pyannote-audio": {
+		btnLabel: "pyannote.audio",
+		repoName: "pyannote-audio",
+		repoUrl:  "https://github.com/pyannote/pyannote-audio",
+		snippet:  pyannote_audio,
+	},
+	"sentence-transformers": {
+		btnLabel: "sentence-transformers",
+		repoName: "sentence-transformers",
+		repoUrl:  "https://github.com/UKPLab/sentence-transformers",
+		snippet:  sentenceTransformers,
+	},
+	"sklearn": {
+		btnLabel: "Scikit-learn",
+		repoName: "Scikit-learn",
+		repoUrl:  "https://github.com/scikit-learn/scikit-learn",
+		snippet:  sklearn,
+	},
+	"fastai": {
+		btnLabel: "fastai",
+		repoName: "fastai",
+		repoUrl:  "https://github.com/fastai/fastai",
+		snippet:  fastai,
+	},
+	"spacy": {
+		btnLabel: "spaCy",
+		repoName: "spaCy",
+		repoUrl:  "https://github.com/explosion/spaCy",
+		snippet:  spacy,
+	},
+	"speechbrain": {
+		btnLabel: "speechbrain",
+		repoName: "speechbrain",
+		repoUrl:  "https://github.com/speechbrain/speechbrain",
+		snippet:  speechbrain,
+	},
+	"stanza": {
+		btnLabel: "Stanza",
+		repoName: "stanza",
+		repoUrl: "https://github.com/stanfordnlp/stanza",
+		snippet: stanza,
+	},
+	"tensorflowtts": {
+		btnLabel: "TensorFlowTTS",
+		repoName: "TensorFlowTTS",
+		repoUrl:  "https://github.com/TensorSpeech/TensorFlowTTS",
+		snippet:  tensorflowtts,
+	},
+	"timm": {
+		btnLabel: "timm",
+		repoName: "pytorch-image-models",
+		repoUrl:  "https://github.com/rwightman/pytorch-image-models",
+		snippet:  timm,
+	},
+	"transformers": {
+		btnLabel: "Transformers",
+		repoName: "🤗/transformers",
+		repoUrl:  "https://github.com/huggingface/transformers",
+		snippet:  transformers,
+	},
+	"fasttext": {
+		btnLabel: "fastText",
+		repoName: "fastText",
+		repoUrl:  "https://fasttext.cc/",
+		snippet:  fasttext,
+	},
+	"stable-baselines3": {
+		btnLabel: "stable-baselines3",
+		repoName: "stable-baselines3",
+		repoUrl:  "https://github.com/huggingface/huggingface_sb3",
+		snippet:  stableBaselines3,
+	},
+	"ml-agents": {
+		btnLabel: "ml-agents",
+		repoName: "ml-agents",
+		repoUrl:  "https://github.com/huggingface/ml-agents",
+		snippet:  mlAgents,
+	},
+} as const;
+"""
+
+
+if __name__ == '__main__':
+    import sys
+    library_name = "keras"
+    model_name = "Distillgpt2"
+    print(read_file(library_name, model_name))
+    
+    """"
+    try:
+        args = sys.argv[1:]
+        if args:
+            print(read_file(args[0], args[1]))
+    except IndexError:
+        pass
+    """

language_model_template1.md

@@ -0,0 +1,329 @@
+---
+{{card_data}}
+---
+
+{% set lm_task_entries = {
+    'text-generation': {
+        'direct_use': "The model can be used for text generation.", 
+        'downstream_use': "To learn more about this task and potential downstream uses, see the Hugging Face [text generation docs](https://huggingface.co/tasks/text-generation)", 
+        'misuse': "The model was not trained to be factual or true representations of people or events, and therefore using the models to generate such content is out-of-scope for the abilities of this model."
+    },
+    'question-answering': {
+        'direct_use': "The model can be used for question answering.", 
+        'downstream_use': "Potential types of question answering include extractive QA, open generative QA, and closed generative QA. To learn more about this task and potential downstream uses, see the Hugging Face [question answering docs](https://huggingface.co/tasks/question-answering)", 
+        'misuse': "The model was not trained to be factual or true representations of people or events, and therefore using the models to generate such content is out-of-scope for the abilities of this model."
+    },
+    'fill-mask': {
+        'direct_use': "The model can be used for masked language modeling.", 
+        'downstream_use': "Masked language modeling are sometimes used to train large models for domain-specific problems. To learn more about this task and potential downstream uses, see the Hugging Face [fill mask docs](https://huggingface.co/tasks/fill-mask)", 
+        'misuse': "The model was not trained to be factual or true representations of people or events, and therefore using the models to generate such content is out-of-scope for the abilities of this model."
+    },
+    'sentence_similarity': {
+        'direct_use': "The model can be used for sentence similarity, the task of determining how similar two texts are.", 
+        'downstream_use': "Potential downstream use cases may include information retreival and clustering or grouping. To learn more about sentence similarity and potential downstream uses, see the Hugging Face [sentence similarity docs](https://huggingface.co/tasks/sentence-similarity)", 
+        'misuse': ""
+    },
+    'summarization': {
+        'direct_use': "The model can be used for summarization.", 
+        'downstream_use': "To learn more about summarization and potential downstream uses, see the Hugging Face [summarization docs](https://huggingface.co/tasks/summarization).", 
+        'misuse': "The model was not trained to be factual or true representations of people or events, and therefore using the models to generate such content is out-of-scope for the abilities of this model."
+    },
+    'text_classification': {
+        'direct_use': "The model can be used for text classification, the task of assigning a label or class to a given text.", 
+        'downstream_use': "Potential downstream use cases include sentiment analysis, natural language inference, and assessing grammatical correctness. To learn more about text classification and other potential downstream uses, see the Hugging Face [text classification docs](https://huggingface.co/tasks/text-classification).", 
+        'misuse': ""
+    },
+    'token_classification': {
+        'direct_use': "The model can be used for token classification, a natural language understanding task in which a label is assigned to some tokens in a text.", 
+        'downstream_use': "Potential downstream use cases include Named Entity Recognition (NER) and Part-of-Speech (PoS) tagging. To learn more about token classification and other potential downstream use cases, see the Hugging Face [token classification docs](https://huggingface.co/tasks/token-classification).", 
+        'misuse': ""
+    },
+    'translation': {
+        'direct_use': "The model can be used for translation, the task of converting text from one language to another.", 
+        'downstream_use': "Potential downstream use cases include use cases that leverage conversational agents across different languages. To learn more about translation and other potential downstream use cases, see the Hugging Face [translation docs](https://huggingface.co/tasks/translation).", 
+        'misuse': ""
+    },
+} %}
+
+{% set task_list = [
+    'text_generation', 
+    'question_answering', 
+    'fill_mask', 
+    'sentence_similarity', 
+    'summarization', 
+    'text_classification',
+    'token_classification', 
+    'translation'
+] %}
+
+
+# Model Card for {{ model_id }}
+
+<!-- Provide a quick summary of what the model is/does. [Optional] -->
+{{ the_model_description }}
+
+{% if model_card_user == "policymaker" %}
+<details>
+<summary> Click to expand policymaker version of model card </summary>
+
+# Table of Contents 
+
+1. [Model Details](#model-details)
+2. [Uses](#uses)
+3. [Bias, Risks, and Limitations](#bias-risks-and-limitations)
+4. [Model Examination](#model-examination)
+5. [Environmental Impact](#environmental-impact)
+6. [Citation](#citation)
+7. [Glossary](#glossary-optional)
+8. [More Information](#more-information-optional)
+9. [Model Card Authors](#model-card-authors-optional)
+10. [Model Card Contact](#model-card-contact)
+
+</details>
+
+{% endif %}
+
+
+#  Table of Contents
+
+- [Model Card for {{ model_id }}](#model-card-for--model_id-)
+- [Table of Contents](#table-of-contents)
+- [Table of Contents](#table-of-contents-1)
+- [Model Details](#model-details)
+  - [Model Description](#model-description)
+- [Uses](#uses)
+  - [Direct Use](#direct-use)
+  - [Downstream Use [Optional]](#downstream-use-optional)
+  - [Out-of-Scope Use](#out-of-scope-use)
+- [Bias, Risks, and Limitations](#bias-risks-and-limitations)
+  - [Recommendations](#recommendations)
+- [Training Details](#training-details)
+  - [Training Data](#training-data)
+  - [Training Procedure](#training-procedure)
+    - [Preprocessing](#preprocessing)
+    - [Speeds, Sizes, Times](#speeds-sizes-times)
+- [Evaluation](#evaluation)
+  - [Testing Data, Factors & Metrics](#testing-data-factors--metrics)
+    - [Testing Data](#testing-data)
+    - [Factors](#factors)
+    - [Metrics](#metrics)
+  - [Results](#results)
+- [Model Examination](#model-examination)
+- [Environmental Impact](#environmental-impact)
+- [Technical Specifications [optional]](#technical-specifications-optional)
+  - [Model Architecture and Objective](#model-architecture-and-objective)
+  - [Compute Infrastructure](#compute-infrastructure)
+    - [Hardware](#hardware)
+    - [Software](#software)
+- [Citation](#citation)
+- [Glossary [optional]](#glossary-optional)
+- [More Information [optional]](#more-information-optional)
+- [Model Card Authors [optional]](#model-card-authors-optional)
+- [Model Card Contact](#model-card-contact)
+- [How to Get Started with the Model](#how-to-get-started-with-the-model)
+
+
+# Model Details
+
+## Model Description
+
+<!-- Provide a longer summary of what this model is/does. -->
+{{ the_model_description }}
+
+- **Developed by:** {{ developers | join(', ') | default("More information needed", true)}}
+- **Shared by [Optional]:** {{ shared_by | join(', ') | default("More information needed", true)}}
+- **Model type:** {{ model_type | default("Language model", true)}}
+- **Language(s) (NLP):** {{ language | join(', ') | default("More information needed", true)}}
+- **License:** {{ model_license | default("More information needed", true)}}
+- **Parent Model:** {{ "  [Parent Model]({0})".format(repo_link) if parent_model_link else "More information needed"}}
+- **Resources for more information:** {{ more_resources | default("More information needed", true)}}
+{{ "    - [GitHub Repo]({0})".format(repo_link) if repo_link}}
+{{ "    - [Associated Paper]({0})".format(paper_link) if paper_link }}
+
+# Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+## Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+<!-- If the user enters content, print that. If not, but they enter a task in the list, use that. If neither, say "more info needed." -->
+{% if direct_use is defined %}
+{{ direct_use }}
+{% elif model_task in task_list %}
+{{ lm_task_entries[model_task]['direct_use'] }}
+{% else %}
+More information needed.
+{% endif %}
+
+## Downstream Use [Optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+<!-- If the user enters content, print that. If not, but they enter a task in the list, use that. If neither, say "more info needed." -->
+{% if downstream_use is defined %} 
+{{ downstream_use }}
+{% elif model_task in task_list %} 
+{{ lm_task_entries[model_task]['downstream_use'] }}
+{% else %} 
+More information needed.
+{% endif %}
+
+## Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+<!-- If the user enters content, print that. If not, but they enter a task in the list, use that. If neither, say "more info needed." -->
+{% if out_of_scope_use is defined %}
+{{ out_of_scope_use }}
+{% elif model_task in task_list %}
+The model should not be used to intentionally create hostile or alienating environments for people. {{ lm_task_entries[model_task]['misuse'] }}
+{% else %}
+More information needed.
+{% endif %}
+
+# Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+{% if bias_risks_limiations is defined %}
+{{ bias_risks_limitations }}
+{% else %}
+Significant research has explored bias and fairness issues with language models (see, e.g., [Sheng et al. (2021)](https://aclanthology.org/2021.acl-long.330.pdf) and [Bender et al. (2021)](https://dl.acm.org/doi/pdf/10.1145/3442188.3445922)). Predictions generated by the model may include disturbing and harmful stereotypes across protected classes; identity characteristics; and sensitive, social, and occupational groups.
+{% endif %}
+
+## Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+{% if bias_recommendations is defined %}
+{{ bias_recommendations }}
+{% else %}
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recomendations.
+{% endif %}
+
+# Training Details
+
+## Training Data
+
+<!-- This should link to a Data Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+{{ training_data | default("More information on training data needed", true)}}
+{{ "See the associated [dataset card]({0}) for further details.".format(training_datacard_link) if training_data_card_link }}
+
+## Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+### Preprocessing
+
+{{ preprocessing | default("More information needed", true)}}
+
+### Speeds, Sizes, Times
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+{{ speeds_sizes_times | default("More information needed", true)}}
+ 
+# Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+## Testing Data, Factors & Metrics
+
+### Testing Data
+
+<!-- This should link to a Data Card if possible. -->
+
+{{ testing_data | default("More information needed", true)}}
+{{ "See the associated [dataset card]({0}) for further details.".format(testing_datacard_link) if testing_data_card_link }}
+
+### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+{{ testing_factors | default("More information needed", true)}}
+
+### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+{{ testing_metrics | default("More information needed", true)}}
+
+## Results 
+
+{{ results | default("More information needed", true)}}
+
+# Model Examination
+
+{{ model_examination | default("More information needed", true)}}
+
+# Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** {{ hardware | default("More information needed", true)}}
+- **Hours used:** {{ hours_used | default("More information needed", true)}}
+- **Cloud Provider:** {{ cloud_provider | default("More information needed", true)}}
+- **Compute Region:** {{ cloud_region | default("More information needed", true)}}
+- **Carbon Emitted:** {{ co2_emitted | default("More information needed", true)}}
+
+# Technical Specifications [optional]
+
+## Model Architecture and Objective
+
+{{ model_specs | default("More information needed", true)}}
+
+## Compute Infrastructure
+
+{{ compute_infrastructure | default("More information needed", true)}}
+
+### Hardware
+
+{{ hardware | default("More information needed", true)}}
+
+### Software
+
+{{ software | default("More information needed", true)}}
+
+# Citation
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+{{ citation_bibtex | default("More information needed", true)}}
+
+**APA:**
+
+{{ citation_apa | default("More information needed", true)}}
+
+# Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+{{ glossary | default("More information needed", true)}}
+
+# More Information [optional]
+
+{{ more_information | default("More information needed", true)}}
+
+# Model Card Authors [optional]
+
+<!-- This section provides another layer of transparency and accountability. Whose views is this model card representing? How many voices were included in its construction? Etc. -->
+
+{{ model_card_authors | join(', ') | default("More information needed", true)}}
+
+# Model Card Contact
+
+{{ model_card_contact | join(', ') | default("More information needed", true)}}
+
+# How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+<details>
+<summary> Click to expand </summary>
+
+{{ get_started_code | default("More information needed", true)}}
+
+</details>

lets_combine.md

@@ -0,0 +1 @@
+'<details> <summary> Click to expand </summary>\n\n# Model Details\n## Model Description\n<!--> Provide a longer summary of what this model is. <!-->\n- **Developed by:** {{ developers | default("More information needed", true)}}- **Shared by [Optional]:** {{ shared_by | default("More information needed", true)}}- **Model type:** Language model- **Language(s) (NLP):** {{ language | default("More information needed", true)}}- **License:** {{ license | default("More information needed", true)}}- **Related Models:** {{ related_models | default("More information needed", true)}}    - **Parent Model:** {{ parent_model | default("More information needed", true)}}- **Resources for more information:** {{ more_resources | default("More information needed", true)}} </details>\n# Uses\n<!--> Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. <!-->\n## Direct Use\n<!--> This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. <!-->\n## Downstream Use [Optional]\n<!--> This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app <!-->\n## Out-of-Scope Use\n<!--> This section addresses misuse, malicious use, and uses that the model will not work well for. <!--> '

markdownTagExtract.py

@@ -0,0 +1,99 @@
+#from lib import tag_checker
+import glob
+import fileinput
+import os
+
+def tag_checker(file,start_header,end_header):
+    markdown_fp = open(file, "r")
+
+    # Needed for later
+    idea_list = []
+    idea_counter = 0
+
+    start_t = start_header
+    end_t = end_header
+
+    inside_tag = False
+    for line in markdown_fp:
+        start_tag = start_t in line
+        end_tag = end_t in line
+        outside_tag = not inside_tag
+
+        if start_tag and outside_tag:
+            # Start tag
+            tag_start_index = line.index(start_t) + len(end_t)
+            line = line[tag_start_index:]
+            
+            # This is where we'll store the idea
+            idea_list.append("")
+            
+            inside_tag = True
+
+        if end_tag and inside_tag:
+            # End tag
+            end_tag_index = line.index(end_t)
+
+            line = line[:end_tag_index]
+
+            idea_list[idea_counter] += line
+            idea_counter += 1
+            inside_tag = False
+
+        if inside_tag:
+            # Extract
+            idea_list[idea_counter] += line
+    markdown_fp.close()
+    return idea_list
+  
+def listToString(s): 
+    
+    # initialize an empty string
+    str1 = "" 
+    
+    # traverse in the string  
+    for ele in s: 
+        str1 += ele  
+    
+    # return string  
+    return str1 
+
+
+def to_markdown(new_file, text_list):
+    new_file_name = open(new_file, "w")
+
+    #new_file_name.write("# Collection of ideas\n")
+
+    for i, idea in enumerate(text_list):
+            new_file_name.write(idea + "\n")
+
+    new_file_name.close()
+
+def combine_markdowns(document1, original_document):
+    pat = document1
+    with open(original_document, 'w') as fout:
+        for line in sorted(fileinput.input(glob.glob(pat))):
+            fout.write(line)
+    return original_document
+
+if __name__ == "__main__":
+    file = "template.md"
+    header_1_start = '<how_to_start>'
+    header_1_end = '</how_to_start>'
+
+    header_2_start = '<how_to_start>'
+    header_2_end = '</how_to_start>'
+
+
+    how_to_start = (tag_checker(file,header_2_start,header_2_end))
+
+    intended_use_limits = (tag_checker(file,header_2_start,header_2_end))
+    string_s = listToString(how_to_start)
+    print(string_s)
+    combine_markdowns = how_to_start + intended_use_limits
+  
+    
+    #to_markdown ('combined.md',combine_markdowns)
+
+
+  
+    

middleMan.py

@@ -0,0 +1,136 @@
+import streamlit as st
+from persist import persist, load_widget_state
+#from pages.viewCardProgress import get_card
+from modelcards import CardData, ModelCard
+from markdownTagExtract import tag_checker,listToString,to_markdown
+#from specific_extraction import extract_it
+from modelcards import CardData, ModelCard
+from jinja2 import Environment, FileSystemLoader
+
+
+def is_float(value):
+    try:
+        float(value)
+        return True
+    except:
+        return False
+
+## Handles parsing jinja variable templates
+def parse_into_jinja_markdown():
+    env = Environment(loader=FileSystemLoader('.'), autoescape=True)
+    temp = env.get_template(st.session_state.markdown_upload)
+    # to add: 
+    # - parent model
+    # to fix:
+        # citation on form: check box for bibtex or apa: then parse 
+    return (temp.render(model_id = st.session_state["model_name"],
+        language = st.session_state["languages"],
+        the_model_description = st.session_state["model_description"],developers=st.session_state["Model_developers"],shared_by = st.session_state["Shared_by"],model_license = st.session_state['license'],
+        parent_model_link = st.session_state['Parent_Model_url'],
+            direct_use = st.session_state["Direct_Use"], downstream_use = st.session_state["Downstream_Use"],out_of_scope_use = st.session_state["Out-of-Scope_Use"],
+            bias_risks_limitations = st.session_state["Model_Limits_n_Risks"], bias_recommendations = st.session_state['Recommendations'],
+            model_examination = st.session_state['Model_examin'],
+            speeds_sizes_times = st.session_state['Speeds_Sizes_Times'],
+            hardware= st.session_state['Model_hardware'], hours_used = st.session_state['hours_used'], cloud_provider = st.session_state['Model_cloud_provider'], cloud_region = st.session_state['Model_cloud_region'], co2_emitted = st.session_state['Model_c02_emitted'],
+            citation_bibtex= st.session_state["APA_citation"], citation_apa = st.session_state['bibtex_citation'],
+            training_data = st.session_state['training_Data'], preprocessing =st.session_state['model_preprocessing'],
+            model_specs = st.session_state['Model_specs'], compute_infrastructure = st.session_state['compute_infrastructure'],software = st.session_state['technical_specs_software'],
+            glossary = st.session_state['Glossary'], 
+            more_information = st.session_state['More_info'], 
+            model_card_authors = st.session_state['the_authors'],
+            model_card_contact = st.session_state['Model_card_contact'],
+            get_started_code =st.session_state["Model_how_to"],
+            repo_link = st.session_state["github_url"],
+            paper_link = st.session_state["paper_url"],
+            blog_link = st.session_state["blog_url"],
+            testing_data = st.session_state["Testing_Data"],
+            testing_factors = st.session_state["Factors"],
+            results = st.session_state['Model_Results'],
+            testing_metrics = st.session_state["Metrics"]
+            ))
+
+
+
+################################################################
+################################################################
+################################################################
+################## Below CURRENTLY Deprecated ##################
+################################################################
+################################################################
+################################################################
+
+
+
+def apply_view(page_state, not_code_pull,text_passed):
+    not_important_section = True
+    if st.session_state.legal_view == True:
+        #user_view = 'legal_view'
+        user_view_collapse={'Model_details_text','Model_uses','Model_Eval','Model_carbon','Model_cite', 'Glossary','Model_card_authors'}
+        
+    elif st.session_state.researcher_view == True:
+        #user_view = 'researcher_view'
+        user_view_collapse={'Model_details_text','Model_how_to','Model_training','Model_Limits_n_Risks', 'Glossary', 'Model_card_contact', 'Citation'}
+        
+    else:
+        #user_view = 'beginner_technical_view'
+        user_view_collapse={'Model_details_text','Model_how_to','Model_Eval','Model_uses', 'Glossary'} # Add Techical Spec
+    
+
+    for value in user_view_collapse:
+        if value == page_state:
+            not_important_section = False
+            
+    if not_important_section == True: #and st.session_state[user_view]:
+        #st.markdown("here")
+        text_return = out_text_out(not_code_pull,page_state,text_passed)
+        out_text = "<details> <summary> Click to expand </summary>" +text_return + "</details>"
+        return (out_text)
+        
+        #out_text = "<details>" + out_text + "</details>"
+    else:
+        text_return = out_text_out(not_code_pull,page_state,text_passed)
+        out_text = text_return
+        return (out_text)
+
+def out_text_out(not_code_pull,page_state,out_text):
+    if not_code_pull == True:
+        out_text = extract_it(page_state)
+        return(out_text)
+    else: 
+        out_text = out_text
+        return(out_text)
+        
+def writingPrompt(page_state, help_text, out_text):
+    #st.session_state.check_box = False 
+    #extracted_how_to= tag_checker(markdown,start_tag,end_tag)
+    
+    
+    
+    #see_suggestion = column.checkbox("See Writing Prompt")
+    
+    st.session_state.check_box = True
+    variable_output_prompt = st.text_area("Enter some text",height = 500, value =out_text, key=persist(out_text),
+    help=help_text)
+    st.session_state.page_state = persist(variable_output_prompt)
+    #out_text = extract_it(page_state)
+        
+        
+    #else:
+        #st.session_state.check_box = True
+        ##st.session_state.check_box = False
+        #variable_output_prompt = st.text_area("Enter Text",value = ' ',key=persist(page_state),height = 500,help =help_text)
+        
+    return variable_output_prompt
+
+
+
+def extract_section(current_template, start_tag, end_tag):
+    current_Card_markdown= current_template
+
+    extracted_how_to= tag_checker(current_Card_markdown,start_tag,end_tag)
+    out_text = ' '.join(extracted_how_to)
+    return out_text
+
+def main():
+    #card.save('current_card.md')
+    return 

modelcard_template_new_spec.md

@@ -0,0 +1,225 @@
+---
+{{card_data}}
+---
+
+# {{ model_id }}
+
+<!--> Provide a quick summary of what the model is/does. <!-->
+
+#  Table of Contents
+
+- [{{ model_id }}](#-model_id-)
+- [Table of Contents](#table-of-contents)
+- [Model Details](#model-details)
+  - [Model Description](#model-description)
+- [Uses](#uses)
+  - [Direct Use](#direct-use)
+  - [Downstream Use [Optional]](#downstream-use-optional)
+  - [Out-of-Scope Use](#out-of-scope-use)
+- [Bias, Risks, and Limitations](#bias-risks-and-limitations)
+  - [Recommendations](#recommendations)
+- [Training Details](#training-details)
+  - [Training Data](#training-data)
+  - [Training Procedure](#training-procedure)
+    - [Preprocessing](#preprocessing)
+    - [Speeds, Sizes, Times](#speeds-sizes-times)
+- [Evaluation](#evaluation)
+  - [Testing Data, Factors & Metrics](#testing-data-factors--metrics)
+    - [Testing Data](#testing-data)
+    - [Factors](#factors)
+    - [Metrics](#metrics)
+  - [Results](#results)
+- [Model Examination](#model-examination)
+- [Environmental Impact](#environmental-impact)
+- [Technical Specifications [optional]](#technical-specifications-optional)
+  - [Model Architecture and Objective](#model-architecture-and-objective)
+  - [Compute Infrastructure](#compute-infrastructure)
+    - [Hardware](#hardware)
+    - [Software](#software)
+- [Citation](#citation)
+- [Glossary [optional]](#glossary-optional)
+- [More Information [optional]](#more-information-optional)
+- [Model Card Authors [optional]](#model-card-authors-optional)
+- [Model Card Contact](#model-card-contact)
+- [How to Get Started with the Model](#how-to-get-started-with-the-model)
+
+
+# Model Details
+
+## Model Description
+
+<!--> Provide a longer summary of what this model is. <!-->
+{{ the_model_description | default("More information needed", true)}}
+
+- **Developed by:** {{ developers | default("More information needed", true)}}
+- **Shared by [Optional]:** {{ shared_by | default("More information needed", true)}}
+- **Model type:** Language model
+- **Language(s) (NLP):** {{ language | default("More information needed", true)}}
+- **License:** {{ license | default("More information needed", true)}}
+- **Related Models:** {{ related_models | join(', ') | default("More information needed", true)}} 
+{{ "    -  [Parent Model]({0})".format(repo_link) if parent_model_link }}
+- **Resources for more information:** {{ more_resources | default("More information needed", true)}}
+{{ "    - [GitHub Repo]({0})".format(repo_link) if repo_link }}
+{{ "    - [Associated Paper]({0})".format(paper_link) if paper_link }}
+{{ "    - [Blog Post]({0})".format(blog_link) if blog_link }}
+
+# Uses
+
+<!--> Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. <!-->
+
+## Direct Use
+
+<!--> This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. <!-->
+
+{{ direct_use | default("More information needed", true)}}
+
+## Downstream Use [Optional]
+
+<!--> This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app <!-->
+
+{{ downstream_use | default("More information needed", true)}}
+
+## Out-of-Scope Use
+
+<!--> This section addresses misuse, malicious use, and uses that the model will not work well for. <!-->
+
+{{ out_of_scope_use | default("More information needed", true)}}
+
+# Bias, Risks, and Limitations
+
+<!--> This section is meant to convey both technical and sociotechnical limitations. <!-->
+
+{{ bias_risks_limitations | default("More information needed", true)}}
+
+## Recommendations
+
+<!--> This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. <!-->
+
+{{ bias_recommendations | default("Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recomendations.", true)}}
+
+# Training Details
+
+## Training Data
+
+<!--> This should link to a Data Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. <!-->
+
+{{ training_data | default("More information needed", true)}}
+
+## Training Procedure
+
+<!--> This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. <!-->
+
+### Preprocessing
+
+{{ preprocessing | default("More information needed", true)}}
+
+### Speeds, Sizes, Times
+
+<!--> This section provides information about throughput, start/end time, checkpoint size if relevant, etc. <!-->
+
+{{ speeds_sizes_times | default("More information needed", true)}}
+ 
+# Evaluation
+
+<!--> This section describes the evaluation protocols and provides the results. <!-->
+
+## Testing Data, Factors & Metrics
+
+### Testing Data
+
+<!--> This should link to a Data Card if possible. <!-->
+
+{{ testing_data | default("More information needed", true)}}
+
+### Factors
+
+<!--> These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. <!-->
+
+{{ testing_factors | default("More information needed", true)}}
+
+### Metrics
+
+<!--> These are the evaluation metrics being used, ideally with a description of why. <!-->
+
+{{ testing_metrics | default("More information needed", true)}}
+
+## Results 
+
+{{ results | default("More information needed", true)}}
+
+# Model Examination
+
+{{ model_examination | default("More information needed", true)}}
+
+# Environmental Impact
+
+<!--> Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly <!-->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** {{ hardware | default("More information needed", true)}}
+- **Hours used:** {{ hours_used | default("More information needed", true)}}
+- **Cloud Provider:** {{ cloud_provider | default("More information needed", true)}}
+- **Compute Region:** {{ cloud_region | default("More information needed", true)}}
+- **Carbon Emitted:** {{ co2_emitted | default("More information needed", true)}}
+
+# Technical Specifications [optional]
+
+## Model Architecture and Objective
+
+{{ model_specs | default("More information needed", true)}}
+
+## Compute Infrastructure
+
+{{ compute_infrastructure | default("More information needed", true)}}
+
+### Hardware
+
+{{ hardware | default("More information needed", true)}}
+
+### Software
+
+{{ software | default("More information needed", true)}}
+
+# Citation
+
+<!--> If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. <!-->
+
+**BibTeX:**
+
+{{ citation_bibtex | default("More information needed", true)}}
+
+**APA:**
+
+{{ citation_apa | default("More information needed", true)}}
+
+# Glossary [optional]
+
+<!--> If relevant, include terms and calculations in this section that can help readers understand the model or model card. <!-->
+
+{{ glossary | default("More information needed", true)}}
+
+# More Information [optional]
+
+{{ more_information | default("More information needed", true)}}
+
+# Model Card Authors [optional]
+
+{{ model_card_authors | default("More information needed", true)}}
+
+# Model Card Contact
+
+{{ model_card_contact | default("More information needed", true)}}
+
+# How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+<details>
+<summary> Click to expand </summary>
+
+{{ get_started_code | default("More information needed", true)}}
+
+</details>
+
+

out_markd.md

@@ -0,0 +1,1042 @@
+#
+ 
+
+
+
+
+#
+ 
+M
+o
+d
+e
+l
+ 
+D
+e
+t
+a
+i
+l
+s
+
+
+#
+#
+ 
+M
+o
+d
+e
+l
+ 
+D
+e
+s
+c
+r
+i
+p
+t
+i
+o
+n
+
+
+<
+!
+-
+-
+>
+ 
+P
+r
+o
+v
+i
+d
+e
+ 
+a
+ 
+l
+o
+n
+g
+e
+r
+ 
+s
+u
+m
+m
+a
+r
+y
+ 
+o
+f
+ 
+w
+h
+a
+t
+ 
+t
+h
+i
+s
+ 
+m
+o
+d
+e
+l
+ 
+i
+s
+.
+ 
+<
+!
+-
+-
+>
+
+
+-
+ 
+*
+*
+D
+e
+v
+e
+l
+o
+p
+e
+d
+ 
+b
+y
+:
+*
+*
+ 
+{
+{
+ 
+d
+e
+v
+e
+l
+o
+p
+e
+r
+s
+ 
+|
+ 
+d
+e
+f
+a
+u
+l
+t
+(
+"
+M
+o
+r
+e
+ 
+i
+n
+f
+o
+r
+m
+a
+t
+i
+o
+n
+ 
+n
+e
+e
+d
+e
+d
+"
+,
+ 
+t
+r
+u
+e
+)
+}
+}
+-
+ 
+*
+*
+S
+h
+a
+r
+e
+d
+ 
+b
+y
+ 
+[
+O
+p
+t
+i
+o
+n
+a
+l
+]
+:
+*
+*
+ 
+{
+{
+ 
+s
+h
+a
+r
+e
+d
+_
+b
+y
+ 
+|
+ 
+d
+e
+f
+a
+u
+l
+t
+(
+"
+M
+o
+r
+e
+ 
+i
+n
+f
+o
+r
+m
+a
+t
+i
+o
+n
+ 
+n
+e
+e
+d
+e
+d
+"
+,
+ 
+t
+r
+u
+e
+)
+}
+}
+-
+ 
+*
+*
+M
+o
+d
+e
+l
+ 
+t
+y
+p
+e
+:
+*
+*
+ 
+L
+a
+n
+g
+u
+a
+g
+e
+ 
+m
+o
+d
+e
+l
+-
+ 
+*
+*
+L
+a
+n
+g
+u
+a
+g
+e
+(
+s
+)
+ 
+(
+N
+L
+P
+)
+:
+*
+*
+ 
+{
+{
+ 
+l
+a
+n
+g
+u
+a
+g
+e
+ 
+|
+ 
+d
+e
+f
+a
+u
+l
+t
+(
+"
+M
+o
+r
+e
+ 
+i
+n
+f
+o
+r
+m
+a
+t
+i
+o
+n
+ 
+n
+e
+e
+d
+e
+d
+"
+,
+ 
+t
+r
+u
+e
+)
+}
+}
+-
+ 
+*
+*
+L
+i
+c
+e
+n
+s
+e
+:
+*
+*
+ 
+{
+{
+ 
+l
+i
+c
+e
+n
+s
+e
+ 
+|
+ 
+d
+e
+f
+a
+u
+l
+t
+(
+"
+M
+o
+r
+e
+ 
+i
+n
+f
+o
+r
+m
+a
+t
+i
+o
+n
+ 
+n
+e
+e
+d
+e
+d
+"
+,
+ 
+t
+r
+u
+e
+)
+}
+}
+-
+ 
+*
+*
+R
+e
+l
+a
+t
+e
+d
+ 
+M
+o
+d
+e
+l
+s
+:
+*
+*
+ 
+{
+{
+ 
+r
+e
+l
+a
+t
+e
+d
+_
+m
+o
+d
+e
+l
+s
+ 
+|
+ 
+d
+e
+f
+a
+u
+l
+t
+(
+"
+M
+o
+r
+e
+ 
+i
+n
+f
+o
+r
+m
+a
+t
+i
+o
+n
+ 
+n
+e
+e
+d
+e
+d
+"
+,
+ 
+t
+r
+u
+e
+)
+}
+}
+ 
+ 
+ 
+ 
+-
+ 
+*
+*
+P
+a
+r
+e
+n
+t
+ 
+M
+o
+d
+e
+l
+:
+*
+*
+ 
+{
+{
+ 
+p
+a
+r
+e
+n
+t
+_
+m
+o
+d
+e
+l
+ 
+|
+ 
+d
+e
+f
+a
+u
+l
+t
+(
+"
+M
+o
+r
+e
+ 
+i
+n
+f
+o
+r
+m
+a
+t
+i
+o
+n
+ 
+n
+e
+e
+d
+e
+d
+"
+,
+ 
+t
+r
+u
+e
+)
+}
+}
+-
+ 
+*
+*
+R
+e
+s
+o
+u
+r
+c
+e
+s
+ 
+f
+o
+r
+ 
+m
+o
+r
+e
+ 
+i
+n
+f
+o
+r
+m
+a
+t
+i
+o
+n
+:
+*
+*
+ 
+{
+{
+ 
+m
+o
+r
+e
+_
+r
+e
+s
+o
+u
+r
+c
+e
+s
+ 
+|
+ 
+d
+e
+f
+a
+u
+l
+t
+(
+"
+M
+o
+r
+e
+ 
+i
+n
+f
+o
+r
+m
+a
+t
+i
+o
+n
+ 
+n
+e
+e
+d
+e
+d
+"
+,
+ 
+t
+r
+u
+e
+)
+}
+}
+ 
+<
+d
+e
+t
+a
+i
+l
+s
+>
+ 
+<
+s
+u
+m
+m
+a
+r
+y
+>
+ 
+C
+l
+i
+c
+k
+ 
+t
+o
+ 
+e
+x
+p
+a
+n
+d
+ 
+<
+/
+s
+u
+m
+m
+a
+r
+y
+>
+
+
+#
+ 
+B
+i
+a
+s
+,
+ 
+R
+i
+s
+k
+s
+,
+ 
+a
+n
+d
+ 
+L
+i
+m
+i
+t
+a
+t
+i
+o
+n
+s
+
+
+<
+!
+-
+-
+>
+ 
+T
+h
+i
+s
+ 
+s
+e
+c
+t
+i
+o
+n
+ 
+i
+s
+ 
+m
+e
+a
+n
+t
+ 
+t
+o
+ 
+c
+o
+n
+v
+e
+y
+ 
+b
+o
+t
+h
+ 
+t
+e
+c
+h
+n
+i
+c
+a
+l
+ 
+a
+n
+d
+ 
+s
+o
+c
+i
+o
+t
+e
+c
+h
+n
+i
+c
+a
+l
+ 
+l
+i
+m
+i
+t
+a
+t
+i
+o
+n
+s
+.
+ 
+<
+!
+-
+-
+>
+
+
+#
+#
+ 
+R
+e
+c
+o
+m
+m
+e
+n
+d
+a
+t
+i
+o
+n
+s
+
+
+<
+!
+-
+-
+>
+ 
+T
+h
+i
+s
+ 
+s
+e
+c
+t
+i
+o
+n
+ 
+i
+s
+ 
+m
+e
+a
+n
+t
+ 
+t
+o
+ 
+c
+o
+n
+v
+e
+y
+ 
+r
+e
+c
+o
+m
+m
+e
+n
+d
+a
+t
+i
+o
+n
+s
+ 
+w
+i
+t
+h
+ 
+r
+e
+s
+p
+e
+c
+t
+ 
+t
+o
+ 
+t
+h
+e
+ 
+b
+i
+a
+s
+,
+ 
+r
+i
+s
+k
+,
+ 
+a
+n
+d
+ 
+t
+e
+c
+h
+n
+i
+c
+a
+l
+ 
+l
+i
+m
+i
+t
+a
+t
+i
+o
+n
+s
+.
+ 
+<
+!
+-
+-
+>
+ 
+<
+/
+d
+e
+t
+a
+i
+l
+s
+>

output.md

@@ -0,0 +1,5 @@
+# Collection of ideas
+## Idea 0
+
+[1]normal text under header 1
+

pages/10_ 📁_Technical Specifications.py

@@ -0,0 +1,61 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+#from specific_extraction import extract_it
+
+
+global variable_output
+
+def main():
+    cs_body()
+   
+
+
+def cs_body():
+    
+   
+    st.markdown('# Technical Specifications [optional]')
+    st.write("Provide an overview of any additional technical specifications for this model")
+    left, right = st.columns([2,4])
+    
+    
+
+    with left: 
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Model Architecture and Objective:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Compute Infrastructure:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+       
+        st.markdown('##### Hardware:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.markdown('##### Software:')
+        
+    with right:
+        #soutput_jinja = parse_into_jinja_markdown()
+        st.text_area("", key=persist("Model_specs"))
+        #st.write("\n")
+        st.text_area("",key=persist("compute_infrastructure"))
+        st.text_area("", key=persist("Model_hardware"))
+        st.text_area("", key=persist("technical_specs_software"))
+        
+   
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/11_ 📬_Model_Card_Contact.py

@@ -0,0 +1,26 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+#from specific_extraction import extract_it
+
+
+global variable_output
+
+def main():
+    cs_body()
+   
+
+
+def cs_body():
+    
+    st.markdown('# Model Card Contact')
+    st.text_area("How can people who have updates to the Model Card contact the authors?", key=persist("Model_card_contact"), )
+
+        
+   
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/12_👩‍💻_How_To_Get_Started.py

@@ -0,0 +1,30 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+from extract_code import read_file
+
+
+
+global variable_output
+
+def main():
+
+    cs_body()
+
+def cs_body():
+    
+    library_name = st.session_state.library_name
+    model_name = st.session_state.model_name
+    model_name_to_str = f"{model_name}"
+    library_name_to_str = f"{library_name}"
+    text_pass = read_file(library_name_to_str, model_name_to_str) ## get the how to get started code
+    
+    st.markdown('# How to Get Started with the Model')
+    st.session_state['Model_how_to'] = text_pass
+    st.text_area("Code snippet to show how to use the model.",height = 300, key=persist("Model_how_to"))
+   
+        
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/13_🔖_Model_Card_Authors.py

@@ -0,0 +1,26 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+
+
+global variable_output
+
+def main():
+    cs_body()
+   
+
+
+def cs_body():
+    # Model Cards
+    #card = get_card()
+    #card.save('current_editable.md')
+    
+    st.markdown('# Model Card Authors [optional]')
+    st.text_area("This section also provides another layer of transparency and accountability. Whose views is this model card representing? How many voices were included in its construction? Etc.",height = 180, help = "The people who actually constructed the Model Card go here.",key=persist("the_authors"))
+    
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/14_📚_Glossary.py

@@ -0,0 +1,24 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+
+global variable_output
+
+def main():
+    cs_body()
+   
+
+
+def cs_body():
+
+    st.markdown('# Glossary [optional]')
+    st.text_area("Terms used in the model card that need to be clearly defined in order to be accessible across audiences go here.",height = 200, key=persist("Glossary"))
+   
+        
+        
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/15_More_Information.py

@@ -0,0 +1,24 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+
+global variable_output
+
+def main():
+    cs_body()
+   
+
+
+def cs_body():
+   
+        
+    st.markdown('# More Information [optional]')
+    st.text_area("Any additional information",height = 200, key=persist("More_info"))
+    
+   
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/1_👀_CardProgress.py

@@ -0,0 +1,15 @@
+from ast import parse
+import streamlit as st
+from persist import load_widget_state
+from middleMan import parse_into_jinja_markdown as pj
+import os
+
+def main():
+    ## call the jinja_parser
+    st.write( pj())
+
+  
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/2_📜_Model_Details.py

@@ -0,0 +1,87 @@
+import streamlit as st
+from persist import persist, load_widget_state
+#from middleMan import get_card,writingPrompt,apply_view
+import pandas as pd
+import requests
+
+#from specific_extraction import extract_it
+
+
+global variable_output
+
+@st.cache
+def get_cached_data():
+    languages_df = pd.read_html("https://hf.co/languages")[0]
+    languages_map = pd.Series(languages_df["Language"].values, index=languages_df["ISO code"]).to_dict()
+
+    license_df = pd.read_html("https://huggingface.co/docs/hub/repositories-licenses")[0]
+    license_map = pd.Series(
+        license_df["License identifier (to use in model card)"].values, index=license_df.Fullname
+    ).to_dict()
+
+    available_metrics = [x['id'] for x in requests.get('https://huggingface.co/api/metrics').json()]
+
+    r = requests.get('https://huggingface.co/api/models-tags-by-type')
+    tags_data = r.json()
+    libraries = [x['id'] for x in tags_data['library']]
+    tasks = [x['id'] for x in tags_data['pipeline_tag']]
+    #return languages_map, license_map, available_metrics, libraries, tasks
+    return license_map
+
+
+def cs_body():
+    license_map= get_cached_data()
+    Supervision_learning_method_list = ["Unsupervised","Semi-supervised","Self-supervised","Supervised","Reinforcement Learning"]
+    Machine_Learning_Type_list = ["Neural Network","SVM","Decision Trees"]
+    Modality_List = ["Computer Vision","Natural Language Processing","Audio","Speech","Multimodal","Tabular"]
+
+    #st.set_page_config(layout="wide") ## not yet supported on the hub
+    st.markdown('## Model Details')
+    st.markdown('### Model Description')
+    st.text_area("Provide a 1-2 sentence summary of what this model is.", help="The model description provides basic details about the model. This includes the architecture, version, if it was introduced in a paper, if an original implementation is available, the author, and general information about the model. Any copyright should be attributed here. General information about training procedures, parameters, and important disclaimers can also be mentioned in this section.", key=persist('model_description'))
+
+    left, right = st.columns([4,6])
+    sub_col1, sub_col2, sub_col3 = st.columns(3)
+    with st.container():
+        with left: 
+            st.write("\n")
+            st.write("\n")
+            st.markdown('### Developed By:')
+            st.write("\n")
+            st.write("\n")
+            st.write("\n")
+            st.markdown('### Shared By [optional]:')
+            st.write("\n")
+            st.write("\n")
+            st.write("\n")
+            st.markdown('### License:')
+            st.write("\n")
+            
+            st.markdown('### Model Type:')
+            
+        with right:
+            st.text_input("",help="List the people who built the model.", key=persist("Model_developers"))
+            st.write("\n")
+            st.text_input("",help="List the people/organization making the model available online.",key=persist("Shared_by"))
+            st.write("\n")
+            st.selectbox("",[""] + list(license_map.values()), help="The license associated with this model.", key=persist("license"))
+        
+    with st.container():
+        
+        with sub_col1:
+            st.multiselect(" Supervision/Learning Method", [""]+ Supervision_learning_method_list, key=persist("Supervision_learning_method"))
+        with sub_col2:
+            st.multiselect("Machine Learning Type",[""]+Machine_Learning_Type_list, key=persist("Machine_Learning_Type"))
+        with sub_col3:
+            st.multiselect("Modality",[""]+Modality_List, key=persist("Modality"))
+        
+
+def main():
+    cs_body()
+
+    
+
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/3_ 🏗_Uses.py

@@ -0,0 +1,47 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+global variable_output
+
+def main():
+
+    cs_body()
+
+def cs_body():
+    
+    st.markdown('# Uses')
+    st.text_area("This section addresses questions around how the model is intended to be used, discusses the foreseeable users of the model (including those affected by the model), and describes uses that are considered out of scope or misuse of the model.")
+    left, right = st.columns([2,4])
+    
+    #st.markdown('### Model Description')
+    
+
+    with left: 
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Direct Use:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        #st.write("\n")
+        st.markdown('### Downstream Use [Optional]:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Out-of-Scope Use:')
+        
+    with right:
+        st.text_area("",help="How can this model be used, without additional post-processing or further pipeline work?", key=persist("Direct_Use"))
+        st.text_area("",help="How can this model be used, when incorporated into another system?",key=persist("Downstream_Use"))
+        st.text_area("", help="What tasks will the model not work for?", key=persist("Out-of-Scope_Use"))
+
+   
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/4_⚠️_Limits_and_Risks.py

@@ -0,0 +1,36 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+
+
+global variable_output
+
+def main():
+    cs_body()
+
+def cs_body():
+    
+    st.markdown('# Bias, Risks, and Limitations')
+    st.text_area("What are the known or foreseeable issues stemming from this model? Use this section to convey both technical and sociotechnical limitations",help="Provide an overview of the possible Limitations and Risks that may be associated with this model", key=persist("Model_Limits_n_Risks"), )
+    left, right = st.columns([2,4])
+    
+    #st.markdown('### Model Description')
+    
+
+    with left: 
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Recommendations:')
+        
+        
+    with right:
+        #soutput_jinja = parse_into_jinja_markdown()
+        st.text_area("",help="How can the known or foreseeable issues be addressed?", key=persist("Recommendations"))
+        #st.write("\n")
+  
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/5_🏋️‍♀️_Model_training.py

@@ -0,0 +1,87 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+global variable_output
+
+def main():
+  
+    cs_body()
+  
+
+def cs_body():
+    
+    st.markdown('# Training Details')
+    st.write("Provide an overview of the Training Data and Training Procedure for this model")
+    left, middle, right = st.columns([2,1,7])
+
+    with left: 
+        st.write("\n")
+        st.write("\n")
+        st.markdown('## Training Data:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+    with middle:
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.markdown(' \n ## Training Procedure')
+    with left:
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+       
+        st.markdown('#### Preprocessing:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.markdown('#### Speeds, Sizes, Time:')
+        
+    with right:
+        #soutput_jinja = parse_into_jinja_markdown()
+        
+        st.text_area("", help ="Ideally this links to a Dataset Card.", key=persist("training_Data"))
+        #st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        
+        st.text_area("",key=persist("model_preprocessing"))
+        st.text_area("", help = "This section provides information about throughput, start/end time, checkpoint size if relevant, etc.", key=persist("Speeds_Sizes_Times"))
+   
+   
+   
+   
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/6_🔬_Model_Evaluation.py

@@ -0,0 +1,66 @@
+import streamlit as st
+from persist import persist, load_widget_state
+from pathlib import Path
+
+from middleMan import apply_view,writingPrompt
+
+global variable_output
+
+def main():
+    cs_body()
+    
+
+def cs_body():
+  
+    #stateVariable = 'Model_Eval'
+    #help_text ='Detail the Evaluation Results for this model'
+    #col1.header('Model Evaluation')
+    st.markdown('# Evaluation')
+    st.text_area(" This section describes the evaluation protocols and provides the results. ",help="Detail the Evaluation Results for this model")
+    st.markdown('## Testing Data, Factors & Metrics:')
+    left, right = st.columns([2,4])
+    
+    #st.markdown('### Model Description')
+    
+
+    with left: 
+        st.write("\n")
+        st.write("\n")
+        st.markdown('#### Testing Data:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        #st.write("\n")
+        st.markdown('#### Factors:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.markdown('#### Metrics:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.markdown('#### Results:')
+        
+    with right:
+        #soutput_jinja = parse_into_jinja_markdown()
+        st.text_area("", help="Ideally this links to a Dataset Card.",key=persist("Testing_Data"))
+        #st.write("\n")
+        st.text_area("",help="What are the foreseeable characteristics that will influence how the model behaves? This includes domain and context, as well as population subgroups.",key=persist("Factors"))
+        st.text_area("", help="What metrics will be used for evaluation in light of tradeoffs between different errors?", key=persist("Metrics"))
+        st.text_area("", key=persist("Model_Results"))
+
+   
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/7_🔎_Model_Examination.py

@@ -0,0 +1,35 @@
+import streamlit as st
+from persist import persist, load_widget_state
+
+#from specific_extraction import extract_it
+
+
+global variable_output
+
+def main():
+    cs_body()
+   
+
+
+def cs_body():
+    
+    #col1.header('Model Examination')
+    #stateVariable = "Model_examin"
+    #help_text = 'Give an overview of your model, the relevant research paper, who trained it, etc.'
+
+    st.markdown('# Model Examination')
+    st.text_area("Experimental: Where explainability/interpretability work can go.",height = 200, key=persist("Model_examin"), )
+    #left, right = st.columns([2,4], gap="small")
+    
+    #st.markdown('### Model Description')
+    
+
+
+  
+    
+        
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/8_🌏_Environmental_Impact.py

@@ -0,0 +1,56 @@
+import streamlit as st
+from persist import persist, load_widget_state
+from pathlib import Path
+
+
+
+global variable_output
+
+def main():
+
+    cs_body()
+
+
+def cs_body():
+
+    stateVariable = 'Model_carbon'
+    help_text ='Provide an estimate for the carbon emissions: e.g hardware used, horus spent training, cloud provider '
+
+    st.markdown('# Environmental Impact')
+    st.markdown('###### Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).')
+    st.text_area("", help="Provide an estimate for the carbon emissions: e.g hardware used, horus spent training, cloud provider")
+
+    left, right = st.columns([2,4])
+    with left: 
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Hardware Type:')
+        st.write("\n")
+        st.write("\n")
+        #st.write("\n")
+        st.markdown('### Hours used:')
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Cloud Provider:')
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Compute Region:')
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Carbon Emitted:')
+    with right:
+        #soutput_jinja = parse_into_jinja_markdown()
+        st.text_input("",key=persist("Model_hardware"))
+        #st.write("\n")
+        st.text_input("",help="sw",key=persist("hours_used"))
+        st.text_input("",key=persist("Model_cloud_provider"))
+        st.text_input("",key=persist("Model_cloud_region"))
+        st.text_input("",help= 'in grams of CO2eq', key=persist("Model_c02_emitted")) ##to-do: auto calculate 
+    
+   
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

pages/9_📌_Citation.py

@@ -0,0 +1,48 @@
+import streamlit as st
+from persist import persist, load_widget_state
+from pathlib import Path
+
+
+
+global variable_output
+
+def main():
+    cs_body()
+
+def cs_body():
+
+    st.markdown('# Citation')
+    st.write("If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section")
+    left, right = st.columns([2,4])
+    
+    #st.markdown('### Model Description')
+    
+
+    with left: 
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### BibTeX:')
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### APA:')
+        
+        
+    with right:
+        
+        st.text_area("", key=persist("bibtex_citation"))
+        st.text_area("", key=persist("APA_citation"))
+        #st.write("\n")
+  
+   
+   
+    
+    
+    
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

persist.py

@@ -0,0 +1,26 @@
+# Thank god this existed.
+# https://gist.github.com/okld/0aba4869ba6fdc8d49132e6974e2e662
+
+from streamlit import session_state as _state
+
+_PERSIST_STATE_KEY = f"{__name__}_PERSIST"
+
+
+def persist(key: str) -> str:
+    """Mark widget state as persistent."""
+    if _PERSIST_STATE_KEY not in _state:
+        _state[_PERSIST_STATE_KEY] = set()
+
+    _state[_PERSIST_STATE_KEY].add(key)
+
+    return key
+
+
+def load_widget_state():
+    """Load persistent widget state."""
+    if _PERSIST_STATE_KEY in _state:
+        _state.update({
+            key: value
+            for key, value in _state.items()
+            if key in _state[_PERSIST_STATE_KEY]
+        })

requirements.txt

@@ -0,0 +1,4 @@
+streamlit
+modelcards==0.1.2
+pandas
+lxml

specific_extraction.py

@@ -0,0 +1,528 @@
+import re
+import streamlit as st
+from modelcards import CardData, ModelCard
+from markdownTagExtract import tag_checker,listToString,to_markdown
+#from specific_extraction import extract_it
+
+
+# from persist import persist
+#global bytes_data
+
+
+################################################################
+#### Markdown parser logic #################################
+################################################################
+
+def file_upload():
+    bytes_data = st.session_state.markdown_upload
+    return bytes_data
+
+
+# Sets up the basics
+model_card_md = file_upload()  # this is where the new model card will be read in from
+model_card_md = model_card_md#.decode("utf-8")
+# Does metadata appear in any other format than this?
+metadata_re = re.compile("^---(.*?)---", re.DOTALL)
+header_re = re.compile("^\s*# (.*)", re.MULTILINE)
+subheader_re = re.compile("^\s*## (.*)", re.MULTILINE)
+subsubheader_re = re.compile("^\s*### (.*)", re.MULTILINE)
+subsubsubheader_re = re.compile("^\s*#### (.*)", re.MULTILINE)
+# We could be a lot more flexible on this re.
+# We require keys to be bold-faced here.
+# We don't have to require bold, as long as it's key:value
+# **License:**
+# Bold terms use ** or __
+# Allows the mixing of ** and __ for bold but eh whatev
+key_value_re = re.compile("^\s*([*_]{2}[^*_]+[*_]{2})([^\n]*)", re.MULTILINE)
+# Hyphens or stars mark list items.
+# Unordered list
+list_item_re = re.compile("^\s*[-*+]\s+.*", re.MULTILINE)
+# This is the ordered list
+enum_re = re.compile("^\s*[0-9].*", re.MULTILINE)
+table_re = re.compile("^\s*\|.*", re.MULTILINE)
+text_item_re = re.compile("^\s*[A-Za-z(](.*)", re.MULTILINE)
+# text_item_re = re.compile("^\s*#\s*.*", re.MULTILINE)
+# Allows the mixing of -* and *- for italics but eh whatev
+italicized_text_item_re = re.compile(
+    "^[_*][^_*\s].*\n?.*[^_*][_*]$", flags=re.MULTILINE
+)
+tag_re = re.compile("^\s*<.*", re.MULTILINE)
+image_re = re.compile("!\[.*\]\(.*\)", re.MULTILINE)
+
+
+subheader_re_dict = {}
+subheader_re_dict[header_re] = subheader_re
+subheader_re_dict[subheader_re] = subsubheader_re
+subheader_re_dict[subsubheader_re] = subsubsubheader_re
+
+
+def get_metadata(section_text):
+    return list(metadata_re.finditer(section_text))
+
+
+def find_images(section_text):
+    return list(image_re.finditer(section_text))
+
+
+def find_tags(section_text):
+    return list(tag_re.finditer(section_text))
+
+
+def find_tables(section_text):
+    return list(table_re.finditer(section_text))
+
+
+def find_enums(section_text):
+    return list(enum_re.finditer(section_text))
+
+
+# Extracts the stuff from the .md file
+def find_key_values(section_text):
+    return list(key_value_re.finditer(section_text))
+
+
+def find_lists(section_text):
+    # Find lists: Those lines starting with either '-' or '*'
+    return list(list_item_re.finditer(section_text))
+
+
+def find_texts(section_text):
+    # Find texts: Free writing within a section
+    basic_text = list(text_item_re.finditer(section_text))
+    ital_text = list(italicized_text_item_re.finditer(section_text))
+    free_text = basic_text + ital_text
+    return free_text
+
+
+def find_headers(full_text):
+    headers = list(header_re.finditer(full_text))
+    subheaders = list(subheader_re.finditer(full_text))
+    subsubheaders = list(subsubheader_re.finditer(full_text))
+    subsubsubheaders = list(subsubsubheader_re.finditer(full_text))
+    return (headers, subheaders, subsubheaders, subsubsubheaders)
+
+
+metadata_list = get_metadata(model_card_md)
+if metadata_list != []:
+    metadata_end = metadata_list[-1].span()[-1]
+    print("Metadata extracted")
+    # Metadata processing can happen here.
+    # For now I'm just ignoring it.
+    model_card_md = model_card_md[metadata_end:]
+else:
+    print("No metadata found")
+
+# Matches of all header types
+headers_list = find_headers(model_card_md)
+print("Headers extracted")
+# This type of header (one #)
+headers = headers_list[0]
+## This type of header (two ##)
+subheaders = headers_list[1]
+### This type of header
+subsubheaders = headers_list[2]
+#### This type of header
+subsubsubheaders = headers_list[3]
+
+# Matches of bulleted lists
+lists_list = find_lists(model_card_md)
+print("Bulleted lists extracted")
+
+enums_list = find_enums(model_card_md)
+print("Enumerated lists extracted")
+
+key_value_list = find_key_values(model_card_md)
+print("Key values extracted")
+
+tables_list = find_tables(model_card_md)
+print("Tables extracted")
+
+tags_list = find_tags(model_card_md)
+print("Markup tags extracted")
+
+images_list = find_images(model_card_md)
+print("Images extracted")
+
+# Matches of free text within a section
+texts_list = find_texts(model_card_md)
+print("Free text extracted")
+
+
+# List items have the attribute: value;
+# This provides for special handling of those strings,
+# allowing us to check if it's a list item in order to split/print ok.
+LIST_ITEM = "List item"
+KEY_VALUE = "Key: Value"
+FREE_TEXT = "Free text"
+ENUM_LIST_ITEM = "Enum item"
+TABLE_ITEM = "Table item"
+TAG_ITEM = "Markup tag"
+IMAGE_ITEM = "Image"
+
+
+def create_span_dict(match_list, match_type):
+    """
+    Creates a dictionary made out of all the spans.
+    This is useful for knowing which types to fill out with what in the app.
+    Also useful for checking if there are spans in the .md file that we've missed.
+    """
+    span_dict = {}
+    for match in match_list:
+        if len(match.group().strip()) > 0:
+            span_dict[(match.span())] = (match.group(), match_type)
+    return span_dict
+
+
+metadata_span_dict = create_span_dict(metadata_list, "Metadata")
+# Makes a little dict for each span type
+header_span_dict = create_span_dict(headers, "# Header")
+subheader_span_dict = create_span_dict(subheaders, "## Subheader")
+subsubheader_span_dict = create_span_dict(subsubheaders, "### Subsubheader")
+subsubsubheader_span_dict = create_span_dict(subsubsubheaders, "#### Subsubsubheader")
+key_value_span_dict = create_span_dict(key_value_list, KEY_VALUE)
+lists_span_dict = create_span_dict(lists_list, LIST_ITEM)
+enums_span_dict = create_span_dict(enums_list, ENUM_LIST_ITEM)
+tables_span_dict = create_span_dict(tables_list, TABLE_ITEM)
+tags_span_dict = create_span_dict(tags_list, TAG_ITEM)
+images_span_dict = create_span_dict(images_list, IMAGE_ITEM)
+texts_span_dict = create_span_dict(texts_list, FREE_TEXT)
+
+# We don't have to have these organized by type necessarily.
+# Doing it here for clarity.
+all_spans_dict = {}
+all_spans_dict["headers"] = header_span_dict
+all_spans_dict["subheaders"] = subheader_span_dict
+all_spans_dict["subsubheaders"] = subsubheader_span_dict
+all_spans_dict["subsubsubheaders"] = subsubsubheader_span_dict
+all_spans_dict[LIST_ITEM] = lists_span_dict
+all_spans_dict[KEY_VALUE] = key_value_span_dict
+all_spans_dict[TABLE_ITEM] = tables_span_dict
+all_spans_dict[ENUM_LIST_ITEM] = enums_span_dict
+all_spans_dict[TAG_ITEM] = tags_span_dict
+all_spans_dict[IMAGE_ITEM] = images_span_dict
+all_spans_dict[FREE_TEXT] = texts_span_dict
+
+
+def get_sorted_spans(spans_dict):
+    merged_spans = {}
+    for span_dict in spans_dict.values():
+        merged_spans.update(span_dict)
+    sorted_spans = sorted(merged_spans)
+    return sorted_spans, merged_spans
+
+
+sorted_spans, merged_spans = get_sorted_spans(all_spans_dict)
+
+# Sanity/Parse check. Have we captured all spans in the .md file?
+if sorted_spans[0][0] != 0:
+    print("FYI, our spans don't start at the start of the file.")
+    print("We did not catch this start:")
+    print(model_card_md[: sorted_spans[0][0]])
+
+for idx in range(len(sorted_spans) - 1):
+    last_span_end = sorted_spans[idx][1]
+    new_span_start = sorted_spans[idx + 1][0]
+    if new_span_start > last_span_end + 1:
+        start_nonparse = sorted_spans[idx]
+        end_nonparse = sorted_spans[idx + 1]
+        text = model_card_md[start_nonparse[1] : end_nonparse[0]]
+        if text.strip():
+            print("Found an unparsed span in the file:")
+            print(start_nonparse)
+            print(" ---> ")
+            print(end_nonparse)
+            print(text)
+
+# print(header_span_dict)
+def section_map_to_help_text(text_retrieved):
+
+    presit_states = {
+        "## Model Details": "Give an overview of your model, the relevant research paper, who trained it, etc.",
+        "## How to Get Started with the Model": "Give an overview of how to get started with the model",
+        "## Limitations and Biases": "Provide an overview of the possible Limitations and Risks that may be associated with this model",
+        "## Uses": "Detail the potential uses, intended use and out-of-scope uses for this model",
+        "## Training": "Provide an overview of the Training Data and Training Procedure for this model",
+        "## Evaluation Results": "Detail the Evaluation Results for this model",
+        "## Environmental Impact": "Provide an estimate for the carbon emissions: Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here.",
+        "## Citation Information": "How to best cite the model authors",
+        "## Glossary": "If relevant, include terms and calculations in this section that can help readers understand the model or model card.",
+        "## More Information": "Any additional information",
+        "## Model Card Authors": "This section provides another layer of transparency and accountability. Whose views is this model card representing? How many voices were included in its construction? Etc.",
+        "Model Card Contact": "Mediums to use, in order to contact the model creators",
+        "##  Technical Specifications": " Additional technical information",
+        '## Model Examination': " Examining the model",
+    }
+
+    for key in presit_states:
+        if key == text_retrieved:
+            return presit_states(key)
+
+
+def section_map_to_persist(text_retrieved):
+
+    presit_states = {
+        "Model_details_text": "## Model Details",
+        "Model_how_to": "## How to Get Started with the Model",
+        "Model_Limits_n_Risks": "## Limitations and Biases",
+        "Model_uses": "## Uses",
+        "Model_training": "## Training",
+        "Model_Eval": "## Evaluation Results",
+        "Model_carbon": "## Environmental Impact",
+        "Model_cite": "## Citation Information",
+        "Glossary": "## Glossary",
+        "More_info": "## More Information",
+        "Model_card_authors": "## Model Card Authors",
+        "Model_card_contact": "## Model Card Contact",
+        "Technical_specs": "## Technical specifications",
+        "Model_examin": "## Model Examination",
+    }
+
+    for key in presit_states:
+        if presit_states[key] == text_retrieved:
+            return key
+
+
+def main():
+    # st.write('here')
+    print(extract_it("Model_details_text"))
+
+
+def extract_headers():
+    headers = {}
+    subheaders = {}
+    subsubheaders = {}
+    subsubsubheaders = {}
+    previous = (None, None, None, None)
+
+    for s in sorted_spans:
+        if merged_spans[s][1] == "# Header":
+            headers[s] = (sorted_spans.index(s), previous[0])
+            previous = (sorted_spans.index(s), previous[1], previous[2], previous[3])
+        if merged_spans[s][1] == "## Subheader":
+            subheaders[s] = (sorted_spans.index(s), previous[1])
+            previous = (previous[0], sorted_spans.index(s), previous[2], previous[3])
+        if merged_spans[s][1] == "### Subsubheader":
+            subsubheaders[s] = (sorted_spans.index(s), previous[2])
+            previous = (previous[0], previous[1], sorted_spans.index(s), previous[3])
+        if merged_spans[s][1] == "#### Subsubsubheader":
+            subsubsubheaders[s] = (sorted_spans.index(s), previous[3])
+            previous = (previous[0], previous[1], previous[2], sorted_spans.index(s))
+
+    return headers, subheaders, subsubheaders, subsubsubheaders
+
+
+def stringify():
+    headers, subheaders, subsubheaders, subsubsubheaders = extract_headers()
+    headers_strings = {}
+    subheaders_strings = {}
+    subsubheaders_strings = {}
+    subsubsubheaders_strings = {}
+
+    first = None
+    for i in headers:
+        if headers[i][1] == None:
+            continue
+        sub_spans = sorted_spans[headers[i][1] : headers[i][0]]
+        lines = []
+        for x in sub_spans:
+            lines.append(merged_spans[x][0])
+        try:
+            name = lines[0]
+        except:
+            name = "Model Details"
+        lines = "".join(lines)
+        # print(merged_spans[i][0] + "-------------------")
+        # print(lines)
+        headers_strings[
+            name.replace("\n# ", "")
+            .replace("    ", "")
+            .replace("  ", "")
+            .replace("\n", "")
+            .replace("{{", "")
+            .replace("}}", "")
+        ] = lines
+        first = i
+
+    first = None
+    for i in subheaders:
+        if subheaders[i][1] == None:
+            continue
+        sub_spans = sorted_spans[subheaders[i][1] : subheaders[i][0]]
+        lines = []
+        for x in sub_spans:
+            if merged_spans[x][1] == "## Subheader" and first == None:
+                break
+            elif merged_spans[x][1] == "# Header":
+                break
+            else:
+                lines.append(merged_spans[x][0])
+        try:
+            name = lines[0]
+        except:
+            name = "Model Details"
+        lines = "".join(lines)
+        # print(merged_spans[i][0] + "-------------------")
+        # print(lines)
+        subheaders_strings[
+            name.replace("\n# ", "").replace("    ", "").replace("  ", "")
+        ] = lines
+        first = i
+
+    first = None
+    for i in subsubheaders:
+        if subsubheaders[i][1] == None:
+            continue
+        sub_spans = sorted_spans[subsubheaders[i][1] : subsubheaders[i][0]]
+        lines = []
+        for x in sub_spans:
+            if merged_spans[x][1] == "## Subheader" or (
+                merged_spans[x][1] == "### Subsubheader" and first == None
+            ):
+                break
+            else:
+                lines.append(merged_spans[x][0])
+        lines = "".join(lines)
+
+        subsubheaders_strings[
+            merged_spans[i][0].replace("\n", "").replace("### ", "").replace("    ", "")
+        ] = lines
+        first = i
+
+    for i in subsubsubheaders:
+        if subsubsubheaders[i][1] == None:
+            continue
+        sub_spans = sorted_spans[subsubsubheaders[i][1] : subsubsubheaders[i][0]]
+        lines = []
+        for x in sub_spans:
+            if (
+                merged_spans[x][1] == "## Subheader"
+                or merged_spans[x][1] == "### Subsubheader"
+            ):
+                break
+            else:
+                lines.append(merged_spans[x][0])
+        lines = "".join(lines)
+
+        subsubsubheaders_strings[
+            merged_spans[i][0].replace("#### ", "").replace("**", "").replace("\n", "")
+        ] = lines
+
+    return (
+        headers_strings,
+        subheaders_strings,
+        subsubheaders_strings,
+        subsubsubheaders_strings,
+    )
+
+
+def extract_it(text_to_retrieve):
+    print("Span\t\tType\t\tText")
+    print("-------------------------------------")
+    found_subheader = False
+    current_subheader = " "
+    page_state = " "
+    help_text = " "
+    #st.write("in cs- body here")
+
+    (
+        headers_strings,
+        subheaders_strings,
+        subsubheaders_strings,
+        subsubsubheaders_strings,
+    ) = stringify()
+
+    h_keys = list(headers_strings.keys())
+    sh_keys = list(subheaders_strings.keys())
+    ssh_keys = list(subsubheaders_strings.keys())
+    sssh_keys = list(subsubsubheaders_strings.keys())
+
+    needed = [
+        "model details",
+        "howto",
+        "limitations",
+        "uses",
+        "training",
+        "evaluation",
+        "environmental",
+        "citation",
+        "glossary",
+        "more information",
+        "authors",
+        "contact",
+    ]  # not sure what keyword should be used for citation, howto, and contact
+    # info_strings = {
+    #     "details": "## Model Details",
+    #     "howto": "## How to Get Started with the Model",
+    #     "limitations": "## Limitations and Biases",
+    #     "uses": "## Uses",
+    #     "training": "## Training",
+    #     "evaluation": "## Evaluation Results",
+    #     "environmental": "## Environmental Impact",
+    #     "citation": "## Citation Information",
+    #     "glossary": "## Glossary",
+    #     "more information": "## More Information",
+    #     "authors": "## Model Card Authors",
+    #     "contact": "## Model Card Contact",
+    # }
+    info_strings = {
+        "model details": "",
+        "howto": "",
+        "limitations": "",
+        "uses": "",
+        "training": "",
+        "evaluation": "",
+        "environmental": "",
+        "citation": "",
+        "glossary": "",
+        "more information": "",
+        "authors": "",
+        "contact": "",
+    }
+
+    for x in needed:
+        for l in h_keys:
+            if x in l.lower():
+                info_strings[x] = info_strings[x] + headers_strings[l]
+        for i in sh_keys:
+            if x in i.lower():
+                info_strings[x] = info_strings[x] + subheaders_strings[i]
+        for z in ssh_keys:
+            try:
+                if x in z.lower():
+                    info_strings[x] = info_strings[x] + subsubheaders_strings[z]
+            except:
+                continue
+        for y in sssh_keys:
+            try:
+                if x in y.lower():
+                    info_strings[x] = info_strings[x] + subsubsubheaders_strings[y]
+            except:
+                continue
+
+    extracted_info = {
+        "Model_details_text": info_strings["model details"],
+        "Model_how_to": info_strings["howto"],
+        "Model_Limits_n_Risks": info_strings["limitations"],
+        "Model_uses": info_strings["uses"],
+        "Model_training": info_strings["training"],
+        "Model_Eval": info_strings["evaluation"],
+        "Model_carbon": info_strings["environmental"],
+        "Model_cite": info_strings["citation"],
+        "Glossary": info_strings["glossary"],
+        "More_info": info_strings["more information"],
+        "Model_card_authors": info_strings["authors"],
+        "Model_card_contact": info_strings["contact"],
+        "Technical_specs": "## Technical specifications",
+        "Model_examin": "## Model Examination",
+    }
+
+    #text_to_retrieve = "Model_details_text"
+
+    new_t = extracted_info[text_to_retrieve] + " "
+
+    return(new_t)
+
+
+if __name__ == "__main__":
+
+    main()

test_markdown_out.py

@@ -0,0 +1,30 @@
+import streamlit as st
+from persist import persist, load_widget_state
+from jinja2 import Environment, FileSystemLoader
+
+def parse_into_jinja_markdown():
+    env = Environment(loader=FileSystemLoader('.'), autoescape=True)
+    temp = env.get_template(st.session_state.markdown_upload)
+   
+    return (temp.render(model_id = st.session_state["model_name"],
+        the_model_description = st.session_state["model_description"],developers=st.session_state["Model_developers"],shared_by = st.session_state["shared_by"],model_license = st.session_state['license'],
+            direct_use = st.session_state["Direct_Use"], downstream_use = st.session_state["Downstream_Use"],out_of_scope_use = st.session_state["Out-of-Scope_Use"],
+            bias_risks_limitations = st.session_state["Model_Limits_n_Risks"], bias_recommendations = st.session_state['Recommendations'],
+            model_examination = st.session_state['Model_examin'],
+            hardware= st.session_state['Model_hardware'], hours_used = st.session_state['hours_used'], cloud_provider = st.session_state['Model_cloud_provider'], cloud_region = st.session_state['Model_cloud_region'], co2_emitted = st.session_state['Model_c02_emitted'],
+            citation_bibtex= st.session_state["APA_citation"], citation_apa = st.session_state['bibtex_citation'],
+            training_data = st.session_state['training_data'], preprocessing =st.session_state['preprocessing'], speeds_sizes_times = st.session_state['Speeds_Sizes_Times'],
+            model_specs = st.session_state['Model_specs'], compute_infrastructure = st.session_state['compute_infrastructure'],software = st.session_state['technical_specs_software'],
+            glossary = st.session_state['Glossary'], 
+            more_information = st.session_state['More_info'], 
+            model_card_authors = st.session_state['the_authors'],
+            model_card_contact = st.session_state['Model_card_contact'],
+            get_started_code =st.session_state["Model_how_to"]
+            ))
+
+def main():
+    st.write( parse_into_jinja_markdown())
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

testing_layout.py

@@ -0,0 +1,71 @@
+import streamlit as st
+from persist import persist, load_widget_state
+import pandas as pd
+import requests
+
+
+
+
+@st.cache
+def get_cached_data():
+    languages_df = pd.read_html("https://hf.co/languages")[0]
+    languages_map = pd.Series(languages_df["Language"].values, index=languages_df["ISO code"]).to_dict()
+
+    license_df = pd.read_html("https://huggingface.co/docs/hub/repositories-licenses")[0]
+    license_map = pd.Series(
+        license_df["License identifier (to use in model card)"].values, index=license_df.Fullname
+    ).to_dict()
+
+    available_metrics = [x['id'] for x in requests.get('https://huggingface.co/api/metrics').json()]
+
+    r = requests.get('https://huggingface.co/api/models-tags-by-type')
+    tags_data = r.json()
+    libraries = [x['id'] for x in tags_data['library']]
+    tasks = [x['id'] for x in tags_data['pipeline_tag']]
+    #return languages_map, license_map, available_metrics, libraries, tasks
+    return license_map
+
+
+
+
+
+def main():
+    license_map= get_cached_data()
+    #st.set_page_config(layout="wide")
+    st.markdown('## Model Details')
+    st.markdown('### Model Description')
+    st.text_area("Provide a 1-2 sentence summary of what this model is.", help="The model description provides basic details about the model. This includes the architecture, version, if it was introduced in a paper, if an original implementation is available, the author, and general information about the model. Any copyright should be attributed here. General information about training procedures, parameters, and important disclaimers can also be mentioned in this section.", key=persist('model_description'))
+
+    left, right = st.columns([2,6], gap="small")
+    with left: 
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Developed By:')
+        st.write("\n")
+        st.write("\n")
+        #st.write("\n")
+        st.markdown('### Shared By [optional]:')
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### Model Type:')
+        st.write("\n")
+        st.write("\n")
+        st.markdown('### License:')
+    with right:
+        st.write("\n")
+        st.write("\n")
+        st.text_input("",help="Developed By work", key=persist("Model_developers"))
+        st.write("\n")
+        st.write("\n")
+
+        st.text_input("",help="Shared By work",key=persist("shared_by"))
+        st.text_input("",help="Model Type work")
+        #st.write("\n")
+        st.selectbox("",[""] + list(license_map.values()), help="Licenses work", key=persist("license"))
+        
+   
+
+
+if __name__ == '__main__':
+    load_widget_state()
+    main()

viewCardProgress(old).py

@@ -0,0 +1,101 @@
+import streamlit as st
+from persist import persist, load_widget_state
+from modelcards import CardData, ModelCard
+from huggingface_hub import create_repo
+
+
+def is_float(value):
+    try:
+        float(value)
+        return True
+    except:
+        return False
+
+def get_card():
+    languages=st.session_state.languages or None
+    license=st.session_state.license or None
+    library_name = st.session_state.library_name or None
+    tags= [x.strip() for x in st.session_state.tags.split(',') if x.strip()]
+    tags.append("autogenerated-modelcard")
+    datasets= [x.strip() for x in st.session_state.datasets.split(',') if x.strip()] or None
+    metrics=st.session_state.metrics or None
+    model_name = st.session_state.model_name or None
+    model_description = st.session_state.model_description or None
+    #Model_details_text = st.session_state.Model_details_text or None
+    #Model_how_to = st.session_state.Model_how_to or None
+    authors = st.session_state.authors or None
+    paper_url = st.session_state.paper_url or None
+    github_url = st.session_state.github_url or None
+    bibtex_citations = st.session_state.bibtex_citations or None
+    emissions = float(st.session_state.emissions) if is_float(st.session_state.emissions) else None  # BUG
+
+    # Handle any warnings...
+    do_warn = False
+    warning_msg = "Warning: The following fields are required but have not been filled in: "
+    if not languages:
+        warning_msg += "\n- Languages"
+        do_warn = True
+    if not license:
+        warning_msg += "\n- License"
+        do_warn = True
+    if do_warn:
+        st.error(warning_msg)
+        st.stop()
+
+    # Generate and display card
+    card_data = CardData(
+        language=languages,
+        license=license,
+        library_name=library_name,
+        tags=tags,
+        datasets=datasets,
+        metrics=metrics,
+    )
+    if emissions:
+        card_data.co2_eq_emissions = {'emissions': emissions}
+
+    card = ModelCard.from_template(
+        card_data,
+        template_path='template.md',
+        model_id=model_name,
+        # Template kwargs:
+        model_description=model_description,
+        license=license,
+        authors=authors,
+        paper_url=paper_url,
+        github_url=github_url,
+        bibtex_citations=bibtex_citations,
+        emissions=emissions
+    )
+    return card
+
+
+def main():
+
+    card = get_card()
+    card.save('current_card.md')
+    view_raw = st.sidebar.checkbox("View Raw")
+    if view_raw:
+        st.text(card)
+    else:
+        st.markdown(card.text, unsafe_allow_html=True)
+
+    with st.sidebar:
+        with st.form("Upload to 🤗 Hub"):
+            st.markdown("Use a token with write access from [here](https://hf.co/settings/tokens)")
+            token = st.text_input("Token", type='password')
+            repo_id = st.text_input("Repo ID")
+            submit = st.form_submit_button('Upload to 🤗 Hub')
+
+        if submit:
+            if len(repo_id.split('/')) == 2:
+                repo_url = create_repo(repo_id, exist_ok=True, token=token)
+                card.push_to_hub(repo_id, token=token)
+                st.success(f"Pushed the card to the repo [here]({repo_url}!")
+            else:
+                st.error("Repo ID invalid. It should be username/repo-name. For example: nateraw/food")
+
+
+if __name__ == "__main__":
+    load_widget_state()
+    main()