New api-interface-community library - what's allowed and how to test it

🤗Hub
1

Hi,
I’m trying to add few models to the Hub, but they all follow clear pytorch approach not using any library supported by HF. I figured out that I could create a <my_lib> huggingface_hub/api-inference-community/ and link a repo with my models as a submodule there. I implement all the api hooks for widgets and that’s it.
My question is - would it be possible to do it this way, and if so is there a way to test the widgets before the “my_lib” commit to the huggingface_hub repo goes public ?

1 Like
2

That’s a smart approach for contributing PyTorch models to the Hub without relying on native Transformers or other HF-supported libraries! Creating a dedicated directory and linking your repo as a submodule seems like a viable way to structure things.

Regarding your question about testing widgets before the commit to huggingface_hub goes public, here’s a breakdown of what’s possible and how you might approach it:

Challenges and Considerations:

  1. Local Testing Environment: The primary challenge is recreating the Hugging Face Hub environment locally to properly test your widgets and API hooks.
  2. Dependency Management: You’ll need to ensure that your local testing environment has all the necessary dependencies, including the Hugging Face Hub library and any other dependencies required by your widgets.
  3. Access to Private Models: If your models are private (which they likely are during development), you’ll need to find a way to authenticate with the Hub in your local testing environment.
  4. Widget Rendering: Testing the actual rendering of your widgets can be tricky, as it may involve JavaScript and browser-specific behavior.

Possible Approaches:

  1. Fork and Local Development:

    • Fork the huggingface_hub repository on GitHub.
    • Create a new branch for your changes.
    • Clone your fork locally.
    • Create your <my_lib> directory and link your model repo as a submodule.
    • Implement your widget API hooks.
    • Use a local HTTP server (e.g., Python’s http.server or Node.js’s serve) to serve your modified huggingface_hub directory. This will simulate the Hugging Face Hub environment.
    • Test your widgets by accessing the local HTTP server in your browser. You may need to write some JavaScript code to fetch your models and display the widgets.

  2. Docker Containerization:

    • Create a Dockerfile that sets up a complete testing environment, including:
      • The huggingface_hub library (either installed from your fork or linked as a volume).
      • Any other dependencies required by your widgets.
      • A web server to serve your modified huggingface_hub directory.
    • Build a Docker image from your Dockerfile.
    • Run a container from your Docker image.
    • Test your widgets by accessing the container’s web server in your browser.

  3. API Testing and Local Mocking (Apidog):

Before deploying your changes and making it visible to the public make sure you do API testing.

Make sure you get this tool it will save you time from debugging since the code will always be working!

Key Considerations (Regardless of Approach):

  • Authentication: If your models are private, you’ll need to authenticate with the Hub in your local testing environment. Consider using environment variables to store your credentials.
  • Testing Data:Use a small, representative dataset for testing your widgets.
  • JavaScript Debugging: Use your browser’s developer tools to debug any JavaScript issues that may arise during widget rendering.
  • CI/CD: Consider setting up a CI/CD pipeline to automatically test your widgets whenever you make changes.

Good luck!

1 Like