FM / serialization

/usr/local/lib64/python3.6/site-packages/torch/include/torch/csrc/jit/serialization/

/usr/local/lib64/python3.6/site-packages/torch/include/torch/csrc/jit/serialization

Name	Size	Mode	Actions
callstack_debug_info_serialization.h	2624	0644	edit dl rm
export.h	9839	0644	edit dl rm
import.h	3350	0644	edit dl rm
import_export_constants.h	670	0644	edit dl rm
import_export_functions.h	406	0644	edit dl rm
import_export_helpers.h	709	0644	edit dl rm
import_legacy.h	496	0644	edit dl rm
import_read.h	783	0644	edit dl rm
import_source.h	3342	0644	edit dl rm
onnx.h	229	0644	edit dl rm
pickle.h	3087	0644	edit dl rm
pickler.h	8588	0644	edit dl rm
python_print.h	1180	0644	edit dl rm
source_range_serialization.h	1198	0644	edit dl rm
source_range_serialization_impl.h	685	0644	edit dl rm
storage_context.h	2484	0644	edit dl rm
type_name_uniquer.h	779	0644	edit dl rm
unpickler.h	6434	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/include/torch/csrc/jit/serialization/import_source.h (3342B)

#pragma once

#include <ATen/core/ivalue_inl.h>
#include <ATen/core/qualified_name.h>
#include <torch/csrc/jit/api/module.h>
#include <torch/csrc/jit/frontend/parser.h>
#include <torch/csrc/jit/frontend/resolver.h>
#include <torch/csrc/jit/frontend/script_type_parser.h>
#include <torch/csrc/jit/ir/ir.h>
#include <torch/csrc/jit/serialization/export.h>
#include <torch/custom_class.h>
#include <functional>
#include <memory>
#include <regex>
#include <string>
#include <vector>

namespace torch {
namespace jit {

using SourceLoader = std::function<std::shared_ptr<Source>(const std::string&)>;

struct SourceImporterImpl : public Resolver,
                            std::enable_shared_from_this<SourceImporterImpl> {
  SourceImporterImpl(
      std::shared_ptr<CompilationUnit> cu,
      const std::vector<at::IValue>* constant_table,
      SourceLoader source_loader,
      size_t version);
  TypePtr findNamedType(const QualifiedName& name);
  Function* findFunction(const QualifiedName& name);
  void parseSourceIfNeeded(const std::string& qualifier);
  void LEGACY_import_methods(
      const Module& mod,
      const std::shared_ptr<Source>& src);

std::shared_ptr<SugaredValue> resolveValue(
      const std::string& name,
      Function& m,
      const SourceRange& loc) override;
  TypePtr resolveType(const std::string& name, const SourceRange& loc) override;

private:
  void importFunction(const std::string& qualifier, const Def& def);
  void importNamedType(const std::string& qualifier, const ClassDef& class_def);
  c10::optional<Assign> attributeAssignmentSpecialHandlingHack(
      const QualifiedName& qualified_classname,
      const Assign& assign);
  void importClass(
      const QualifiedName& qualified_classname,
      const ClassDef& class_def,
      bool is_module);
  void importEnum(
      const QualifiedName& qualified_name,
      const ClassDef& enum_def);
  void importNamedTuple(
      const QualifiedName& qualified_name,
      const ClassDef& named_tuple_def);

void parsePossibleVersionNumber(Lexer& L);

void parseImports(Lexer& L);

std::shared_ptr<CompilationUnit> cu_;
  std::unordered_map<std::string, std::shared_ptr<SugaredValue>> env_;
  SourceLoader source_loader_;
  std::unordered_set<std::string> loaded_sources_;
  // named types and functions loaded from a file but not yet defined because
  // their type has not been requested yet.
  std::unordered_map<QualifiedName, TreeRef> to_be_defined_;
};

// Given a directory of serialized TorchScript sources,
// This class allows the loading of individual named types in source.
// Resolves the dependencies between source files and parses
// the source files as necessary.

struct TORCH_API SourceImporter {
  SourceImporter(
      // The compilation unit that will own the imported source
      std::shared_ptr<CompilationUnit> cu,
      const std::vector<at::IValue>* constant_table,
      SourceLoader loader,
      size_t version);

TypePtr loadType(const QualifiedName& name) const;

// Add the methods defined in `src` to the module `mod`, using SourceImporter
  // to resolve any classes via loadType
  void LEGACY_import_methods(
      const Module& mod,
      const std::shared_ptr<Source>& src);
  ~SourceImporter();

private:
  std::shared_ptr<SourceImporterImpl> pImpl;
};

} // namespace jit
} // namespace torch

#pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace torch { namespace jit { using SourceLoader = std::function(const std::string&)>; struct SourceImporterImpl : public Resolver, std::enable_shared_from_this { SourceImporterImpl( std::shared_ptr cu, const std::vector* constant_table, SourceLoader source_loader, size_t version); TypePtr findNamedType(const QualifiedName& name); Function* findFunction(const QualifiedName& name); void parseSourceIfNeeded(const std::string& qualifier); void LEGACY_import_methods( const Module& mod, const std::shared_ptr& src); std::shared_ptr resolveValue( const std::string& name, Function& m, const SourceRange& loc) override; TypePtr resolveType(const std::string& name, const SourceRange& loc) override; private: void importFunction(const std::string& qualifier, const Def& def); void importNamedType(const std::string& qualifier, const ClassDef& class_def); c10::optional attributeAssignmentSpecialHandlingHack( const QualifiedName& qualified_classname, const Assign& assign); void importClass( const QualifiedName& qualified_classname, const ClassDef& class_def, bool is_module); void importEnum( const QualifiedName& qualified_name, const ClassDef& enum_def); void importNamedTuple( const QualifiedName& qualified_name, const ClassDef& named_tuple_def); void parsePossibleVersionNumber(Lexer& L); void parseImports(Lexer& L); std::shared_ptr cu_; std::unordered_map> env_; SourceLoader source_loader_; std::unordered_set loaded_sources_; // named types and functions loaded from a file but not yet defined because // their type has not been requested yet. std::unordered_map to_be_defined_; }; // Given a directory of serialized TorchScript sources, // This class allows the loading of individual named types in source. // Resolves the dependencies between source files and parses // the source files as necessary. struct TORCH_API SourceImporter { SourceImporter( // The compilation unit that will own the imported source std::shared_ptr cu, const std::vector* constant_table, SourceLoader loader, size_t version); TypePtr loadType(const QualifiedName& name) const; // Add the methods defined in `src` to the module `mod`, using SourceImporter // to resolve any classes via loadType void LEGACY_import_methods( const Module& mod, const std::shared_ptr& src); ~SourceImporter(); private: std::shared_ptr pImpl; }; } // namespace jit } // namespace torch