genesis-flow 1.0.0__py3-none-any.whl

genesis_flow-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

genesis_flow-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,19 @@
+[console_scripts]
+genesis-flow = mlflow.cli:cli
+mlflow = mlflow.cli:cli
+
+[mlflow.app]
+basic-auth = mlflow.server.auth:create_app
+
+[mlflow.app.client]
+basic-auth = mlflow.server.auth.client:AuthServiceClient
+
+[mlflow.deployments]
+databricks = mlflow.deployments.databricks
+http = mlflow.deployments.mlflow
+https = mlflow.deployments.mlflow
+openai = mlflow.deployments.openai
+
+[mlflow.tracking_store]
+azure-postgres = mlflow.azure.stores:create_store
+postgresql = mlflow.azure.stores:create_store

genesis_flow-1.0.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,202 @@
+Copyright 2018 Databricks, Inc.  All rights reserved.
+
+				Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

genesis_flow-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mlflow

mlflow/__init__.py

@@ -0,0 +1,367 @@
+"""
+The ``mlflow`` module provides a high-level "fluent" API for starting and managing MLflow runs.
+For example:
+
+.. code:: python
+
+    import mlflow
+
+    mlflow.start_run()
+    mlflow.log_param("my", "param")
+    mlflow.log_metric("score", 100)
+    mlflow.end_run()
+
+You can also use the context manager syntax like this:
+
+.. code:: python
+
+    with mlflow.start_run() as run:
+        mlflow.log_param("my", "param")
+        mlflow.log_metric("score", 100)
+
+which automatically terminates the run at the end of the ``with`` block.
+
+The fluent tracking API is not currently threadsafe. Any concurrent callers to the tracking API must
+implement mutual exclusion manually.
+
+For a lower level API, see the :py:mod:`mlflow.client` module.
+"""
+
+import contextlib
+from typing import TYPE_CHECKING
+
+from mlflow.version import IS_TRACING_SDK_ONLY, VERSION
+
+__version__ = VERSION
+
+import mlflow.mismatch
+
+# `check_version_mismatch` must be called here before importing any other modules
+with contextlib.suppress(Exception):
+    mlflow.mismatch._check_version_mismatch()
+
+if not IS_TRACING_SDK_ONLY:
+    from mlflow import (
+        artifacts,  # noqa: F401
+        client,  # noqa: F401
+        config,  # noqa: F401
+        data,  # noqa: F401
+        exceptions,  # noqa: F401
+        genai,  # noqa: F401
+        models,  # noqa: F401
+        tracking,  # noqa: F401
+    )
+
+from mlflow import tracing  # noqa: F401
+from mlflow.environment_variables import MLFLOW_CONFIGURE_LOGGING
+from mlflow.exceptions import MlflowException
+from mlflow.utils.lazy_load import LazyLoader
+from mlflow.utils.logging_utils import _configure_mlflow_loggers
+
+# Genesis-Flow: Lazily load essential mlflow flavors only
+anthropic = LazyLoader("mlflow.anthropic", globals(), "mlflow.anthropic")
+ag2 = LazyLoader("mlflow.ag2", globals(), "mlflow.ag2")
+autogen = LazyLoader("mlflow.autogen", globals(), "mlflow.autogen")
+bedrock = LazyLoader("mlflow.bedrock", globals(), "mlflow.bedrock")
+crewai = LazyLoader("mlflow.crewai", globals(), "mlflow.crewai")
+dspy = LazyLoader("mlflow.dspy", globals(), "mlflow.dspy")
+gemini = LazyLoader("mlflow.gemini", globals(), "mlflow.gemini")
+groq = LazyLoader("mlflow.groq", globals(), "mlflow.groq")
+johnsnowlabs = LazyLoader("mlflow.johnsnowlabs", globals(), "mlflow.johnsnowlabs")
+langchain = LazyLoader("mlflow.langchain", globals(), "mlflow.langchain")
+litellm = LazyLoader("mlflow.litellm", globals(), "mlflow.litellm")
+llama_index = LazyLoader("mlflow.llama_index", globals(), "mlflow.llama_index")
+llm = LazyLoader("mlflow.llm", globals(), "mlflow.llm")
+metrics = LazyLoader("mlflow.metrics", globals(), "mlflow.metrics")
+mistral = LazyLoader("mlflow.mistral", globals(), "mlflow.mistral")
+openai = LazyLoader("mlflow.openai", globals(), "mlflow.openai")
+promptflow = LazyLoader("mlflow.promptflow", globals(), "mlflow.promptflow")
+pydantic_ai = LazyLoader("mlflow.pydantic_ai", globals(), "mlflow.pydantic_ai")
+pyfunc = LazyLoader("mlflow.pyfunc", globals(), "mlflow.pyfunc")
+pytorch = LazyLoader("mlflow.pytorch", globals(), "mlflow.pytorch")
+rfunc = LazyLoader("mlflow.rfunc", globals(), "mlflow.rfunc")
+shap = LazyLoader("mlflow.shap", globals(), "mlflow.shap")
+sklearn = LazyLoader("mlflow.sklearn", globals(), "mlflow.sklearn")
+smolagents = LazyLoader("mlflow.smolagents", globals(), "mlflow.smolagents")
+# TxtAI integration is defined at https://github.com/neuml/mlflow-txtai
+txtai = LazyLoader("mlflow.txtai", globals(), "mlflow_txtai")
+transformers = LazyLoader("mlflow.transformers", globals(), "mlflow.transformers")
+
+if TYPE_CHECKING:
+    # Do not move this block above the lazy-loaded modules above.
+    # All the lazy-loaded modules above must be imported here for code completion to work in IDEs.
+    from mlflow import (  # noqa: F401
+        ag2,
+        anthropic,
+        autogen,
+        bedrock,
+        crewai,
+        dspy,
+        gemini,
+        groq,
+        johnsnowlabs,
+        langchain,
+        litellm,
+        llama_index,
+        llm,
+        metrics,
+        mistral,
+        openai,
+        promptflow,
+        pydantic_ai,
+        pyfunc,
+        pytorch,
+        rfunc,
+        shap,
+        sklearn,
+        smolagents,
+        transformers,
+    )
+
+if MLFLOW_CONFIGURE_LOGGING.get() is True:
+    _configure_mlflow_loggers(root_module_name=__name__)
+
+# Core modules required for mlflow-tracing
+from mlflow.tracing.assessment import (
+    delete_assessment,
+    get_assessment,
+    log_assessment,
+    log_expectation,
+    log_feedback,
+    override_feedback,
+    update_assessment,
+)
+from mlflow.tracing.fluent import (
+    add_trace,
+    delete_trace_tag,
+    get_active_trace_id,
+    get_current_active_span,
+    get_last_active_trace_id,
+    get_trace,
+    log_trace,
+    search_traces,
+    set_trace_tag,
+    start_span,
+    start_span_no_context,
+    trace,
+    update_current_trace,
+)
+from mlflow.tracking import (
+    get_tracking_uri,
+    is_tracking_uri_set,
+    set_tracking_uri,
+)
+from mlflow.tracking.fluent import active_run, flush_trace_async_logging, set_experiment
+
+# These are minimal set of APIs to be exposed via `mlflow-tracing` package.
+# APIs listed here must not depend on dependencies that are not part of `mlflow-tracing` package.
+__all__ = [
+    "MlflowException",
+    # Minimal tracking APIs required for tracing core functionality
+    "set_experiment",
+    "set_tracking_uri",
+    "get_tracking_uri",
+    "is_tracking_uri_set",
+    # NB: Tracing SDK doesn't support using Runs, however, active_run is used heavily within
+    # the autologging code base.
+    "active_run",
+    # Tracing APIs
+    "add_trace",
+    "delete_trace_tag",
+    "flush_trace_async_logging",
+    "get_active_trace_id",
+    "get_current_active_span",
+    "get_last_active_trace_id",
+    "get_trace",
+    "log_trace",
+    "search_traces",
+    "set_trace_tag",
+    "start_span",
+    "start_span_no_context",
+    "trace",
+    "update_current_trace",
+    # Assessment APIs
+    "get_assessment",
+    "delete_assessment",
+    "log_assessment",
+    "update_assessment",
+    "log_expectation",
+    "log_feedback",
+    "override_feedback",
+]
+
+# Only import these modules when mlflow or mlflow-skinny is installed i.e. not importing them
+# when only mlflow-tracing is installed.
+if not IS_TRACING_SDK_ONLY:
+    from mlflow.client import MlflowClient
+
+    # For backward compatibility, we expose the following functions and classes at the top level in
+    # addition to `mlflow.config`.
+    from mlflow.config import (
+        disable_system_metrics_logging,
+        enable_system_metrics_logging,
+        get_registry_uri,
+        set_registry_uri,
+        set_system_metrics_node_id,
+        set_system_metrics_samples_before_logging,
+        set_system_metrics_sampling_interval,
+    )
+    from mlflow.models.evaluation.deprecated import evaluate
+    from mlflow.models.evaluation.validation import validate_evaluation_results
+    from mlflow.tracking._model_registry.fluent import (
+        # TODO: Prompt Registry APIs are moved to the `mlflow.genai` namespace and direct
+        # imports from mlflow will be deprecated in the future.
+        delete_prompt_alias,
+        load_prompt,
+        register_model,
+        register_prompt,
+        search_model_versions,
+        search_prompts,
+        search_registered_models,
+        set_model_version_tag,
+        set_prompt_alias,
+    )
+    from mlflow.tracking.fluent import (
+        ActiveModel,
+        ActiveRun,
+        autolog,
+        clear_active_model,
+        create_experiment,
+        create_external_model,
+        delete_experiment,
+        delete_logged_model_tag,
+        delete_run,
+        delete_tag,
+        end_run,
+        finalize_logged_model,
+        flush_artifact_async_logging,
+        flush_async_logging,
+        get_active_model_id,
+        get_artifact_uri,
+        get_experiment,
+        get_experiment_by_name,
+        get_logged_model,
+        get_metric_history,
+        get_parent_run,
+        get_run,
+        initialize_logged_model,
+        last_active_run,
+        last_logged_model,
+        load_table,
+        log_artifact,
+        log_artifacts,
+        list_artifacts,
+        log_dict,
+        log_figure,
+        log_image,
+        log_input,
+        log_inputs,
+        log_metric,
+        log_metrics,
+        log_model_params,
+        log_outputs,
+        log_param,
+        log_params,
+        log_table,
+        log_text,
+        search_experiments,
+        search_logged_models,
+        search_runs,
+        set_active_model,
+        set_experiment_tag,
+        set_experiment_tags,
+        set_logged_model_tags,
+        set_tag,
+        set_tags,
+        start_run,
+    )
+    from mlflow.tracking.multimedia import Image
+    from mlflow.utils.async_logging.run_operations import RunOperations  # noqa: F401
+    from mlflow.utils.credentials import login
+    from mlflow.utils.doctor import doctor
+
+    __all__ += [
+        "ActiveRun",
+        "ActiveModel",
+        "MlflowClient",
+        "MlflowException",
+        "autolog",
+        "clear_active_model",
+        "create_experiment",
+        "create_external_model",
+        "delete_experiment",
+        "delete_run",
+        "delete_tag",
+        "disable_system_metrics_logging",
+        "doctor",
+        "enable_system_metrics_logging",
+        "end_run",
+        "evaluate",
+        "finalize_logged_model",
+        "flush_async_logging",
+        "flush_artifact_async_logging",
+        "get_active_model_id",
+        "get_artifact_uri",
+        "get_experiment",
+        "get_experiment_by_name",
+        "get_logged_model",
+        "get_metric_history",
+        "get_parent_run",
+        "get_registry_uri",
+        "get_run",
+        "initialize_logged_model",
+        "last_active_run",
+        "last_logged_model",
+        "load_table",
+        "log_artifact",
+        "log_artifacts",
+        "list_artifacts",
+        "log_dict",
+        "log_figure",
+        "log_image",
+        "log_input",
+        "log_inputs",
+        "log_model_params",
+        "log_outputs",
+        "log_metric",
+        "log_metrics",
+        "log_param",
+        "log_params",
+        "log_table",
+        "log_text",
+        "login",
+        "pyfunc",
+        "register_model",
+        "search_experiments",
+        "search_logged_models",
+        "search_model_versions",
+        "search_registered_models",
+        "search_runs",
+        "search_prompts",
+        "set_active_model",
+        "set_experiment_tag",
+        "set_experiment_tags",
+        "set_model_version_tag",
+        "set_registry_uri",
+        "set_system_metrics_node_id",
+        "set_system_metrics_samples_before_logging",
+        "set_system_metrics_sampling_interval",
+        "set_tag",
+        "set_tags",
+        "start_run",
+        "validate_evaluation_results",
+        "Image",
+        # Prompt Registry APIs
+        # TODO: Prompt Registry APIs are moved to the `mlflow.genai` namespace and direct
+        # imports from mlflow will be deprecated in the future.
+        "load_prompt",
+        "register_prompt",
+        "search_prompts",
+        "set_prompt_alias",
+        "delete_prompt_alias",
+        "set_logged_model_tags",
+        "delete_logged_model_tag",
+    ]
+
+
+# Genesis-Flow: Gateway module removed

mlflow/__main__.py

@@ -0,0 +1,3 @@
+from mlflow.cli import cli
+
+cli.main()

mlflow/ag2/__init__.py

@@ -0,0 +1,56 @@
+from mlflow.utils.annotations import experimental
+from mlflow.utils.autologging_utils import autologging_integration
+
+FLAVOR_NAME = "ag2"
+
+
+@experimental(version="3.0.0")
+def autolog(
+    log_traces: bool = True,
+    disable: bool = False,
+    silent: bool = False,
+):
+    """
+    Enables (or disables) and configures autologging from ag2 to MLflow. Currently, MLflow
+    only supports tracing for ag2 agents.
+
+    Args:
+        log_traces: If ``True``, traces are logged for AG2 agents by using runtime logging.
+            If ``False``, no traces are collected during inference. Default to ``True``.
+        disable: If ``True``, disables the AG2 autologging. Default to ``False``.
+        silent: If ``True``, suppress all event logs and warnings from MLflow during AG2
+            autologging. If ``False``, show all events and warnings.
+    """
+    from autogen import runtime_logging
+
+    from mlflow.ag2.ag2_logger import MlflowAg2Logger
+
+    # NB: The @autologging_integration annotation is used for adding shared logic. However, one
+    # caveat is that the wrapped function is NOT executed when disable=True is passed. This prevents
+    # us from running cleaning up logging when autologging is turned off. To workaround this, we
+    # annotate _autolog() instead of this entrypoint, and define the cleanup logic outside it.
+    # TODO: since this implementation is inconsistent, explore a universal way to solve the issue.
+    if log_traces and not disable:
+        runtime_logging.start(logger=MlflowAg2Logger())
+    else:
+        runtime_logging.stop()
+
+    _autolog(log_traces=log_traces, disable=disable, silent=silent)
+
+
+# This is required by mlflow.autolog()
+autolog.integration_name = FLAVOR_NAME
+
+
+@autologging_integration(FLAVOR_NAME)
+def _autolog(
+    log_traces: bool = True,
+    disable: bool = False,
+    silent: bool = False,
+):
+    """
+    This is a dummy function only for the purpose of adding the autologging_integration annotation.
+    We cannot add the annotation directly to the autolog() function above due to the reason
+    mentioned in the comment above. Note that this function MUST declare the same signature as the
+    autolog(), otherwise the annotation will not work properly.
+    """